mozilla-central/__GENERATED__/ipc/ipdl/PFileSystemManager.cpp (file symbol)

Copy as Markdown

Other Tools

//
// Automatically generated by ipdlc.
// Edit at your own risk
//
#include "mozilla/dom/PFileSystemAccessHandleParent.h"
#include "mozilla/dom/PFileSystemAccessHandleChild.h"
#include "mozilla/dom/PFileSystemAccessHandleControlParent.h"
#include "mozilla/dom/PFileSystemAccessHandleControlChild.h"
#include "mozilla/dom/PFileSystemWritableFileStreamParent.h"
#include "mozilla/dom/PFileSystemWritableFileStreamChild.h"
#include "mozilla/dom/PFileSystemManager.h"
#include "mozilla/dom/PFileSystemManagerParent.h"
#include "mozilla/dom/PFileSystemManagerChild.h"
#include "ipc/IPCMessageUtils.h"
#include "ipc/IPCMessageUtilsSpecializations.h"
#include "nsIFile.h"
#include "mozilla/ipc/Endpoint.h"
#include "mozilla/ipc/ProtocolMessageUtils.h"
#include "mozilla/ipc/ProtocolUtils.h"
#include "mozilla/ipc/ShmemMessageUtils.h"
#include "mozilla/ipc/TaintingIPCUtils.h"
namespace mozilla {
namespace dom {
namespace PFileSystemManager {
nsresult
CreateEndpoints(
base::ProcessId aParentDestPid,
base::ProcessId aChildDestPid,
mozilla::ipc::Endpoint<::mozilla::dom::PFileSystemManagerParent>* aParent,
mozilla::ipc::Endpoint<::mozilla::dom::PFileSystemManagerChild>* aChild)
{
return mozilla::ipc::CreateEndpoints(
mozilla::ipc::PrivateIPDLInterface(),
aParentDestPid, aChildDestPid, aParent, aChild);
}
nsresult
CreateEndpoints(
mozilla::ipc::Endpoint<::mozilla::dom::PFileSystemManagerParent>* aParent,
mozilla::ipc::Endpoint<::mozilla::dom::PFileSystemManagerChild>* aChild)
{
return mozilla::ipc::CreateEndpoints(
mozilla::ipc::PrivateIPDLInterface(),
aParent, aChild);
}
mozilla::UniquePtr<IPC::Message>
Msg_GetRootHandle(int32_t routingId)
{
return IPC::Message::IPDLMessage(routingId, Msg_GetRootHandle__ID, 0, IPC::Message::HeaderFlags(IPC::Message::NOT_NESTED, IPC::Message::NORMAL_PRIORITY, IPC::Message::COMPRESSION_NONE, IPC::Message::EAGER_SEND, IPC::Message::NOT_CONSTRUCTOR, IPC::Message::ASYNC, IPC::Message::NOT_REPLY));
}
mozilla::UniquePtr<IPC::Message>
Reply_GetRootHandle(int32_t routingId)
{
return IPC::Message::IPDLMessage(routingId, Reply_GetRootHandle__ID, 0, IPC::Message::HeaderFlags(IPC::Message::NOT_NESTED, IPC::Message::NORMAL_PRIORITY, IPC::Message::COMPRESSION_NONE, IPC::Message::EAGER_SEND, IPC::Message::NOT_CONSTRUCTOR, IPC::Message::ASYNC, IPC::Message::REPLY));
}
mozilla::UniquePtr<IPC::Message>
Msg_GetDirectoryHandle(int32_t routingId)
{
return IPC::Message::IPDLMessage(routingId, Msg_GetDirectoryHandle__ID, 0, IPC::Message::HeaderFlags(IPC::Message::NOT_NESTED, IPC::Message::NORMAL_PRIORITY, IPC::Message::COMPRESSION_NONE, IPC::Message::EAGER_SEND, IPC::Message::NOT_CONSTRUCTOR, IPC::Message::ASYNC, IPC::Message::NOT_REPLY));
}
mozilla::UniquePtr<IPC::Message>
Reply_GetDirectoryHandle(int32_t routingId)
{
return IPC::Message::IPDLMessage(routingId, Reply_GetDirectoryHandle__ID, 0, IPC::Message::HeaderFlags(IPC::Message::NOT_NESTED, IPC::Message::NORMAL_PRIORITY, IPC::Message::COMPRESSION_NONE, IPC::Message::EAGER_SEND, IPC::Message::NOT_CONSTRUCTOR, IPC::Message::ASYNC, IPC::Message::REPLY));
}
mozilla::UniquePtr<IPC::Message>
Msg_GetFileHandle(int32_t routingId)
{
return IPC::Message::IPDLMessage(routingId, Msg_GetFileHandle__ID, 0, IPC::Message::HeaderFlags(IPC::Message::NOT_NESTED, IPC::Message::NORMAL_PRIORITY, IPC::Message::COMPRESSION_NONE, IPC::Message::EAGER_SEND, IPC::Message::NOT_CONSTRUCTOR, IPC::Message::ASYNC, IPC::Message::NOT_REPLY));
}
mozilla::UniquePtr<IPC::Message>
Reply_GetFileHandle(int32_t routingId)
{
return IPC::Message::IPDLMessage(routingId, Reply_GetFileHandle__ID, 0, IPC::Message::HeaderFlags(IPC::Message::NOT_NESTED, IPC::Message::NORMAL_PRIORITY, IPC::Message::COMPRESSION_NONE, IPC::Message::EAGER_SEND, IPC::Message::NOT_CONSTRUCTOR, IPC::Message::ASYNC, IPC::Message::REPLY));
}
mozilla::UniquePtr<IPC::Message>
Msg_GetFile(int32_t routingId)
{
return IPC::Message::IPDLMessage(routingId, Msg_GetFile__ID, 0, IPC::Message::HeaderFlags(IPC::Message::NOT_NESTED, IPC::Message::NORMAL_PRIORITY, IPC::Message::COMPRESSION_NONE, IPC::Message::EAGER_SEND, IPC::Message::NOT_CONSTRUCTOR, IPC::Message::ASYNC, IPC::Message::NOT_REPLY));
}
mozilla::UniquePtr<IPC::Message>
Reply_GetFile(int32_t routingId)
{
return IPC::Message::IPDLMessage(routingId, Reply_GetFile__ID, 0, IPC::Message::HeaderFlags(IPC::Message::NOT_NESTED, IPC::Message::NORMAL_PRIORITY, IPC::Message::COMPRESSION_NONE, IPC::Message::EAGER_SEND, IPC::Message::NOT_CONSTRUCTOR, IPC::Message::ASYNC, IPC::Message::REPLY));
}
mozilla::UniquePtr<IPC::Message>
Msg_GetAccessHandle(int32_t routingId)
{
return IPC::Message::IPDLMessage(routingId, Msg_GetAccessHandle__ID, 0, IPC::Message::HeaderFlags(IPC::Message::NOT_NESTED, IPC::Message::NORMAL_PRIORITY, IPC::Message::COMPRESSION_NONE, IPC::Message::EAGER_SEND, IPC::Message::NOT_CONSTRUCTOR, IPC::Message::ASYNC, IPC::Message::NOT_REPLY));
}
mozilla::UniquePtr<IPC::Message>
Reply_GetAccessHandle(int32_t routingId)
{
return IPC::Message::IPDLMessage(routingId, Reply_GetAccessHandle__ID, 0, IPC::Message::HeaderFlags(IPC::Message::NOT_NESTED, IPC::Message::NORMAL_PRIORITY, IPC::Message::COMPRESSION_NONE, IPC::Message::EAGER_SEND, IPC::Message::NOT_CONSTRUCTOR, IPC::Message::ASYNC, IPC::Message::REPLY));
}
mozilla::UniquePtr<IPC::Message>
Msg_GetWritable(int32_t routingId)
{
return IPC::Message::IPDLMessage(routingId, Msg_GetWritable__ID, 0, IPC::Message::HeaderFlags(IPC::Message::NOT_NESTED, IPC::Message::NORMAL_PRIORITY, IPC::Message::COMPRESSION_NONE, IPC::Message::EAGER_SEND, IPC::Message::NOT_CONSTRUCTOR, IPC::Message::ASYNC, IPC::Message::NOT_REPLY));
}
mozilla::UniquePtr<IPC::Message>
Reply_GetWritable(int32_t routingId)
{
return IPC::Message::IPDLMessage(routingId, Reply_GetWritable__ID, 0, IPC::Message::HeaderFlags(IPC::Message::NOT_NESTED, IPC::Message::NORMAL_PRIORITY, IPC::Message::COMPRESSION_NONE, IPC::Message::EAGER_SEND, IPC::Message::NOT_CONSTRUCTOR, IPC::Message::ASYNC, IPC::Message::REPLY));
}
mozilla::UniquePtr<IPC::Message>
Msg_Resolve(int32_t routingId)
{
return IPC::Message::IPDLMessage(routingId, Msg_Resolve__ID, 0, IPC::Message::HeaderFlags(IPC::Message::NOT_NESTED, IPC::Message::NORMAL_PRIORITY, IPC::Message::COMPRESSION_NONE, IPC::Message::EAGER_SEND, IPC::Message::NOT_CONSTRUCTOR, IPC::Message::ASYNC, IPC::Message::NOT_REPLY));
}
mozilla::UniquePtr<IPC::Message>
Reply_Resolve(int32_t routingId)
{
return IPC::Message::IPDLMessage(routingId, Reply_Resolve__ID, 0, IPC::Message::HeaderFlags(IPC::Message::NOT_NESTED, IPC::Message::NORMAL_PRIORITY, IPC::Message::COMPRESSION_NONE, IPC::Message::EAGER_SEND, IPC::Message::NOT_CONSTRUCTOR, IPC::Message::ASYNC, IPC::Message::REPLY));
}
mozilla::UniquePtr<IPC::Message>
Msg_GetEntries(int32_t routingId)
{
return IPC::Message::IPDLMessage(routingId, Msg_GetEntries__ID, 0, IPC::Message::HeaderFlags(IPC::Message::NOT_NESTED, IPC::Message::NORMAL_PRIORITY, IPC::Message::COMPRESSION_NONE, IPC::Message::EAGER_SEND, IPC::Message::NOT_CONSTRUCTOR, IPC::Message::ASYNC, IPC::Message::NOT_REPLY));
}
mozilla::UniquePtr<IPC::Message>
Reply_GetEntries(int32_t routingId)
{
return IPC::Message::IPDLMessage(routingId, Reply_GetEntries__ID, 0, IPC::Message::HeaderFlags(IPC::Message::NOT_NESTED, IPC::Message::NORMAL_PRIORITY, IPC::Message::COMPRESSION_NONE, IPC::Message::EAGER_SEND, IPC::Message::NOT_CONSTRUCTOR, IPC::Message::ASYNC, IPC::Message::REPLY));
}
mozilla::UniquePtr<IPC::Message>
Msg_RemoveEntry(int32_t routingId)
{
return IPC::Message::IPDLMessage(routingId, Msg_RemoveEntry__ID, 0, IPC::Message::HeaderFlags(IPC::Message::NOT_NESTED, IPC::Message::NORMAL_PRIORITY, IPC::Message::COMPRESSION_NONE, IPC::Message::EAGER_SEND, IPC::Message::NOT_CONSTRUCTOR, IPC::Message::ASYNC, IPC::Message::NOT_REPLY));
}
mozilla::UniquePtr<IPC::Message>
Reply_RemoveEntry(int32_t routingId)
{
return IPC::Message::IPDLMessage(routingId, Reply_RemoveEntry__ID, 0, IPC::Message::HeaderFlags(IPC::Message::NOT_NESTED, IPC::Message::NORMAL_PRIORITY, IPC::Message::COMPRESSION_NONE, IPC::Message::EAGER_SEND, IPC::Message::NOT_CONSTRUCTOR, IPC::Message::ASYNC, IPC::Message::REPLY));
}
mozilla::UniquePtr<IPC::Message>
Msg_MoveEntry(int32_t routingId)
{
return IPC::Message::IPDLMessage(routingId, Msg_MoveEntry__ID, 0, IPC::Message::HeaderFlags(IPC::Message::NOT_NESTED, IPC::Message::NORMAL_PRIORITY, IPC::Message::COMPRESSION_NONE, IPC::Message::EAGER_SEND, IPC::Message::NOT_CONSTRUCTOR, IPC::Message::ASYNC, IPC::Message::NOT_REPLY));
}
mozilla::UniquePtr<IPC::Message>
Reply_MoveEntry(int32_t routingId)
{
return IPC::Message::IPDLMessage(routingId, Reply_MoveEntry__ID, 0, IPC::Message::HeaderFlags(IPC::Message::NOT_NESTED, IPC::Message::NORMAL_PRIORITY, IPC::Message::COMPRESSION_NONE, IPC::Message::EAGER_SEND, IPC::Message::NOT_CONSTRUCTOR, IPC::Message::ASYNC, IPC::Message::REPLY));
}
mozilla::UniquePtr<IPC::Message>
Msg_RenameEntry(int32_t routingId)
{
return IPC::Message::IPDLMessage(routingId, Msg_RenameEntry__ID, 0, IPC::Message::HeaderFlags(IPC::Message::NOT_NESTED, IPC::Message::NORMAL_PRIORITY, IPC::Message::COMPRESSION_NONE, IPC::Message::EAGER_SEND, IPC::Message::NOT_CONSTRUCTOR, IPC::Message::ASYNC, IPC::Message::NOT_REPLY));
}
mozilla::UniquePtr<IPC::Message>
Reply_RenameEntry(int32_t routingId)
{
return IPC::Message::IPDLMessage(routingId, Reply_RenameEntry__ID, 0, IPC::Message::HeaderFlags(IPC::Message::NOT_NESTED, IPC::Message::NORMAL_PRIORITY, IPC::Message::COMPRESSION_NONE, IPC::Message::EAGER_SEND, IPC::Message::NOT_CONSTRUCTOR, IPC::Message::ASYNC, IPC::Message::REPLY));
}
mozilla::UniquePtr<IPC::Message>
Msg_PFileSystemWritableFileStreamConstructor(int32_t routingId)
{
return IPC::Message::IPDLMessage(routingId, Msg_PFileSystemWritableFileStreamConstructor__ID, 0, IPC::Message::HeaderFlags(IPC::Message::NOT_NESTED, IPC::Message::NORMAL_PRIORITY, IPC::Message::COMPRESSION_NONE, IPC::Message::EAGER_SEND, IPC::Message::CONSTRUCTOR, IPC::Message::ASYNC, IPC::Message::NOT_REPLY));
}
mozilla::UniquePtr<IPC::Message>
Reply_PFileSystemWritableFileStreamConstructor(int32_t routingId)
{
return IPC::Message::IPDLMessage(routingId, Reply_PFileSystemWritableFileStreamConstructor__ID, 0, IPC::Message::HeaderFlags(IPC::Message::NOT_NESTED, IPC::Message::NORMAL_PRIORITY, IPC::Message::COMPRESSION_NONE, IPC::Message::EAGER_SEND, IPC::Message::CONSTRUCTOR, IPC::Message::ASYNC, IPC::Message::REPLY));
}
mozilla::UniquePtr<IPC::Message>
Msg_CloseAll(int32_t routingId)
{
return IPC::Message::IPDLMessage(routingId, Msg_CloseAll__ID, 0, IPC::Message::HeaderFlags(IPC::Message::NOT_NESTED, IPC::Message::NORMAL_PRIORITY, IPC::Message::COMPRESSION_NONE, IPC::Message::EAGER_SEND, IPC::Message::NOT_CONSTRUCTOR, IPC::Message::ASYNC, IPC::Message::NOT_REPLY));
}
mozilla::UniquePtr<IPC::Message>
Reply_CloseAll(int32_t routingId)
{
return IPC::Message::IPDLMessage(routingId, Reply_CloseAll__ID, 0, IPC::Message::HeaderFlags(IPC::Message::NOT_NESTED, IPC::Message::NORMAL_PRIORITY, IPC::Message::COMPRESSION_NONE, IPC::Message::EAGER_SEND, IPC::Message::NOT_CONSTRUCTOR, IPC::Message::ASYNC, IPC::Message::REPLY));
}
} // namespace PFileSystemManager
} // namespace dom
} // namespace mozilla
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct FileSystemEntryMetadata|
//
namespace mozilla {
namespace dom {
namespace fs {
} // namespace fs
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::fs::FileSystemEntryMetadata>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).entryId());
// Sentinel = 'entryId'
(aWriter)->WriteSentinel(197853920);
IPC::WriteParam(aWriter, (aVar).entryName());
// Sentinel = 'entryName'
(aWriter)->WriteSentinel(315950004);
IPC::WriteParam(aWriter, (aVar).directory());
// Sentinel = 'directory'
(aWriter)->WriteSentinel(314180566);
}
auto ParamTraits<::mozilla::dom::fs::FileSystemEntryMetadata>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___entryId = IPC::ReadParam<::mozilla::dom::fs::EntryId>(aReader);
if (!maybe___entryId) {
aReader->FatalError("Error deserializing 'entryId' (EntryId) member of 'FileSystemEntryMetadata'");
return {};
}
auto& _entryId = *maybe___entryId;
// Sentinel = 'entryId'
if ((!((aReader)->ReadSentinel(197853920)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'entryId' (EntryId) member of 'FileSystemEntryMetadata'");
return {};
}
auto maybe___entryName = IPC::ReadParam<::mozilla::dom::fs::Name>(aReader);
if (!maybe___entryName) {
aReader->FatalError("Error deserializing 'entryName' (Name) member of 'FileSystemEntryMetadata'");
return {};
}
auto& _entryName = *maybe___entryName;
// Sentinel = 'entryName'
if ((!((aReader)->ReadSentinel(315950004)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'entryName' (Name) member of 'FileSystemEntryMetadata'");
return {};
}
auto maybe___directory = IPC::ReadParam<bool>(aReader);
if (!maybe___directory) {
aReader->FatalError("Error deserializing 'directory' (bool) member of 'FileSystemEntryMetadata'");
return {};
}
auto& _directory = *maybe___directory;
// Sentinel = 'directory'
if ((!((aReader)->ReadSentinel(314180566)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'directory' (bool) member of 'FileSystemEntryMetadata'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_entryId),
std::move(_entryName),
std::move(_directory)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct FileSystemChildMetadata|
//
namespace mozilla {
namespace dom {
namespace fs {
} // namespace fs
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::fs::FileSystemChildMetadata>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).parentId());
// Sentinel = 'parentId'
(aWriter)->WriteSentinel(249430840);
IPC::WriteParam(aWriter, (aVar).childName());
// Sentinel = 'childName'
(aWriter)->WriteSentinel(297337734);
}
auto ParamTraits<::mozilla::dom::fs::FileSystemChildMetadata>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___parentId = IPC::ReadParam<::mozilla::dom::fs::EntryId>(aReader);
if (!maybe___parentId) {
aReader->FatalError("Error deserializing 'parentId' (EntryId) member of 'FileSystemChildMetadata'");
return {};
}
auto& _parentId = *maybe___parentId;
// Sentinel = 'parentId'
if ((!((aReader)->ReadSentinel(249430840)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'parentId' (EntryId) member of 'FileSystemChildMetadata'");
return {};
}
auto maybe___childName = IPC::ReadParam<::mozilla::dom::fs::Name>(aReader);
if (!maybe___childName) {
aReader->FatalError("Error deserializing 'childName' (Name) member of 'FileSystemChildMetadata'");
return {};
}
auto& _childName = *maybe___childName;
// Sentinel = 'childName'
if ((!((aReader)->ReadSentinel(297337734)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'childName' (Name) member of 'FileSystemChildMetadata'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_parentId),
std::move(_childName)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct FileSystemGetHandleRequest|
//
namespace mozilla {
namespace dom {
namespace fs {
} // namespace fs
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::fs::FileSystemGetHandleRequest>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).handle());
// Sentinel = 'handle'
(aWriter)->WriteSentinel(142344813);
IPC::WriteParam(aWriter, (aVar).create());
// Sentinel = 'create'
(aWriter)->WriteSentinel(144048757);
}
auto ParamTraits<::mozilla::dom::fs::FileSystemGetHandleRequest>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___handle = IPC::ReadParam<::mozilla::dom::fs::FileSystemChildMetadata>(aReader);
if (!maybe___handle) {
aReader->FatalError("Error deserializing 'handle' (FileSystemChildMetadata) member of 'FileSystemGetHandleRequest'");
return {};
}
auto& _handle = *maybe___handle;
// Sentinel = 'handle'
if ((!((aReader)->ReadSentinel(142344813)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'handle' (FileSystemChildMetadata) member of 'FileSystemGetHandleRequest'");
return {};
}
auto maybe___create = IPC::ReadParam<bool>(aReader);
if (!maybe___create) {
aReader->FatalError("Error deserializing 'create' (bool) member of 'FileSystemGetHandleRequest'");
return {};
}
auto& _create = *maybe___create;
// Sentinel = 'create'
if ((!((aReader)->ReadSentinel(144048757)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'create' (bool) member of 'FileSystemGetHandleRequest'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_handle),
std::move(_create)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |union FileSystemGetHandleResponse|
//
namespace mozilla {
namespace dom {
namespace fs {
auto FileSystemGetHandleResponse::MaybeDestroy() -> void
{
if ((mType) == (T__None)) {
return;
}
switch (mType) {
case Tnsresult:
{
(ptr_nsresult())->~nsresult__tdef();
break;
}
case TEntryId:
{
(ptr_EntryId())->~EntryId__tdef();
break;
}
default:
{
mozilla::ipc::LogicError("not reached");
break;
}
}
}
MOZ_IMPLICIT FileSystemGetHandleResponse::FileSystemGetHandleResponse(const nsresult& aOther)
{
new (mozilla::KnownNotNull, ptr_nsresult()) nsresult(aOther);
mType = Tnsresult;
}
MOZ_IMPLICIT FileSystemGetHandleResponse::FileSystemGetHandleResponse(nsresult&& aOther)
{
new (mozilla::KnownNotNull, ptr_nsresult()) nsresult(std::move(aOther));
mType = Tnsresult;
}
MOZ_IMPLICIT FileSystemGetHandleResponse::FileSystemGetHandleResponse(const EntryId& aOther)
{
new (mozilla::KnownNotNull, ptr_EntryId()) EntryId(aOther);
mType = TEntryId;
}
MOZ_IMPLICIT FileSystemGetHandleResponse::FileSystemGetHandleResponse(EntryId&& aOther)
{
new (mozilla::KnownNotNull, ptr_EntryId()) EntryId(std::move(aOther));
mType = TEntryId;
}
MOZ_IMPLICIT FileSystemGetHandleResponse::FileSystemGetHandleResponse(const FileSystemGetHandleResponse& aOther)
{
(aOther).AssertSanity();
switch ((aOther).type()) {
case Tnsresult:
{
new (mozilla::KnownNotNull, ptr_nsresult()) nsresult((aOther).get_nsresult());
break;
}
case TEntryId:
{
new (mozilla::KnownNotNull, ptr_EntryId()) EntryId((aOther).get_EntryId());
break;
}
case T__None:
{
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
return;
}
}
mType = (aOther).type();
}
MOZ_IMPLICIT FileSystemGetHandleResponse::FileSystemGetHandleResponse(FileSystemGetHandleResponse&& aOther)
{
(aOther).AssertSanity();
Type t = (aOther).type();
switch (t) {
case Tnsresult:
{
new (mozilla::KnownNotNull, ptr_nsresult()) nsresult(std::move((aOther).get_nsresult()));
(aOther).MaybeDestroy();
break;
}
case TEntryId:
{
new (mozilla::KnownNotNull, ptr_EntryId()) EntryId(std::move((aOther).get_EntryId()));
(aOther).MaybeDestroy();
break;
}
case T__None:
{
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
return;
}
}
(aOther).mType = T__None;
mType = t;
}
FileSystemGetHandleResponse::~FileSystemGetHandleResponse()
{
MaybeDestroy();
}
auto FileSystemGetHandleResponse::operator=(const nsresult& aRhs) -> FileSystemGetHandleResponse&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_nsresult()) nsresult(aRhs);
mType = Tnsresult;
return (*(this));
}
auto FileSystemGetHandleResponse::operator=(nsresult&& aRhs) -> FileSystemGetHandleResponse&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_nsresult()) nsresult(std::move(aRhs));
mType = Tnsresult;
return (*(this));
}
auto FileSystemGetHandleResponse::operator=(const EntryId& aRhs) -> FileSystemGetHandleResponse&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_EntryId()) EntryId(aRhs);
mType = TEntryId;
return (*(this));
}
auto FileSystemGetHandleResponse::operator=(EntryId&& aRhs) -> FileSystemGetHandleResponse&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_EntryId()) EntryId(std::move(aRhs));
mType = TEntryId;
return (*(this));
}
auto FileSystemGetHandleResponse::operator=(const FileSystemGetHandleResponse& aRhs) -> FileSystemGetHandleResponse&
{
(aRhs).AssertSanity();
Type t = (aRhs).type();
switch (t) {
case Tnsresult:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_nsresult()) nsresult((aRhs).get_nsresult());
break;
}
case TEntryId:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_EntryId()) EntryId((aRhs).get_EntryId());
break;
}
case T__None:
{
MaybeDestroy();
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
break;
}
}
mType = t;
return (*(this));
}
auto FileSystemGetHandleResponse::operator=(FileSystemGetHandleResponse&& aRhs) -> FileSystemGetHandleResponse&
{
(aRhs).AssertSanity();
Type t = (aRhs).type();
switch (t) {
case Tnsresult:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_nsresult()) nsresult(std::move((aRhs).get_nsresult()));
(aRhs).MaybeDestroy();
break;
}
case TEntryId:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_EntryId()) EntryId(std::move((aRhs).get_EntryId()));
(aRhs).MaybeDestroy();
break;
}
case T__None:
{
MaybeDestroy();
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
break;
}
}
(aRhs).mType = T__None;
mType = t;
return (*(this));
}
} // namespace fs
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::fs::FileSystemGetHandleResponse>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
typedef ::mozilla::dom::fs::FileSystemGetHandleResponse union__;
int type = (aVar).type();
IPC::WriteParam(aWriter, type);
// Sentinel = 'FileSystemGetHandleResponse'
(aWriter)->WriteSentinel(2484931265);
switch (type) {
case union__::Tnsresult:
{
IPC::WriteParam(aWriter, (aVar).get_nsresult());
// Sentinel = 'Tnsresult'
(aWriter)->WriteSentinel(313394133);
return;
}
case union__::TEntryId:
{
IPC::WriteParam(aWriter, (aVar).get_EntryId());
// Sentinel = 'TEntryId'
(aWriter)->WriteSentinel(227279636);
return;
}
default:
{
aWriter->FatalError("unknown variant of union FileSystemGetHandleResponse");
return;
}
}
}
auto ParamTraits<::mozilla::dom::fs::FileSystemGetHandleResponse>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
typedef ::mozilla::dom::fs::FileSystemGetHandleResponse union__;
auto maybe__type = IPC::ReadParam<int>(aReader);
if (!maybe__type) {
aReader->FatalError("Error deserializing type of union FileSystemGetHandleResponse");
return {};
}
auto& type = *maybe__type;
// Sentinel = 'FileSystemGetHandleResponse'
if ((!((aReader)->ReadSentinel(2484931265)))) {
mozilla::ipc::SentinelReadError("Error deserializing type of union FileSystemGetHandleResponse");
return {};
}
switch (type) {
case union__::Tnsresult:
{
auto maybe__tmp = IPC::ReadParam<::nsresult>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant Tnsresult of union FileSystemGetHandleResponse");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'Tnsresult'
if ((!((aReader)->ReadSentinel(313394133)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant Tnsresult of union FileSystemGetHandleResponse");
return {};
}
return std::move(tmp);
}
case union__::TEntryId:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::dom::fs::EntryId>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TEntryId of union FileSystemGetHandleResponse");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TEntryId'
if ((!((aReader)->ReadSentinel(227279636)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TEntryId of union FileSystemGetHandleResponse");
return {};
}
return std::move(tmp);
}
default:
{
aReader->FatalError("unknown variant of union FileSystemGetHandleResponse");
return {};
}
}
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct FileSystemGetEntriesRequest|
//
namespace mozilla {
namespace dom {
namespace fs {
} // namespace fs
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::fs::FileSystemGetEntriesRequest>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).parentId());
// Sentinel = 'parentId'
(aWriter)->WriteSentinel(249430840);
IPC::WriteParam(aWriter, (aVar).page());
// Sentinel = 'page'
(aWriter)->WriteSentinel(68813214);
}
auto ParamTraits<::mozilla::dom::fs::FileSystemGetEntriesRequest>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___parentId = IPC::ReadParam<::mozilla::dom::fs::EntryId>(aReader);
if (!maybe___parentId) {
aReader->FatalError("Error deserializing 'parentId' (EntryId) member of 'FileSystemGetEntriesRequest'");
return {};
}
auto& _parentId = *maybe___parentId;
// Sentinel = 'parentId'
if ((!((aReader)->ReadSentinel(249430840)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'parentId' (EntryId) member of 'FileSystemGetEntriesRequest'");
return {};
}
auto maybe___page = IPC::ReadParam<::mozilla::dom::fs::PageNumber>(aReader);
if (!maybe___page) {
aReader->FatalError("Error deserializing 'page' (PageNumber) member of 'FileSystemGetEntriesRequest'");
return {};
}
auto& _page = *maybe___page;
// Sentinel = 'page'
if ((!((aReader)->ReadSentinel(68813214)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'page' (PageNumber) member of 'FileSystemGetEntriesRequest'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_parentId),
std::move(_page)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct FileSystemDirectoryListing|
//
namespace mozilla {
namespace dom {
namespace fs {
} // namespace fs
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::fs::FileSystemDirectoryListing>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).directories());
// Sentinel = 'directories'
(aWriter)->WriteSentinel(460522654);
IPC::WriteParam(aWriter, (aVar).files());
// Sentinel = 'files'
(aWriter)->WriteSentinel(103285268);
}
auto ParamTraits<::mozilla::dom::fs::FileSystemDirectoryListing>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___directories = IPC::ReadParam<nsTArray<::mozilla::dom::fs::FileSystemEntryMetadata>>(aReader);
if (!maybe___directories) {
aReader->FatalError("Error deserializing 'directories' (FileSystemEntryMetadata[]) member of 'FileSystemDirectoryListing'");
return {};
}
auto& _directories = *maybe___directories;
// Sentinel = 'directories'
if ((!((aReader)->ReadSentinel(460522654)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'directories' (FileSystemEntryMetadata[]) member of 'FileSystemDirectoryListing'");
return {};
}
auto maybe___files = IPC::ReadParam<nsTArray<::mozilla::dom::fs::FileSystemEntryMetadata>>(aReader);
if (!maybe___files) {
aReader->FatalError("Error deserializing 'files' (FileSystemEntryMetadata[]) member of 'FileSystemDirectoryListing'");
return {};
}
auto& _files = *maybe___files;
// Sentinel = 'files'
if ((!((aReader)->ReadSentinel(103285268)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'files' (FileSystemEntryMetadata[]) member of 'FileSystemDirectoryListing'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_directories),
std::move(_files)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |union FileSystemGetEntriesResponse|
//
namespace mozilla {
namespace dom {
namespace fs {
auto FileSystemGetEntriesResponse::MaybeDestroy() -> void
{
if ((mType) == (T__None)) {
return;
}
switch (mType) {
case Tnsresult:
{
(ptr_nsresult())->~nsresult__tdef();
break;
}
case TFileSystemDirectoryListing:
{
(ptr_FileSystemDirectoryListing())->~FileSystemDirectoryListing__tdef();
break;
}
default:
{
mozilla::ipc::LogicError("not reached");
break;
}
}
}
MOZ_IMPLICIT FileSystemGetEntriesResponse::FileSystemGetEntriesResponse(const nsresult& aOther)
{
new (mozilla::KnownNotNull, ptr_nsresult()) nsresult(aOther);
mType = Tnsresult;
}
MOZ_IMPLICIT FileSystemGetEntriesResponse::FileSystemGetEntriesResponse(nsresult&& aOther)
{
new (mozilla::KnownNotNull, ptr_nsresult()) nsresult(std::move(aOther));
mType = Tnsresult;
}
MOZ_IMPLICIT FileSystemGetEntriesResponse::FileSystemGetEntriesResponse(const FileSystemDirectoryListing& aOther)
{
new (mozilla::KnownNotNull, ptr_FileSystemDirectoryListing()) FileSystemDirectoryListing(aOther);
mType = TFileSystemDirectoryListing;
}
MOZ_IMPLICIT FileSystemGetEntriesResponse::FileSystemGetEntriesResponse(FileSystemDirectoryListing&& aOther)
{
new (mozilla::KnownNotNull, ptr_FileSystemDirectoryListing()) FileSystemDirectoryListing(std::move(aOther));
mType = TFileSystemDirectoryListing;
}
MOZ_IMPLICIT FileSystemGetEntriesResponse::FileSystemGetEntriesResponse(const FileSystemGetEntriesResponse& aOther)
{
(aOther).AssertSanity();
switch ((aOther).type()) {
case Tnsresult:
{
new (mozilla::KnownNotNull, ptr_nsresult()) nsresult((aOther).get_nsresult());
break;
}
case TFileSystemDirectoryListing:
{
new (mozilla::KnownNotNull, ptr_FileSystemDirectoryListing()) FileSystemDirectoryListing((aOther).get_FileSystemDirectoryListing());
break;
}
case T__None:
{
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
return;
}
}
mType = (aOther).type();
}
MOZ_IMPLICIT FileSystemGetEntriesResponse::FileSystemGetEntriesResponse(FileSystemGetEntriesResponse&& aOther)
{
(aOther).AssertSanity();
Type t = (aOther).type();
switch (t) {
case Tnsresult:
{
new (mozilla::KnownNotNull, ptr_nsresult()) nsresult(std::move((aOther).get_nsresult()));
(aOther).MaybeDestroy();
break;
}
case TFileSystemDirectoryListing:
{
new (mozilla::KnownNotNull, ptr_FileSystemDirectoryListing()) FileSystemDirectoryListing(std::move((aOther).get_FileSystemDirectoryListing()));
(aOther).MaybeDestroy();
break;
}
case T__None:
{
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
return;
}
}
(aOther).mType = T__None;
mType = t;
}
FileSystemGetEntriesResponse::~FileSystemGetEntriesResponse()
{
MaybeDestroy();
}
auto FileSystemGetEntriesResponse::operator=(const nsresult& aRhs) -> FileSystemGetEntriesResponse&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_nsresult()) nsresult(aRhs);
mType = Tnsresult;
return (*(this));
}
auto FileSystemGetEntriesResponse::operator=(nsresult&& aRhs) -> FileSystemGetEntriesResponse&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_nsresult()) nsresult(std::move(aRhs));
mType = Tnsresult;
return (*(this));
}
auto FileSystemGetEntriesResponse::operator=(const FileSystemDirectoryListing& aRhs) -> FileSystemGetEntriesResponse&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_FileSystemDirectoryListing()) FileSystemDirectoryListing(aRhs);
mType = TFileSystemDirectoryListing;
return (*(this));
}
auto FileSystemGetEntriesResponse::operator=(FileSystemDirectoryListing&& aRhs) -> FileSystemGetEntriesResponse&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_FileSystemDirectoryListing()) FileSystemDirectoryListing(std::move(aRhs));
mType = TFileSystemDirectoryListing;
return (*(this));
}
auto FileSystemGetEntriesResponse::operator=(const FileSystemGetEntriesResponse& aRhs) -> FileSystemGetEntriesResponse&
{
(aRhs).AssertSanity();
Type t = (aRhs).type();
switch (t) {
case Tnsresult:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_nsresult()) nsresult((aRhs).get_nsresult());
break;
}
case TFileSystemDirectoryListing:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_FileSystemDirectoryListing()) FileSystemDirectoryListing((aRhs).get_FileSystemDirectoryListing());
break;
}
case T__None:
{
MaybeDestroy();
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
break;
}
}
mType = t;
return (*(this));
}
auto FileSystemGetEntriesResponse::operator=(FileSystemGetEntriesResponse&& aRhs) -> FileSystemGetEntriesResponse&
{
(aRhs).AssertSanity();
Type t = (aRhs).type();
switch (t) {
case Tnsresult:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_nsresult()) nsresult(std::move((aRhs).get_nsresult()));
(aRhs).MaybeDestroy();
break;
}
case TFileSystemDirectoryListing:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_FileSystemDirectoryListing()) FileSystemDirectoryListing(std::move((aRhs).get_FileSystemDirectoryListing()));
(aRhs).MaybeDestroy();
break;
}
case T__None:
{
MaybeDestroy();
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
break;
}
}
(aRhs).mType = T__None;
mType = t;
return (*(this));
}
} // namespace fs
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::fs::FileSystemGetEntriesResponse>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
typedef ::mozilla::dom::fs::FileSystemGetEntriesResponse union__;
int type = (aVar).type();
IPC::WriteParam(aWriter, type);
// Sentinel = 'FileSystemGetEntriesResponse'
(aWriter)->WriteSentinel(2700610383);
switch (type) {
case union__::Tnsresult:
{
IPC::WriteParam(aWriter, (aVar).get_nsresult());
// Sentinel = 'Tnsresult'
(aWriter)->WriteSentinel(313394133);
return;
}
case union__::TFileSystemDirectoryListing:
{
IPC::WriteParam(aWriter, (aVar).get_FileSystemDirectoryListing());
// Sentinel = 'TFileSystemDirectoryListing'
(aWriter)->WriteSentinel(2501905129);
return;
}
default:
{
aWriter->FatalError("unknown variant of union FileSystemGetEntriesResponse");
return;
}
}
}
auto ParamTraits<::mozilla::dom::fs::FileSystemGetEntriesResponse>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
typedef ::mozilla::dom::fs::FileSystemGetEntriesResponse union__;
auto maybe__type = IPC::ReadParam<int>(aReader);
if (!maybe__type) {
aReader->FatalError("Error deserializing type of union FileSystemGetEntriesResponse");
return {};
}
auto& type = *maybe__type;
// Sentinel = 'FileSystemGetEntriesResponse'
if ((!((aReader)->ReadSentinel(2700610383)))) {
mozilla::ipc::SentinelReadError("Error deserializing type of union FileSystemGetEntriesResponse");
return {};
}
switch (type) {
case union__::Tnsresult:
{
auto maybe__tmp = IPC::ReadParam<::nsresult>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant Tnsresult of union FileSystemGetEntriesResponse");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'Tnsresult'
if ((!((aReader)->ReadSentinel(313394133)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant Tnsresult of union FileSystemGetEntriesResponse");
return {};
}
return std::move(tmp);
}
case union__::TFileSystemDirectoryListing:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::dom::fs::FileSystemDirectoryListing>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TFileSystemDirectoryListing of union FileSystemGetEntriesResponse");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TFileSystemDirectoryListing'
if ((!((aReader)->ReadSentinel(2501905129)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TFileSystemDirectoryListing of union FileSystemGetEntriesResponse");
return {};
}
return std::move(tmp);
}
default:
{
aReader->FatalError("unknown variant of union FileSystemGetEntriesResponse");
return {};
}
}
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct FileSystemGetFileRequest|
//
namespace mozilla {
namespace dom {
namespace fs {
} // namespace fs
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::fs::FileSystemGetFileRequest>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).entryId());
// Sentinel = 'entryId'
(aWriter)->WriteSentinel(197853920);
}
auto ParamTraits<::mozilla::dom::fs::FileSystemGetFileRequest>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___entryId = IPC::ReadParam<::mozilla::dom::fs::EntryId>(aReader);
if (!maybe___entryId) {
aReader->FatalError("Error deserializing 'entryId' (EntryId) member of 'FileSystemGetFileRequest'");
return {};
}
auto& _entryId = *maybe___entryId;
// Sentinel = 'entryId'
if ((!((aReader)->ReadSentinel(197853920)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'entryId' (EntryId) member of 'FileSystemGetFileRequest'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_entryId)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct FileSystemFileProperties|
//
namespace mozilla {
namespace dom {
namespace fs {
} // namespace fs
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::fs::FileSystemFileProperties>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).last_modified_ms());
// Sentinel = 'last_modified_ms'
(aWriter)->WriteSentinel(941950612);
IPC::WriteParam(aWriter, (aVar).file());
// Sentinel = 'file'
(aWriter)->WriteSentinel(68420001);
IPC::WriteParam(aWriter, (aVar).type());
// Sentinel = 'type'
(aWriter)->WriteSentinel(75760067);
IPC::WriteParam(aWriter, (aVar).path());
// Sentinel = 'path'
(aWriter)->WriteSentinel(70713774);
}
auto ParamTraits<::mozilla::dom::fs::FileSystemFileProperties>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___last_modified_ms = IPC::ReadParam<::mozilla::dom::fs::TimeStamp>(aReader);
if (!maybe___last_modified_ms) {
aReader->FatalError("Error deserializing 'last_modified_ms' (TimeStamp) member of 'FileSystemFileProperties'");
return {};
}
auto& _last_modified_ms = *maybe___last_modified_ms;
// Sentinel = 'last_modified_ms'
if ((!((aReader)->ReadSentinel(941950612)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'last_modified_ms' (TimeStamp) member of 'FileSystemFileProperties'");
return {};
}
auto maybe___file = IPC::ReadParam<::mozilla::dom::IPCBlob>(aReader);
if (!maybe___file) {
aReader->FatalError("Error deserializing 'file' (IPCBlob) member of 'FileSystemFileProperties'");
return {};
}
auto& _file = *maybe___file;
// Sentinel = 'file'
if ((!((aReader)->ReadSentinel(68420001)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'file' (IPCBlob) member of 'FileSystemFileProperties'");
return {};
}
auto maybe___type = IPC::ReadParam<::mozilla::dom::fs::ContentType>(aReader);
if (!maybe___type) {
aReader->FatalError("Error deserializing 'type' (ContentType) member of 'FileSystemFileProperties'");
return {};
}
auto& _type = *maybe___type;
// Sentinel = 'type'
if ((!((aReader)->ReadSentinel(75760067)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'type' (ContentType) member of 'FileSystemFileProperties'");
return {};
}
auto maybe___path = IPC::ReadParam<nsTArray<::mozilla::dom::fs::Name>>(aReader);
if (!maybe___path) {
aReader->FatalError("Error deserializing 'path' (Name[]) member of 'FileSystemFileProperties'");
return {};
}
auto& _path = *maybe___path;
// Sentinel = 'path'
if ((!((aReader)->ReadSentinel(70713774)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'path' (Name[]) member of 'FileSystemFileProperties'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_last_modified_ms),
std::move(_file),
std::move(_type),
std::move(_path)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |union FileSystemGetFileResponse|
//
namespace mozilla {
namespace dom {
namespace fs {
auto FileSystemGetFileResponse::MaybeDestroy() -> void
{
if ((mType) == (T__None)) {
return;
}
switch (mType) {
case Tnsresult:
{
(ptr_nsresult())->~nsresult__tdef();
break;
}
case TFileSystemFileProperties:
{
(ptr_FileSystemFileProperties())->~FileSystemFileProperties__tdef();
break;
}
default:
{
mozilla::ipc::LogicError("not reached");
break;
}
}
}
MOZ_IMPLICIT FileSystemGetFileResponse::FileSystemGetFileResponse(const nsresult& aOther)
{
new (mozilla::KnownNotNull, ptr_nsresult()) nsresult(aOther);
mType = Tnsresult;
}
MOZ_IMPLICIT FileSystemGetFileResponse::FileSystemGetFileResponse(nsresult&& aOther)
{
new (mozilla::KnownNotNull, ptr_nsresult()) nsresult(std::move(aOther));
mType = Tnsresult;
}
MOZ_IMPLICIT FileSystemGetFileResponse::FileSystemGetFileResponse(const FileSystemFileProperties& aOther)
{
new (mozilla::KnownNotNull, ptr_FileSystemFileProperties()) FileSystemFileProperties(aOther);
mType = TFileSystemFileProperties;
}
MOZ_IMPLICIT FileSystemGetFileResponse::FileSystemGetFileResponse(FileSystemFileProperties&& aOther)
{
new (mozilla::KnownNotNull, ptr_FileSystemFileProperties()) FileSystemFileProperties(std::move(aOther));
mType = TFileSystemFileProperties;
}
MOZ_IMPLICIT FileSystemGetFileResponse::FileSystemGetFileResponse(const FileSystemGetFileResponse& aOther)
{
(aOther).AssertSanity();
switch ((aOther).type()) {
case Tnsresult:
{
new (mozilla::KnownNotNull, ptr_nsresult()) nsresult((aOther).get_nsresult());
break;
}
case TFileSystemFileProperties:
{
new (mozilla::KnownNotNull, ptr_FileSystemFileProperties()) FileSystemFileProperties((aOther).get_FileSystemFileProperties());
break;
}
case T__None:
{
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
return;
}
}
mType = (aOther).type();
}
MOZ_IMPLICIT FileSystemGetFileResponse::FileSystemGetFileResponse(FileSystemGetFileResponse&& aOther)
{
(aOther).AssertSanity();
Type t = (aOther).type();
switch (t) {
case Tnsresult:
{
new (mozilla::KnownNotNull, ptr_nsresult()) nsresult(std::move((aOther).get_nsresult()));
(aOther).MaybeDestroy();
break;
}
case TFileSystemFileProperties:
{
new (mozilla::KnownNotNull, ptr_FileSystemFileProperties()) FileSystemFileProperties(std::move((aOther).get_FileSystemFileProperties()));
(aOther).MaybeDestroy();
break;
}
case T__None:
{
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
return;
}
}
(aOther).mType = T__None;
mType = t;
}
FileSystemGetFileResponse::~FileSystemGetFileResponse()
{
MaybeDestroy();
}
auto FileSystemGetFileResponse::operator=(const nsresult& aRhs) -> FileSystemGetFileResponse&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_nsresult()) nsresult(aRhs);
mType = Tnsresult;
return (*(this));
}
auto FileSystemGetFileResponse::operator=(nsresult&& aRhs) -> FileSystemGetFileResponse&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_nsresult()) nsresult(std::move(aRhs));
mType = Tnsresult;
return (*(this));
}
auto FileSystemGetFileResponse::operator=(const FileSystemFileProperties& aRhs) -> FileSystemGetFileResponse&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_FileSystemFileProperties()) FileSystemFileProperties(aRhs);
mType = TFileSystemFileProperties;
return (*(this));
}
auto FileSystemGetFileResponse::operator=(FileSystemFileProperties&& aRhs) -> FileSystemGetFileResponse&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_FileSystemFileProperties()) FileSystemFileProperties(std::move(aRhs));
mType = TFileSystemFileProperties;
return (*(this));
}
auto FileSystemGetFileResponse::operator=(const FileSystemGetFileResponse& aRhs) -> FileSystemGetFileResponse&
{
(aRhs).AssertSanity();
Type t = (aRhs).type();
switch (t) {
case Tnsresult:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_nsresult()) nsresult((aRhs).get_nsresult());
break;
}
case TFileSystemFileProperties:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_FileSystemFileProperties()) FileSystemFileProperties((aRhs).get_FileSystemFileProperties());
break;
}
case T__None:
{
MaybeDestroy();
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
break;
}
}
mType = t;
return (*(this));
}
auto FileSystemGetFileResponse::operator=(FileSystemGetFileResponse&& aRhs) -> FileSystemGetFileResponse&
{
(aRhs).AssertSanity();
Type t = (aRhs).type();
switch (t) {
case Tnsresult:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_nsresult()) nsresult(std::move((aRhs).get_nsresult()));
(aRhs).MaybeDestroy();
break;
}
case TFileSystemFileProperties:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_FileSystemFileProperties()) FileSystemFileProperties(std::move((aRhs).get_FileSystemFileProperties()));
(aRhs).MaybeDestroy();
break;
}
case T__None:
{
MaybeDestroy();
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
break;
}
}
(aRhs).mType = T__None;
mType = t;
return (*(this));
}
} // namespace fs
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::fs::FileSystemGetFileResponse>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
typedef ::mozilla::dom::fs::FileSystemGetFileResponse union__;
int type = (aVar).type();
IPC::WriteParam(aWriter, type);
// Sentinel = 'FileSystemGetFileResponse'
(aWriter)->WriteSentinel(2135624181);
switch (type) {
case union__::Tnsresult:
{
IPC::WriteParam(aWriter, (aVar).get_nsresult());
// Sentinel = 'Tnsresult'
(aWriter)->WriteSentinel(313394133);
return;
}
case union__::TFileSystemFileProperties:
{
IPC::WriteParam(aWriter, (aVar).get_FileSystemFileProperties());
// Sentinel = 'TFileSystemFileProperties'
(aWriter)->WriteSentinel(2129332743);
return;
}
default:
{
aWriter->FatalError("unknown variant of union FileSystemGetFileResponse");
return;
}
}
}
auto ParamTraits<::mozilla::dom::fs::FileSystemGetFileResponse>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
typedef ::mozilla::dom::fs::FileSystemGetFileResponse union__;
auto maybe__type = IPC::ReadParam<int>(aReader);
if (!maybe__type) {
aReader->FatalError("Error deserializing type of union FileSystemGetFileResponse");
return {};
}
auto& type = *maybe__type;
// Sentinel = 'FileSystemGetFileResponse'
if ((!((aReader)->ReadSentinel(2135624181)))) {
mozilla::ipc::SentinelReadError("Error deserializing type of union FileSystemGetFileResponse");
return {};
}
switch (type) {
case union__::Tnsresult:
{
auto maybe__tmp = IPC::ReadParam<::nsresult>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant Tnsresult of union FileSystemGetFileResponse");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'Tnsresult'
if ((!((aReader)->ReadSentinel(313394133)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant Tnsresult of union FileSystemGetFileResponse");
return {};
}
return std::move(tmp);
}
case union__::TFileSystemFileProperties:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::dom::fs::FileSystemFileProperties>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TFileSystemFileProperties of union FileSystemGetFileResponse");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TFileSystemFileProperties'
if ((!((aReader)->ReadSentinel(2129332743)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TFileSystemFileProperties of union FileSystemGetFileResponse");
return {};
}
return std::move(tmp);
}
default:
{
aReader->FatalError("unknown variant of union FileSystemGetFileResponse");
return {};
}
}
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct FileSystemGetAccessHandleRequest|
//
namespace mozilla {
namespace dom {
namespace fs {
} // namespace fs
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::fs::FileSystemGetAccessHandleRequest>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).entryId());
// Sentinel = 'entryId'
(aWriter)->WriteSentinel(197853920);
}
auto ParamTraits<::mozilla::dom::fs::FileSystemGetAccessHandleRequest>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___entryId = IPC::ReadParam<::mozilla::dom::fs::EntryId>(aReader);
if (!maybe___entryId) {
aReader->FatalError("Error deserializing 'entryId' (EntryId) member of 'FileSystemGetAccessHandleRequest'");
return {};
}
auto& _entryId = *maybe___entryId;
// Sentinel = 'entryId'
if ((!((aReader)->ReadSentinel(197853920)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'entryId' (EntryId) member of 'FileSystemGetAccessHandleRequest'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_entryId)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct FileSystemAccessHandleProperties|
//
namespace mozilla {
namespace dom {
namespace fs {
} // namespace fs
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::fs::FileSystemAccessHandleProperties>::Write(
IPC::MessageWriter* aWriter,
paramType&& aVar) -> void
{
IPC::WriteParam(aWriter, std::move((aVar).streamParams()));
// Sentinel = 'streamParams'
(aWriter)->WriteSentinel(544015601);
IPC::WriteParam(aWriter, std::move((aVar).accessHandleChildEndpoint()));
// Sentinel = 'accessHandleChildEndpoint'
(aWriter)->WriteSentinel(2129201636);
IPC::WriteParam(aWriter, std::move((aVar).accessHandleControlChildEndpoint()));
// Sentinel = 'accessHandleControlChildEndpoint'
(aWriter)->WriteSentinel(3499363525);
}
auto ParamTraits<::mozilla::dom::fs::FileSystemAccessHandleProperties>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___streamParams = IPC::ReadParam<::mozilla::ipc::RandomAccessStreamParams>(aReader);
if (!maybe___streamParams) {
aReader->FatalError("Error deserializing 'streamParams' (RandomAccessStreamParams) member of 'FileSystemAccessHandleProperties'");
return {};
}
auto& _streamParams = *maybe___streamParams;
// Sentinel = 'streamParams'
if ((!((aReader)->ReadSentinel(544015601)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'streamParams' (RandomAccessStreamParams) member of 'FileSystemAccessHandleProperties'");
return {};
}
auto maybe___accessHandleChildEndpoint = IPC::ReadParam<::mozilla::ipc::ManagedEndpoint<::mozilla::dom::PFileSystemAccessHandleChild>>(aReader);
if (!maybe___accessHandleChildEndpoint) {
aReader->FatalError("Error deserializing 'accessHandleChildEndpoint' (ManagedEndpoint<::mozilla::dom::PFileSystemAccessHandleChild>) member of 'FileSystemAccessHandleProperties'");
return {};
}
auto& _accessHandleChildEndpoint = *maybe___accessHandleChildEndpoint;
// Sentinel = 'accessHandleChildEndpoint'
if ((!((aReader)->ReadSentinel(2129201636)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'accessHandleChildEndpoint' (ManagedEndpoint<::mozilla::dom::PFileSystemAccessHandleChild>) member of 'FileSystemAccessHandleProperties'");
return {};
}
auto maybe___accessHandleControlChildEndpoint = IPC::ReadParam<::mozilla::ipc::Endpoint<::mozilla::dom::PFileSystemAccessHandleControlChild>>(aReader);
if (!maybe___accessHandleControlChildEndpoint) {
aReader->FatalError("Error deserializing 'accessHandleControlChildEndpoint' (Endpoint<::mozilla::dom::PFileSystemAccessHandleControlChild>) member of 'FileSystemAccessHandleProperties'");
return {};
}
auto& _accessHandleControlChildEndpoint = *maybe___accessHandleControlChildEndpoint;
// Sentinel = 'accessHandleControlChildEndpoint'
if ((!((aReader)->ReadSentinel(3499363525)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'accessHandleControlChildEndpoint' (Endpoint<::mozilla::dom::PFileSystemAccessHandleControlChild>) member of 'FileSystemAccessHandleProperties'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_streamParams),
std::move(_accessHandleChildEndpoint),
std::move(_accessHandleControlChildEndpoint)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |union FileSystemGetAccessHandleResponse|
//
namespace mozilla {
namespace dom {
namespace fs {
auto FileSystemGetAccessHandleResponse::MaybeDestroy() -> void
{
if ((mType) == (T__None)) {
return;
}
switch (mType) {
case Tnsresult:
{
(ptr_nsresult())->~nsresult__tdef();
break;
}
case TFileSystemAccessHandleProperties:
{
(ptr_FileSystemAccessHandleProperties())->~FileSystemAccessHandleProperties__tdef();
break;
}
default:
{
mozilla::ipc::LogicError("not reached");
break;
}
}
}
MOZ_IMPLICIT FileSystemGetAccessHandleResponse::FileSystemGetAccessHandleResponse(const nsresult& aOther)
{
new (mozilla::KnownNotNull, ptr_nsresult()) nsresult(aOther);
mType = Tnsresult;
}
MOZ_IMPLICIT FileSystemGetAccessHandleResponse::FileSystemGetAccessHandleResponse(nsresult&& aOther)
{
new (mozilla::KnownNotNull, ptr_nsresult()) nsresult(std::move(aOther));
mType = Tnsresult;
}
MOZ_IMPLICIT FileSystemGetAccessHandleResponse::FileSystemGetAccessHandleResponse(FileSystemAccessHandleProperties&& aOther)
{
new (mozilla::KnownNotNull, ptr_FileSystemAccessHandleProperties()) FileSystemAccessHandleProperties(std::move(aOther));
mType = TFileSystemAccessHandleProperties;
}
MOZ_IMPLICIT FileSystemGetAccessHandleResponse::FileSystemGetAccessHandleResponse(FileSystemGetAccessHandleResponse&& aOther)
{
(aOther).AssertSanity();
Type t = (aOther).type();
switch (t) {
case Tnsresult:
{
new (mozilla::KnownNotNull, ptr_nsresult()) nsresult(std::move((aOther).get_nsresult()));
(aOther).MaybeDestroy();
break;
}
case TFileSystemAccessHandleProperties:
{
new (mozilla::KnownNotNull, ptr_FileSystemAccessHandleProperties()) FileSystemAccessHandleProperties(std::move((aOther).get_FileSystemAccessHandleProperties()));
(aOther).MaybeDestroy();
break;
}
case T__None:
{
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
return;
}
}
(aOther).mType = T__None;
mType = t;
}
FileSystemGetAccessHandleResponse::~FileSystemGetAccessHandleResponse()
{
MaybeDestroy();
}
auto FileSystemGetAccessHandleResponse::operator=(const nsresult& aRhs) -> FileSystemGetAccessHandleResponse&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_nsresult()) nsresult(aRhs);
mType = Tnsresult;
return (*(this));
}
auto FileSystemGetAccessHandleResponse::operator=(nsresult&& aRhs) -> FileSystemGetAccessHandleResponse&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_nsresult()) nsresult(std::move(aRhs));
mType = Tnsresult;
return (*(this));
}
auto FileSystemGetAccessHandleResponse::operator=(FileSystemAccessHandleProperties&& aRhs) -> FileSystemGetAccessHandleResponse&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_FileSystemAccessHandleProperties()) FileSystemAccessHandleProperties(std::move(aRhs));
mType = TFileSystemAccessHandleProperties;
return (*(this));
}
auto FileSystemGetAccessHandleResponse::operator=(FileSystemGetAccessHandleResponse&& aRhs) -> FileSystemGetAccessHandleResponse&
{
(aRhs).AssertSanity();
Type t = (aRhs).type();
switch (t) {
case Tnsresult:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_nsresult()) nsresult(std::move((aRhs).get_nsresult()));
(aRhs).MaybeDestroy();
break;
}
case TFileSystemAccessHandleProperties:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_FileSystemAccessHandleProperties()) FileSystemAccessHandleProperties(std::move((aRhs).get_FileSystemAccessHandleProperties()));
(aRhs).MaybeDestroy();
break;
}
case T__None:
{
MaybeDestroy();
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
break;
}
}
(aRhs).mType = T__None;
mType = t;
return (*(this));
}
} // namespace fs
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::fs::FileSystemGetAccessHandleResponse>::Write(
IPC::MessageWriter* aWriter,
paramType&& aVar) -> void
{
typedef ::mozilla::dom::fs::FileSystemGetAccessHandleResponse union__;
int type = (aVar).type();
IPC::WriteParam(aWriter, type);
// Sentinel = 'FileSystemGetAccessHandleResponse'
(aWriter)->WriteSentinel(3674606867);
switch (type) {
case union__::Tnsresult:
{
IPC::WriteParam(aWriter, (aVar).get_nsresult());
// Sentinel = 'Tnsresult'
(aWriter)->WriteSentinel(313394133);
return;
}
case union__::TFileSystemAccessHandleProperties:
{
IPC::WriteParam(aWriter, std::move((aVar).get_FileSystemAccessHandleProperties()));
// Sentinel = 'TFileSystemAccessHandleProperties'
(aWriter)->WriteSentinel(3665956133);
return;
}
default:
{
aWriter->FatalError("unknown variant of union FileSystemGetAccessHandleResponse");
return;
}
}
}
auto ParamTraits<::mozilla::dom::fs::FileSystemGetAccessHandleResponse>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
typedef ::mozilla::dom::fs::FileSystemGetAccessHandleResponse union__;
auto maybe__type = IPC::ReadParam<int>(aReader);
if (!maybe__type) {
aReader->FatalError("Error deserializing type of union FileSystemGetAccessHandleResponse");
return {};
}
auto& type = *maybe__type;
// Sentinel = 'FileSystemGetAccessHandleResponse'
if ((!((aReader)->ReadSentinel(3674606867)))) {
mozilla::ipc::SentinelReadError("Error deserializing type of union FileSystemGetAccessHandleResponse");
return {};
}
switch (type) {
case union__::Tnsresult:
{
auto maybe__tmp = IPC::ReadParam<::nsresult>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant Tnsresult of union FileSystemGetAccessHandleResponse");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'Tnsresult'
if ((!((aReader)->ReadSentinel(313394133)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant Tnsresult of union FileSystemGetAccessHandleResponse");
return {};
}
return std::move(tmp);
}
case union__::TFileSystemAccessHandleProperties:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::dom::fs::FileSystemAccessHandleProperties>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TFileSystemAccessHandleProperties of union FileSystemGetAccessHandleResponse");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TFileSystemAccessHandleProperties'
if ((!((aReader)->ReadSentinel(3665956133)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TFileSystemAccessHandleProperties of union FileSystemGetAccessHandleResponse");
return {};
}
return std::move(tmp);
}
default:
{
aReader->FatalError("unknown variant of union FileSystemGetAccessHandleResponse");
return {};
}
}
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct FileSystemGetWritableRequest|
//
namespace mozilla {
namespace dom {
namespace fs {
} // namespace fs
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::fs::FileSystemGetWritableRequest>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).entryId());
// Sentinel = 'entryId'
(aWriter)->WriteSentinel(197853920);
IPC::WriteParam(aWriter, (aVar).keepData());
// Sentinel = 'keepData'
(aWriter)->WriteSentinel(237830944);
}
auto ParamTraits<::mozilla::dom::fs::FileSystemGetWritableRequest>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___entryId = IPC::ReadParam<::mozilla::dom::fs::EntryId>(aReader);
if (!maybe___entryId) {
aReader->FatalError("Error deserializing 'entryId' (EntryId) member of 'FileSystemGetWritableRequest'");
return {};
}
auto& _entryId = *maybe___entryId;
// Sentinel = 'entryId'
if ((!((aReader)->ReadSentinel(197853920)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'entryId' (EntryId) member of 'FileSystemGetWritableRequest'");
return {};
}
auto maybe___keepData = IPC::ReadParam<bool>(aReader);
if (!maybe___keepData) {
aReader->FatalError("Error deserializing 'keepData' (bool) member of 'FileSystemGetWritableRequest'");
return {};
}
auto& _keepData = *maybe___keepData;
// Sentinel = 'keepData'
if ((!((aReader)->ReadSentinel(237830944)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'keepData' (bool) member of 'FileSystemGetWritableRequest'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_entryId),
std::move(_keepData)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct FileSystemWritableFileStreamProperties|
//
namespace mozilla {
namespace dom {
namespace fs {
} // namespace fs
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::fs::FileSystemWritableFileStreamProperties>::Write(
IPC::MessageWriter* aWriter,
paramType&& aVar) -> void
{
IPC::WriteParam(aWriter, std::move((aVar).streamParams()));
// Sentinel = 'streamParams'
(aWriter)->WriteSentinel(544015601);
IPC::WriteParam(aWriter, (aVar).writableFileStream());
// Sentinel = 'writableFileStream'
(aWriter)->WriteSentinel(1173948231);
}
auto ParamTraits<::mozilla::dom::fs::FileSystemWritableFileStreamProperties>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___streamParams = IPC::ReadParam<::mozilla::ipc::RandomAccessStreamParams>(aReader);
if (!maybe___streamParams) {
aReader->FatalError("Error deserializing 'streamParams' (RandomAccessStreamParams) member of 'FileSystemWritableFileStreamProperties'");
return {};
}
auto& _streamParams = *maybe___streamParams;
// Sentinel = 'streamParams'
if ((!((aReader)->ReadSentinel(544015601)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'streamParams' (RandomAccessStreamParams) member of 'FileSystemWritableFileStreamProperties'");
return {};
}
auto maybe___writableFileStream = IPC::ReadParam<mozilla::NotNull<::mozilla::ipc::SideVariant<::mozilla::dom::PFileSystemWritableFileStreamParent*, ::mozilla::dom::PFileSystemWritableFileStreamChild*>>>(aReader);
if (!maybe___writableFileStream) {
aReader->FatalError("Error deserializing 'writableFileStream' (NotNull<PFileSystemWritableFileStream>) member of 'FileSystemWritableFileStreamProperties'");
return {};
}
auto& _writableFileStream = *maybe___writableFileStream;
// Sentinel = 'writableFileStream'
if ((!((aReader)->ReadSentinel(1173948231)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'writableFileStream' (NotNull<PFileSystemWritableFileStream>) member of 'FileSystemWritableFileStreamProperties'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_streamParams),
std::move(_writableFileStream)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |union FileSystemGetWritableFileStreamResponse|
//
namespace mozilla {
namespace dom {
namespace fs {
auto FileSystemGetWritableFileStreamResponse::MaybeDestroy() -> void
{
if ((mType) == (T__None)) {
return;
}
switch (mType) {
case Tnsresult:
{
(ptr_nsresult())->~nsresult__tdef();
break;
}
case TFileSystemWritableFileStreamProperties:
{
(ptr_FileSystemWritableFileStreamProperties())->~FileSystemWritableFileStreamProperties__tdef();
break;
}
default:
{
mozilla::ipc::LogicError("not reached");
break;
}
}
}
MOZ_IMPLICIT FileSystemGetWritableFileStreamResponse::FileSystemGetWritableFileStreamResponse(const nsresult& aOther)
{
new (mozilla::KnownNotNull, ptr_nsresult()) nsresult(aOther);
mType = Tnsresult;
}
MOZ_IMPLICIT FileSystemGetWritableFileStreamResponse::FileSystemGetWritableFileStreamResponse(nsresult&& aOther)
{
new (mozilla::KnownNotNull, ptr_nsresult()) nsresult(std::move(aOther));
mType = Tnsresult;
}
MOZ_IMPLICIT FileSystemGetWritableFileStreamResponse::FileSystemGetWritableFileStreamResponse(FileSystemWritableFileStreamProperties&& aOther)
{
new (mozilla::KnownNotNull, ptr_FileSystemWritableFileStreamProperties()) FileSystemWritableFileStreamProperties(std::move(aOther));
mType = TFileSystemWritableFileStreamProperties;
}
MOZ_IMPLICIT FileSystemGetWritableFileStreamResponse::FileSystemGetWritableFileStreamResponse(FileSystemGetWritableFileStreamResponse&& aOther)
{
(aOther).AssertSanity();
Type t = (aOther).type();
switch (t) {
case Tnsresult:
{
new (mozilla::KnownNotNull, ptr_nsresult()) nsresult(std::move((aOther).get_nsresult()));
(aOther).MaybeDestroy();
break;
}
case TFileSystemWritableFileStreamProperties:
{
new (mozilla::KnownNotNull, ptr_FileSystemWritableFileStreamProperties()) FileSystemWritableFileStreamProperties(std::move((aOther).get_FileSystemWritableFileStreamProperties()));
(aOther).MaybeDestroy();
break;
}
case T__None:
{
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
return;
}
}
(aOther).mType = T__None;
mType = t;
}
FileSystemGetWritableFileStreamResponse::~FileSystemGetWritableFileStreamResponse()
{
MaybeDestroy();
}
auto FileSystemGetWritableFileStreamResponse::operator=(const nsresult& aRhs) -> FileSystemGetWritableFileStreamResponse&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_nsresult()) nsresult(aRhs);
mType = Tnsresult;
return (*(this));
}
auto FileSystemGetWritableFileStreamResponse::operator=(nsresult&& aRhs) -> FileSystemGetWritableFileStreamResponse&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_nsresult()) nsresult(std::move(aRhs));
mType = Tnsresult;
return (*(this));
}
auto FileSystemGetWritableFileStreamResponse::operator=(FileSystemWritableFileStreamProperties&& aRhs) -> FileSystemGetWritableFileStreamResponse&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_FileSystemWritableFileStreamProperties()) FileSystemWritableFileStreamProperties(std::move(aRhs));
mType = TFileSystemWritableFileStreamProperties;
return (*(this));
}
auto FileSystemGetWritableFileStreamResponse::operator=(FileSystemGetWritableFileStreamResponse&& aRhs) -> FileSystemGetWritableFileStreamResponse&
{
(aRhs).AssertSanity();
Type t = (aRhs).type();
switch (t) {
case Tnsresult:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_nsresult()) nsresult(std::move((aRhs).get_nsresult()));
(aRhs).MaybeDestroy();
break;
}
case TFileSystemWritableFileStreamProperties:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_FileSystemWritableFileStreamProperties()) FileSystemWritableFileStreamProperties(std::move((aRhs).get_FileSystemWritableFileStreamProperties()));
(aRhs).MaybeDestroy();
break;
}
case T__None:
{
MaybeDestroy();
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
break;
}
}
(aRhs).mType = T__None;
mType = t;
return (*(this));
}
} // namespace fs
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::fs::FileSystemGetWritableFileStreamResponse>::Write(
IPC::MessageWriter* aWriter,
paramType&& aVar) -> void
{
typedef ::mozilla::dom::fs::FileSystemGetWritableFileStreamResponse union__;
int type = (aVar).type();
IPC::WriteParam(aWriter, type);
// Sentinel = 'FileSystemGetWritableFileStreamResponse'
(aWriter)->WriteSentinel(884281243);
switch (type) {
case union__::Tnsresult:
{
IPC::WriteParam(aWriter, (aVar).get_nsresult());
// Sentinel = 'Tnsresult'
(aWriter)->WriteSentinel(313394133);
return;
}
case union__::TFileSystemWritableFileStreamProperties:
{
IPC::WriteParam(aWriter, std::move((aVar).get_FileSystemWritableFileStreamProperties()));
// Sentinel = 'TFileSystemWritableFileStreamProperties'
(aWriter)->WriteSentinel(880349101);
return;
}
default:
{
aWriter->FatalError("unknown variant of union FileSystemGetWritableFileStreamResponse");
return;
}
}
}
auto ParamTraits<::mozilla::dom::fs::FileSystemGetWritableFileStreamResponse>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
typedef ::mozilla::dom::fs::FileSystemGetWritableFileStreamResponse union__;
auto maybe__type = IPC::ReadParam<int>(aReader);
if (!maybe__type) {
aReader->FatalError("Error deserializing type of union FileSystemGetWritableFileStreamResponse");
return {};
}
auto& type = *maybe__type;
// Sentinel = 'FileSystemGetWritableFileStreamResponse'
if ((!((aReader)->ReadSentinel(884281243)))) {
mozilla::ipc::SentinelReadError("Error deserializing type of union FileSystemGetWritableFileStreamResponse");
return {};
}
switch (type) {
case union__::Tnsresult:
{
auto maybe__tmp = IPC::ReadParam<::nsresult>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant Tnsresult of union FileSystemGetWritableFileStreamResponse");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'Tnsresult'
if ((!((aReader)->ReadSentinel(313394133)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant Tnsresult of union FileSystemGetWritableFileStreamResponse");
return {};
}
return std::move(tmp);
}
case union__::TFileSystemWritableFileStreamProperties:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::dom::fs::FileSystemWritableFileStreamProperties>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TFileSystemWritableFileStreamProperties of union FileSystemGetWritableFileStreamResponse");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TFileSystemWritableFileStreamProperties'
if ((!((aReader)->ReadSentinel(880349101)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TFileSystemWritableFileStreamProperties of union FileSystemGetWritableFileStreamResponse");
return {};
}
return std::move(tmp);
}
default:
{
aReader->FatalError("unknown variant of union FileSystemGetWritableFileStreamResponse");
return {};
}
}
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct FileSystemEntryPair|
//
namespace mozilla {
namespace dom {
namespace fs {
} // namespace fs
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::fs::FileSystemEntryPair>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).parentId());
// Sentinel = 'parentId'
(aWriter)->WriteSentinel(249430840);
IPC::WriteParam(aWriter, (aVar).childId());
// Sentinel = 'childId'
(aWriter)->WriteSentinel(185270962);
}
auto ParamTraits<::mozilla::dom::fs::FileSystemEntryPair>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___parentId = IPC::ReadParam<::mozilla::dom::fs::EntryId>(aReader);
if (!maybe___parentId) {
aReader->FatalError("Error deserializing 'parentId' (EntryId) member of 'FileSystemEntryPair'");
return {};
}
auto& _parentId = *maybe___parentId;
// Sentinel = 'parentId'
if ((!((aReader)->ReadSentinel(249430840)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'parentId' (EntryId) member of 'FileSystemEntryPair'");
return {};
}
auto maybe___childId = IPC::ReadParam<::mozilla::dom::fs::EntryId>(aReader);
if (!maybe___childId) {
aReader->FatalError("Error deserializing 'childId' (EntryId) member of 'FileSystemEntryPair'");
return {};
}
auto& _childId = *maybe___childId;
// Sentinel = 'childId'
if ((!((aReader)->ReadSentinel(185270962)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'childId' (EntryId) member of 'FileSystemEntryPair'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_parentId),
std::move(_childId)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct FileSystemResolveRequest|
//
namespace mozilla {
namespace dom {
namespace fs {
} // namespace fs
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::fs::FileSystemResolveRequest>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).endpoints());
// Sentinel = 'endpoints'
(aWriter)->WriteSentinel(316015573);
}
auto ParamTraits<::mozilla::dom::fs::FileSystemResolveRequest>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___endpoints = IPC::ReadParam<::mozilla::dom::fs::FileSystemEntryPair>(aReader);
if (!maybe___endpoints) {
aReader->FatalError("Error deserializing 'endpoints' (FileSystemEntryPair) member of 'FileSystemResolveRequest'");
return {};
}
auto& _endpoints = *maybe___endpoints;
// Sentinel = 'endpoints'
if ((!((aReader)->ReadSentinel(316015573)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'endpoints' (FileSystemEntryPair) member of 'FileSystemResolveRequest'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_endpoints)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct FileSystemPath|
//
namespace mozilla {
namespace dom {
namespace fs {
} // namespace fs
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::fs::FileSystemPath>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).path());
// Sentinel = 'path'
(aWriter)->WriteSentinel(70713774);
}
auto ParamTraits<::mozilla::dom::fs::FileSystemPath>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___path = IPC::ReadParam<nsTArray<::mozilla::dom::fs::Name>>(aReader);
if (!maybe___path) {
aReader->FatalError("Error deserializing 'path' (Name[]) member of 'FileSystemPath'");
return {};
}
auto& _path = *maybe___path;
// Sentinel = 'path'
if ((!((aReader)->ReadSentinel(70713774)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'path' (Name[]) member of 'FileSystemPath'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_path)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |union FileSystemResolveResponse|
//
namespace mozilla {
namespace dom {
namespace fs {
auto FileSystemResolveResponse::MaybeDestroy() -> void
{
if ((mType) == (T__None)) {
return;
}
switch (mType) {
case Tnsresult:
{
(ptr_nsresult())->~nsresult__tdef();
break;
}
case TMaybeFileSystemPath:
{
(ptr_MaybeFileSystemPath())->~MaybeFileSystemPath__tdef();
break;
}
default:
{
mozilla::ipc::LogicError("not reached");
break;
}
}
}
MOZ_IMPLICIT FileSystemResolveResponse::FileSystemResolveResponse(const nsresult& aOther)
{
new (mozilla::KnownNotNull, ptr_nsresult()) nsresult(aOther);
mType = Tnsresult;
}
MOZ_IMPLICIT FileSystemResolveResponse::FileSystemResolveResponse(nsresult&& aOther)
{
new (mozilla::KnownNotNull, ptr_nsresult()) nsresult(std::move(aOther));
mType = Tnsresult;
}
MOZ_IMPLICIT FileSystemResolveResponse::FileSystemResolveResponse(const mozilla::Maybe<FileSystemPath>& aOther)
{
new (mozilla::KnownNotNull, ptr_MaybeFileSystemPath()) mozilla::Maybe<FileSystemPath>(aOther);
mType = TMaybeFileSystemPath;
}
MOZ_IMPLICIT FileSystemResolveResponse::FileSystemResolveResponse(mozilla::Maybe<FileSystemPath>&& aOther)
{
new (mozilla::KnownNotNull, ptr_MaybeFileSystemPath()) mozilla::Maybe<FileSystemPath>(std::move(aOther));
mType = TMaybeFileSystemPath;
}
MOZ_IMPLICIT FileSystemResolveResponse::FileSystemResolveResponse(const FileSystemResolveResponse& aOther)
{
(aOther).AssertSanity();
switch ((aOther).type()) {
case Tnsresult:
{
new (mozilla::KnownNotNull, ptr_nsresult()) nsresult((aOther).get_nsresult());
break;
}
case TMaybeFileSystemPath:
{
new (mozilla::KnownNotNull, ptr_MaybeFileSystemPath()) mozilla::Maybe<FileSystemPath>((aOther).get_MaybeFileSystemPath());
break;
}
case T__None:
{
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
return;
}
}
mType = (aOther).type();
}
MOZ_IMPLICIT FileSystemResolveResponse::FileSystemResolveResponse(FileSystemResolveResponse&& aOther)
{
(aOther).AssertSanity();
Type t = (aOther).type();
switch (t) {
case Tnsresult:
{
new (mozilla::KnownNotNull, ptr_nsresult()) nsresult(std::move((aOther).get_nsresult()));
(aOther).MaybeDestroy();
break;
}
case TMaybeFileSystemPath:
{
new (mozilla::KnownNotNull, ptr_MaybeFileSystemPath()) mozilla::Maybe<FileSystemPath>(std::move((aOther).get_MaybeFileSystemPath()));
(aOther).MaybeDestroy();
break;
}
case T__None:
{
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
return;
}
}
(aOther).mType = T__None;
mType = t;
}
FileSystemResolveResponse::~FileSystemResolveResponse()
{
MaybeDestroy();
}
auto FileSystemResolveResponse::operator=(const nsresult& aRhs) -> FileSystemResolveResponse&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_nsresult()) nsresult(aRhs);
mType = Tnsresult;
return (*(this));
}
auto FileSystemResolveResponse::operator=(nsresult&& aRhs) -> FileSystemResolveResponse&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_nsresult()) nsresult(std::move(aRhs));
mType = Tnsresult;
return (*(this));
}
auto FileSystemResolveResponse::operator=(const mozilla::Maybe<FileSystemPath>& aRhs) -> FileSystemResolveResponse&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_MaybeFileSystemPath()) mozilla::Maybe<FileSystemPath>(aRhs);
mType = TMaybeFileSystemPath;
return (*(this));
}
auto FileSystemResolveResponse::operator=(mozilla::Maybe<FileSystemPath>&& aRhs) -> FileSystemResolveResponse&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_MaybeFileSystemPath()) mozilla::Maybe<FileSystemPath>(std::move(aRhs));
mType = TMaybeFileSystemPath;
return (*(this));
}
auto FileSystemResolveResponse::operator=(const FileSystemResolveResponse& aRhs) -> FileSystemResolveResponse&
{
(aRhs).AssertSanity();
Type t = (aRhs).type();
switch (t) {
case Tnsresult:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_nsresult()) nsresult((aRhs).get_nsresult());
break;
}
case TMaybeFileSystemPath:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_MaybeFileSystemPath()) mozilla::Maybe<FileSystemPath>((aRhs).get_MaybeFileSystemPath());
break;
}
case T__None:
{
MaybeDestroy();
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
break;
}
}
mType = t;
return (*(this));
}
auto FileSystemResolveResponse::operator=(FileSystemResolveResponse&& aRhs) -> FileSystemResolveResponse&
{
(aRhs).AssertSanity();
Type t = (aRhs).type();
switch (t) {
case Tnsresult:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_nsresult()) nsresult(std::move((aRhs).get_nsresult()));
(aRhs).MaybeDestroy();
break;
}
case TMaybeFileSystemPath:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_MaybeFileSystemPath()) mozilla::Maybe<FileSystemPath>(std::move((aRhs).get_MaybeFileSystemPath()));
(aRhs).MaybeDestroy();
break;
}
case T__None:
{
MaybeDestroy();
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
break;
}
}
(aRhs).mType = T__None;
mType = t;
return (*(this));
}
} // namespace fs
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::fs::FileSystemResolveResponse>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
typedef ::mozilla::dom::fs::FileSystemResolveResponse union__;
int type = (aVar).type();
IPC::WriteParam(aWriter, type);
// Sentinel = 'FileSystemResolveResponse'
(aWriter)->WriteSentinel(2186545717);
switch (type) {
case union__::Tnsresult:
{
IPC::WriteParam(aWriter, (aVar).get_nsresult());
// Sentinel = 'Tnsresult'
(aWriter)->WriteSentinel(313394133);
return;
}
case union__::TMaybeFileSystemPath:
{
IPC::WriteParam(aWriter, (aVar).get_MaybeFileSystemPath());
// Sentinel = 'TMaybeFileSystemPath'
(aWriter)->WriteSentinel(1346766805);
return;
}
default:
{
aWriter->FatalError("unknown variant of union FileSystemResolveResponse");
return;
}
}
}
auto ParamTraits<::mozilla::dom::fs::FileSystemResolveResponse>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
typedef ::mozilla::dom::fs::FileSystemResolveResponse union__;
auto maybe__type = IPC::ReadParam<int>(aReader);
if (!maybe__type) {
aReader->FatalError("Error deserializing type of union FileSystemResolveResponse");
return {};
}
auto& type = *maybe__type;
// Sentinel = 'FileSystemResolveResponse'
if ((!((aReader)->ReadSentinel(2186545717)))) {
mozilla::ipc::SentinelReadError("Error deserializing type of union FileSystemResolveResponse");
return {};
}
switch (type) {
case union__::Tnsresult:
{
auto maybe__tmp = IPC::ReadParam<::nsresult>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant Tnsresult of union FileSystemResolveResponse");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'Tnsresult'
if ((!((aReader)->ReadSentinel(313394133)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant Tnsresult of union FileSystemResolveResponse");
return {};
}
return std::move(tmp);
}
case union__::TMaybeFileSystemPath:
{
auto maybe__tmp = IPC::ReadParam<mozilla::Maybe<::mozilla::dom::fs::FileSystemPath>>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TMaybeFileSystemPath of union FileSystemResolveResponse");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TMaybeFileSystemPath'
if ((!((aReader)->ReadSentinel(1346766805)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TMaybeFileSystemPath of union FileSystemResolveResponse");
return {};
}
return std::move(tmp);
}
default:
{
aReader->FatalError("unknown variant of union FileSystemResolveResponse");
return {};
}
}
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct FileSystemRemoveEntryRequest|
//
namespace mozilla {
namespace dom {
namespace fs {
} // namespace fs
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::fs::FileSystemRemoveEntryRequest>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).handle());
// Sentinel = 'handle'
(aWriter)->WriteSentinel(142344813);
IPC::WriteParam(aWriter, (aVar).recursive());
// Sentinel = 'recursive'
(aWriter)->WriteSentinel(322438105);
}
auto ParamTraits<::mozilla::dom::fs::FileSystemRemoveEntryRequest>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___handle = IPC::ReadParam<::mozilla::dom::fs::FileSystemChildMetadata>(aReader);
if (!maybe___handle) {
aReader->FatalError("Error deserializing 'handle' (FileSystemChildMetadata) member of 'FileSystemRemoveEntryRequest'");
return {};
}
auto& _handle = *maybe___handle;
// Sentinel = 'handle'
if ((!((aReader)->ReadSentinel(142344813)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'handle' (FileSystemChildMetadata) member of 'FileSystemRemoveEntryRequest'");
return {};
}
auto maybe___recursive = IPC::ReadParam<bool>(aReader);
if (!maybe___recursive) {
aReader->FatalError("Error deserializing 'recursive' (bool) member of 'FileSystemRemoveEntryRequest'");
return {};
}
auto& _recursive = *maybe___recursive;
// Sentinel = 'recursive'
if ((!((aReader)->ReadSentinel(322438105)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'recursive' (bool) member of 'FileSystemRemoveEntryRequest'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_handle),
std::move(_recursive)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |union FileSystemRemoveEntryResponse|
//
namespace mozilla {
namespace dom {
namespace fs {
auto FileSystemRemoveEntryResponse::MaybeDestroy() -> void
{
if ((mType) == (T__None)) {
return;
}
switch (mType) {
case Tnsresult:
{
(ptr_nsresult())->~nsresult__tdef();
break;
}
case Tvoid_t:
{
(ptr_void_t())->~void_t__tdef();
break;
}
default:
{
mozilla::ipc::LogicError("not reached");
break;
}
}
}
MOZ_IMPLICIT FileSystemRemoveEntryResponse::FileSystemRemoveEntryResponse(const nsresult& aOther)
{
new (mozilla::KnownNotNull, ptr_nsresult()) nsresult(aOther);
mType = Tnsresult;
}
MOZ_IMPLICIT FileSystemRemoveEntryResponse::FileSystemRemoveEntryResponse(nsresult&& aOther)
{
new (mozilla::KnownNotNull, ptr_nsresult()) nsresult(std::move(aOther));
mType = Tnsresult;
}
MOZ_IMPLICIT FileSystemRemoveEntryResponse::FileSystemRemoveEntryResponse(const void_t& aOther)
{
new (mozilla::KnownNotNull, ptr_void_t()) void_t(aOther);
mType = Tvoid_t;
}
MOZ_IMPLICIT FileSystemRemoveEntryResponse::FileSystemRemoveEntryResponse(void_t&& aOther)
{
new (mozilla::KnownNotNull, ptr_void_t()) void_t(std::move(aOther));
mType = Tvoid_t;
}
MOZ_IMPLICIT FileSystemRemoveEntryResponse::FileSystemRemoveEntryResponse(const FileSystemRemoveEntryResponse& aOther)
{
(aOther).AssertSanity();
switch ((aOther).type()) {
case Tnsresult:
{
new (mozilla::KnownNotNull, ptr_nsresult()) nsresult((aOther).get_nsresult());
break;
}
case Tvoid_t:
{
new (mozilla::KnownNotNull, ptr_void_t()) void_t((aOther).get_void_t());
break;
}
case T__None:
{
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
return;
}
}
mType = (aOther).type();
}
MOZ_IMPLICIT FileSystemRemoveEntryResponse::FileSystemRemoveEntryResponse(FileSystemRemoveEntryResponse&& aOther)
{
(aOther).AssertSanity();
Type t = (aOther).type();
switch (t) {
case Tnsresult:
{
new (mozilla::KnownNotNull, ptr_nsresult()) nsresult(std::move((aOther).get_nsresult()));
(aOther).MaybeDestroy();
break;
}
case Tvoid_t:
{
new (mozilla::KnownNotNull, ptr_void_t()) void_t(std::move((aOther).get_void_t()));
(aOther).MaybeDestroy();
break;
}
case T__None:
{
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
return;
}
}
(aOther).mType = T__None;
mType = t;
}
FileSystemRemoveEntryResponse::~FileSystemRemoveEntryResponse()
{
MaybeDestroy();
}
auto FileSystemRemoveEntryResponse::operator=(const nsresult& aRhs) -> FileSystemRemoveEntryResponse&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_nsresult()) nsresult(aRhs);
mType = Tnsresult;
return (*(this));
}
auto FileSystemRemoveEntryResponse::operator=(nsresult&& aRhs) -> FileSystemRemoveEntryResponse&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_nsresult()) nsresult(std::move(aRhs));
mType = Tnsresult;
return (*(this));
}
auto FileSystemRemoveEntryResponse::operator=(const void_t& aRhs) -> FileSystemRemoveEntryResponse&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_void_t()) void_t(aRhs);
mType = Tvoid_t;
return (*(this));
}
auto FileSystemRemoveEntryResponse::operator=(void_t&& aRhs) -> FileSystemRemoveEntryResponse&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_void_t()) void_t(std::move(aRhs));
mType = Tvoid_t;
return (*(this));
}
auto FileSystemRemoveEntryResponse::operator=(const FileSystemRemoveEntryResponse& aRhs) -> FileSystemRemoveEntryResponse&
{
(aRhs).AssertSanity();
Type t = (aRhs).type();
switch (t) {
case Tnsresult:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_nsresult()) nsresult((aRhs).get_nsresult());
break;
}
case Tvoid_t:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_void_t()) void_t((aRhs).get_void_t());
break;
}
case T__None:
{
MaybeDestroy();
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
break;
}
}
mType = t;
return (*(this));
}
auto FileSystemRemoveEntryResponse::operator=(FileSystemRemoveEntryResponse&& aRhs) -> FileSystemRemoveEntryResponse&
{
(aRhs).AssertSanity();
Type t = (aRhs).type();
switch (t) {
case Tnsresult:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_nsresult()) nsresult(std::move((aRhs).get_nsresult()));
(aRhs).MaybeDestroy();
break;
}
case Tvoid_t:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_void_t()) void_t(std::move((aRhs).get_void_t()));
(aRhs).MaybeDestroy();
break;
}
case T__None:
{
MaybeDestroy();
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
break;
}
}
(aRhs).mType = T__None;
mType = t;
return (*(this));
}
} // namespace fs
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::fs::FileSystemRemoveEntryResponse>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
typedef ::mozilla::dom::fs::FileSystemRemoveEntryResponse union__;
int type = (aVar).type();
IPC::WriteParam(aWriter, type);
// Sentinel = 'FileSystemRemoveEntryResponse'
(aWriter)->WriteSentinel(2925988821);
switch (type) {
case union__::Tnsresult:
{
IPC::WriteParam(aWriter, (aVar).get_nsresult());
// Sentinel = 'Tnsresult'
(aWriter)->WriteSentinel(313394133);
return;
}
case union__::Tvoid_t:
{
IPC::WriteParam(aWriter, (aVar).get_void_t());
// Sentinel = 'Tvoid_t'
(aWriter)->WriteSentinel(189006554);
return;
}
default:
{
aWriter->FatalError("unknown variant of union FileSystemRemoveEntryResponse");
return;
}
}
}
auto ParamTraits<::mozilla::dom::fs::FileSystemRemoveEntryResponse>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
typedef ::mozilla::dom::fs::FileSystemRemoveEntryResponse union__;
auto maybe__type = IPC::ReadParam<int>(aReader);
if (!maybe__type) {
aReader->FatalError("Error deserializing type of union FileSystemRemoveEntryResponse");
return {};
}
auto& type = *maybe__type;
// Sentinel = 'FileSystemRemoveEntryResponse'
if ((!((aReader)->ReadSentinel(2925988821)))) {
mozilla::ipc::SentinelReadError("Error deserializing type of union FileSystemRemoveEntryResponse");
return {};
}
switch (type) {
case union__::Tnsresult:
{
auto maybe__tmp = IPC::ReadParam<::nsresult>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant Tnsresult of union FileSystemRemoveEntryResponse");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'Tnsresult'
if ((!((aReader)->ReadSentinel(313394133)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant Tnsresult of union FileSystemRemoveEntryResponse");
return {};
}
return std::move(tmp);
}
case union__::Tvoid_t:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::void_t>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant Tvoid_t of union FileSystemRemoveEntryResponse");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'Tvoid_t'
if ((!((aReader)->ReadSentinel(189006554)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant Tvoid_t of union FileSystemRemoveEntryResponse");
return {};
}
return std::move(tmp);
}
default:
{
aReader->FatalError("unknown variant of union FileSystemRemoveEntryResponse");
return {};
}
}
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct FileSystemMoveEntryRequest|
//
namespace mozilla {
namespace dom {
namespace fs {
} // namespace fs
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::fs::FileSystemMoveEntryRequest>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).handle());
// Sentinel = 'handle'
(aWriter)->WriteSentinel(142344813);
IPC::WriteParam(aWriter, (aVar).destHandle());
// Sentinel = 'destHandle'
(aWriter)->WriteSentinel(368641021);
}
auto ParamTraits<::mozilla::dom::fs::FileSystemMoveEntryRequest>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___handle = IPC::ReadParam<::mozilla::dom::fs::FileSystemEntryMetadata>(aReader);
if (!maybe___handle) {
aReader->FatalError("Error deserializing 'handle' (FileSystemEntryMetadata) member of 'FileSystemMoveEntryRequest'");
return {};
}
auto& _handle = *maybe___handle;
// Sentinel = 'handle'
if ((!((aReader)->ReadSentinel(142344813)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'handle' (FileSystemEntryMetadata) member of 'FileSystemMoveEntryRequest'");
return {};
}
auto maybe___destHandle = IPC::ReadParam<::mozilla::dom::fs::FileSystemChildMetadata>(aReader);
if (!maybe___destHandle) {
aReader->FatalError("Error deserializing 'destHandle' (FileSystemChildMetadata) member of 'FileSystemMoveEntryRequest'");
return {};
}
auto& _destHandle = *maybe___destHandle;
// Sentinel = 'destHandle'
if ((!((aReader)->ReadSentinel(368641021)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'destHandle' (FileSystemChildMetadata) member of 'FileSystemMoveEntryRequest'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_handle),
std::move(_destHandle)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct FileSystemRenameEntryRequest|
//
namespace mozilla {
namespace dom {
namespace fs {
} // namespace fs
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::fs::FileSystemRenameEntryRequest>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).handle());
// Sentinel = 'handle'
(aWriter)->WriteSentinel(142344813);
IPC::WriteParam(aWriter, (aVar).name());
// Sentinel = 'name'
(aWriter)->WriteSentinel(69075362);
}
auto ParamTraits<::mozilla::dom::fs::FileSystemRenameEntryRequest>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___handle = IPC::ReadParam<::mozilla::dom::fs::FileSystemEntryMetadata>(aReader);
if (!maybe___handle) {
aReader->FatalError("Error deserializing 'handle' (FileSystemEntryMetadata) member of 'FileSystemRenameEntryRequest'");
return {};
}
auto& _handle = *maybe___handle;
// Sentinel = 'handle'
if ((!((aReader)->ReadSentinel(142344813)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'handle' (FileSystemEntryMetadata) member of 'FileSystemRenameEntryRequest'");
return {};
}
auto maybe___name = IPC::ReadParam<::mozilla::dom::fs::Name>(aReader);
if (!maybe___name) {
aReader->FatalError("Error deserializing 'name' (Name) member of 'FileSystemRenameEntryRequest'");
return {};
}
auto& _name = *maybe___name;
// Sentinel = 'name'
if ((!((aReader)->ReadSentinel(69075362)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'name' (Name) member of 'FileSystemRenameEntryRequest'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_handle),
std::move(_name)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |union FileSystemMoveEntryResponse|
//
namespace mozilla {
namespace dom {
namespace fs {
auto FileSystemMoveEntryResponse::MaybeDestroy() -> void
{
if ((mType) == (T__None)) {
return;
}
switch (mType) {
case Tnsresult:
{
(ptr_nsresult())->~nsresult__tdef();
break;
}
case TEntryId:
{
(ptr_EntryId())->~EntryId__tdef();
break;
}
default:
{
mozilla::ipc::LogicError("not reached");
break;
}
}
}
MOZ_IMPLICIT FileSystemMoveEntryResponse::FileSystemMoveEntryResponse(const nsresult& aOther)
{
new (mozilla::KnownNotNull, ptr_nsresult()) nsresult(aOther);
mType = Tnsresult;
}
MOZ_IMPLICIT FileSystemMoveEntryResponse::FileSystemMoveEntryResponse(nsresult&& aOther)
{
new (mozilla::KnownNotNull, ptr_nsresult()) nsresult(std::move(aOther));
mType = Tnsresult;
}
MOZ_IMPLICIT FileSystemMoveEntryResponse::FileSystemMoveEntryResponse(const EntryId& aOther)
{
new (mozilla::KnownNotNull, ptr_EntryId()) EntryId(aOther);
mType = TEntryId;
}
MOZ_IMPLICIT FileSystemMoveEntryResponse::FileSystemMoveEntryResponse(EntryId&& aOther)
{
new (mozilla::KnownNotNull, ptr_EntryId()) EntryId(std::move(aOther));
mType = TEntryId;
}
MOZ_IMPLICIT FileSystemMoveEntryResponse::FileSystemMoveEntryResponse(const FileSystemMoveEntryResponse& aOther)
{
(aOther).AssertSanity();
switch ((aOther).type()) {
case Tnsresult:
{
new (mozilla::KnownNotNull, ptr_nsresult()) nsresult((aOther).get_nsresult());
break;
}
case TEntryId:
{
new (mozilla::KnownNotNull, ptr_EntryId()) EntryId((aOther).get_EntryId());
break;
}
case T__None:
{
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
return;
}
}
mType = (aOther).type();
}
MOZ_IMPLICIT FileSystemMoveEntryResponse::FileSystemMoveEntryResponse(FileSystemMoveEntryResponse&& aOther)
{
(aOther).AssertSanity();
Type t = (aOther).type();
switch (t) {
case Tnsresult:
{
new (mozilla::KnownNotNull, ptr_nsresult()) nsresult(std::move((aOther).get_nsresult()));
(aOther).MaybeDestroy();
break;
}
case TEntryId:
{
new (mozilla::KnownNotNull, ptr_EntryId()) EntryId(std::move((aOther).get_EntryId()));
(aOther).MaybeDestroy();
break;
}
case T__None:
{
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
return;
}
}
(aOther).mType = T__None;
mType = t;
}
FileSystemMoveEntryResponse::~FileSystemMoveEntryResponse()
{
MaybeDestroy();
}
auto FileSystemMoveEntryResponse::operator=(const nsresult& aRhs) -> FileSystemMoveEntryResponse&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_nsresult()) nsresult(aRhs);
mType = Tnsresult;
return (*(this));
}
auto FileSystemMoveEntryResponse::operator=(nsresult&& aRhs) -> FileSystemMoveEntryResponse&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_nsresult()) nsresult(std::move(aRhs));
mType = Tnsresult;
return (*(this));
}
auto FileSystemMoveEntryResponse::operator=(const EntryId& aRhs) -> FileSystemMoveEntryResponse&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_EntryId()) EntryId(aRhs);
mType = TEntryId;
return (*(this));
}
auto FileSystemMoveEntryResponse::operator=(EntryId&& aRhs) -> FileSystemMoveEntryResponse&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_EntryId()) EntryId(std::move(aRhs));
mType = TEntryId;
return (*(this));
}
auto FileSystemMoveEntryResponse::operator=(const FileSystemMoveEntryResponse& aRhs) -> FileSystemMoveEntryResponse&
{
(aRhs).AssertSanity();
Type t = (aRhs).type();
switch (t) {
case Tnsresult:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_nsresult()) nsresult((aRhs).get_nsresult());
break;
}
case TEntryId:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_EntryId()) EntryId((aRhs).get_EntryId());
break;
}
case T__None:
{
MaybeDestroy();
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
break;
}
}
mType = t;
return (*(this));
}
auto FileSystemMoveEntryResponse::operator=(FileSystemMoveEntryResponse&& aRhs) -> FileSystemMoveEntryResponse&
{
(aRhs).AssertSanity();
Type t = (aRhs).type();
switch (t) {
case Tnsresult:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_nsresult()) nsresult(std::move((aRhs).get_nsresult()));
(aRhs).MaybeDestroy();
break;
}
case TEntryId:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_EntryId()) EntryId(std::move((aRhs).get_EntryId()));
(aRhs).MaybeDestroy();
break;
}
case T__None:
{
MaybeDestroy();
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
break;
}
}
(aRhs).mType = T__None;
mType = t;
return (*(this));
}
} // namespace fs
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::fs::FileSystemMoveEntryResponse>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
typedef ::mozilla::dom::fs::FileSystemMoveEntryResponse union__;
int type = (aVar).type();
IPC::WriteParam(aWriter, type);
// Sentinel = 'FileSystemMoveEntryResponse'
(aWriter)->WriteSentinel(2534083326);
switch (type) {
case union__::Tnsresult:
{
IPC::WriteParam(aWriter, (aVar).get_nsresult());
// Sentinel = 'Tnsresult'
(aWriter)->WriteSentinel(313394133);
return;
}
case union__::TEntryId:
{
IPC::WriteParam(aWriter, (aVar).get_EntryId());
// Sentinel = 'TEntryId'
(aWriter)->WriteSentinel(227279636);
return;
}
default:
{
aWriter->FatalError("unknown variant of union FileSystemMoveEntryResponse");
return;
}
}
}
auto ParamTraits<::mozilla::dom::fs::FileSystemMoveEntryResponse>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
typedef ::mozilla::dom::fs::FileSystemMoveEntryResponse union__;
auto maybe__type = IPC::ReadParam<int>(aReader);
if (!maybe__type) {
aReader->FatalError("Error deserializing type of union FileSystemMoveEntryResponse");
return {};
}
auto& type = *maybe__type;
// Sentinel = 'FileSystemMoveEntryResponse'
if ((!((aReader)->ReadSentinel(2534083326)))) {
mozilla::ipc::SentinelReadError("Error deserializing type of union FileSystemMoveEntryResponse");
return {};
}
switch (type) {
case union__::Tnsresult:
{
auto maybe__tmp = IPC::ReadParam<::nsresult>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant Tnsresult of union FileSystemMoveEntryResponse");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'Tnsresult'
if ((!((aReader)->ReadSentinel(313394133)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant Tnsresult of union FileSystemMoveEntryResponse");
return {};
}
return std::move(tmp);
}
case union__::TEntryId:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::dom::fs::EntryId>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TEntryId of union FileSystemMoveEntryResponse");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TEntryId'
if ((!((aReader)->ReadSentinel(227279636)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TEntryId of union FileSystemMoveEntryResponse");
return {};
}
return std::move(tmp);
}
default:
{
aReader->FatalError("unknown variant of union FileSystemMoveEntryResponse");
return {};
}
}
}
} // namespace IPC