Copy as Markdown
Other Tools
//
// Automatically generated by ipdlc.
// Edit at your own risk
//
#include "mozilla/ipc/PBackgroundParent.h"
#include "mozilla/ipc/PBackgroundChild.h"
#include "mozilla/dom/PFetchEventOpProxyParent.h"
#include "mozilla/dom/PFetchEventOpProxyChild.h"
#include "mozilla/GfxMessageUtils.h"
#include "mozilla/dom/CSPMessageUtils.h"
#include "mozilla/dom/DocShellMessageUtils.h"
#include "mozilla/dom/PermissionMessageUtils.h"
#include "mozilla/dom/PropertyBagUtils.h"
#include "mozilla/dom/ReferrerInfoUtils.h"
#include "mozilla/dom/TabMessageUtils.h"
#include "mozilla/ipc/URIUtils.h"
#include "mozilla/layers/LayersMessageUtils.h"
#include "mozilla/net/ClassOfService.h"
#include "mozilla/dom/ServiceWorkerIPCUtils.h"
#include "mozilla/dom/ClientIPCUtils.h"
#include "mozilla/dom/ReferrerInfoUtils.h"
#include "mozilla/dom/WorkerIPCUtils.h"
#include "mozilla/dom/PRemoteWorker.h"
#include "mozilla/dom/PRemoteWorkerParent.h"
#include "mozilla/dom/PRemoteWorkerChild.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 PRemoteWorker {
nsresult
CreateEndpoints(
base::ProcessId aParentDestPid,
base::ProcessId aChildDestPid,
mozilla::ipc::Endpoint<::mozilla::dom::PRemoteWorkerParent>* aParent,
mozilla::ipc::Endpoint<::mozilla::dom::PRemoteWorkerChild>* aChild)
{
return mozilla::ipc::CreateEndpoints(
mozilla::ipc::PrivateIPDLInterface(),
aParentDestPid, aChildDestPid, aParent, aChild);
}
mozilla::UniquePtr<IPC::Message>
Msg_Created(int32_t routingId)
{
return IPC::Message::IPDLMessage(routingId, Msg_Created__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>
Msg_Error(int32_t routingId)
{
return IPC::Message::IPDLMessage(routingId, Msg_Error__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>
Msg_NotifyLock(int32_t routingId)
{
return IPC::Message::IPDLMessage(routingId, Msg_NotifyLock__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>
Msg_NotifyWebTransport(int32_t routingId)
{
return IPC::Message::IPDLMessage(routingId, Msg_NotifyWebTransport__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>
Msg_Close(int32_t routingId)
{
return IPC::Message::IPDLMessage(routingId, Msg_Close__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>
Msg_SetServiceWorkerSkipWaitingFlag(int32_t routingId)
{
return IPC::Message::IPDLMessage(routingId, Msg_SetServiceWorkerSkipWaitingFlag__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_SetServiceWorkerSkipWaitingFlag(int32_t routingId)
{
return IPC::Message::IPDLMessage(routingId, Reply_SetServiceWorkerSkipWaitingFlag__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_PFetchEventOpProxyConstructor(int32_t routingId)
{
return IPC::Message::IPDLMessage(routingId, Msg_PFetchEventOpProxyConstructor__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_PFetchEventOpProxyConstructor(int32_t routingId)
{
return IPC::Message::IPDLMessage(routingId, Reply_PFetchEventOpProxyConstructor__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___delete__(int32_t routingId)
{
return IPC::Message::IPDLMessage(routingId, Msg___delete____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___delete__(int32_t routingId)
{
return IPC::Message::IPDLMessage(routingId, Reply___delete____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_ExecOp(int32_t routingId)
{
return IPC::Message::IPDLMessage(routingId, Msg_ExecOp__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>
Msg_ExecServiceWorkerOp(int32_t routingId)
{
return IPC::Message::IPDLMessage(routingId, Msg_ExecServiceWorkerOp__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_ExecServiceWorkerOp(int32_t routingId)
{
return IPC::Message::IPDLMessage(routingId, Reply_ExecServiceWorkerOp__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 PRemoteWorker
} // namespace dom
} // namespace mozilla
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct RemoteWorkerSuspendOp|
//
namespace mozilla {
namespace dom {
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::RemoteWorkerSuspendOp>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
}
auto ParamTraits<::mozilla::dom::RemoteWorkerSuspendOp>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
IPC::ReadResult<paramType> result__{std::in_place};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct RemoteWorkerResumeOp|
//
namespace mozilla {
namespace dom {
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::RemoteWorkerResumeOp>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
}
auto ParamTraits<::mozilla::dom::RemoteWorkerResumeOp>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
IPC::ReadResult<paramType> result__{std::in_place};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct RemoteWorkerFreezeOp|
//
namespace mozilla {
namespace dom {
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::RemoteWorkerFreezeOp>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
}
auto ParamTraits<::mozilla::dom::RemoteWorkerFreezeOp>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
IPC::ReadResult<paramType> result__{std::in_place};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct RemoteWorkerThawOp|
//
namespace mozilla {
namespace dom {
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::RemoteWorkerThawOp>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
}
auto ParamTraits<::mozilla::dom::RemoteWorkerThawOp>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
IPC::ReadResult<paramType> result__{std::in_place};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct RemoteWorkerTerminateOp|
//
namespace mozilla {
namespace dom {
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::RemoteWorkerTerminateOp>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
}
auto ParamTraits<::mozilla::dom::RemoteWorkerTerminateOp>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
IPC::ReadResult<paramType> result__{std::in_place};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct RemoteWorkerPortIdentifierOp|
//
namespace mozilla {
namespace dom {
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::RemoteWorkerPortIdentifierOp>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).portIdentifier());
// Sentinel = 'portIdentifier'
(aWriter)->WriteSentinel(729875913);
}
auto ParamTraits<::mozilla::dom::RemoteWorkerPortIdentifierOp>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___portIdentifier = IPC::ReadParam<::mozilla::dom::MessagePortIdentifier>(aReader);
if (!maybe___portIdentifier) {
aReader->FatalError("Error deserializing 'portIdentifier' (MessagePortIdentifier) member of 'RemoteWorkerPortIdentifierOp'");
return {};
}
auto& _portIdentifier = *maybe___portIdentifier;
// Sentinel = 'portIdentifier'
if ((!((aReader)->ReadSentinel(729875913)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'portIdentifier' (MessagePortIdentifier) member of 'RemoteWorkerPortIdentifierOp'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_portIdentifier)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct RemoteWorkerAddWindowIDOp|
//
namespace mozilla {
namespace dom {
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::RemoteWorkerAddWindowIDOp>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
(aWriter)->WriteBytes((&((aVar).windowID())), 8);
// Sentinel = 'windowID'
(aWriter)->WriteSentinel(253625126);
}
auto ParamTraits<::mozilla::dom::RemoteWorkerAddWindowIDOp>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
IPC::ReadResult<paramType> result__{
std::in_place,
::uint64_t{0}};
if ((!((aReader)->ReadBytesInto((&((result__)->windowID())), 8)))) {
aReader->FatalError("Error bulk reading fields from uint64_t");
return {};
}
// Sentinel = 'windowID'
if ((!((aReader)->ReadSentinel(253625126)))) {
mozilla::ipc::SentinelReadError("Error bulk reading fields from uint64_t");
return {};
}
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct RemoteWorkerRemoveWindowIDOp|
//
namespace mozilla {
namespace dom {
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::RemoteWorkerRemoveWindowIDOp>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
(aWriter)->WriteBytes((&((aVar).windowID())), 8);
// Sentinel = 'windowID'
(aWriter)->WriteSentinel(253625126);
}
auto ParamTraits<::mozilla::dom::RemoteWorkerRemoveWindowIDOp>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
IPC::ReadResult<paramType> result__{
std::in_place,
::uint64_t{0}};
if ((!((aReader)->ReadBytesInto((&((result__)->windowID())), 8)))) {
aReader->FatalError("Error bulk reading fields from uint64_t");
return {};
}
// Sentinel = 'windowID'
if ((!((aReader)->ReadSentinel(253625126)))) {
mozilla::ipc::SentinelReadError("Error bulk reading fields from uint64_t");
return {};
}
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |union RemoteWorkerOp|
//
namespace mozilla {
namespace dom {
auto RemoteWorkerOp::MaybeDestroy() -> void
{
if ((mType) == (T__None)) {
return;
}
switch (mType) {
case TRemoteWorkerSuspendOp:
{
(ptr_RemoteWorkerSuspendOp())->~RemoteWorkerSuspendOp__tdef();
break;
}
case TRemoteWorkerResumeOp:
{
(ptr_RemoteWorkerResumeOp())->~RemoteWorkerResumeOp__tdef();
break;
}
case TRemoteWorkerFreezeOp:
{
(ptr_RemoteWorkerFreezeOp())->~RemoteWorkerFreezeOp__tdef();
break;
}
case TRemoteWorkerThawOp:
{
(ptr_RemoteWorkerThawOp())->~RemoteWorkerThawOp__tdef();
break;
}
case TRemoteWorkerTerminateOp:
{
(ptr_RemoteWorkerTerminateOp())->~RemoteWorkerTerminateOp__tdef();
break;
}
case TRemoteWorkerPortIdentifierOp:
{
(ptr_RemoteWorkerPortIdentifierOp())->~RemoteWorkerPortIdentifierOp__tdef();
break;
}
case TRemoteWorkerAddWindowIDOp:
{
(ptr_RemoteWorkerAddWindowIDOp())->~RemoteWorkerAddWindowIDOp__tdef();
break;
}
case TRemoteWorkerRemoveWindowIDOp:
{
(ptr_RemoteWorkerRemoveWindowIDOp())->~RemoteWorkerRemoveWindowIDOp__tdef();
break;
}
default:
{
mozilla::ipc::LogicError("not reached");
break;
}
}
}
MOZ_IMPLICIT RemoteWorkerOp::RemoteWorkerOp(const RemoteWorkerSuspendOp& aOther)
{
new (mozilla::KnownNotNull, ptr_RemoteWorkerSuspendOp()) RemoteWorkerSuspendOp(aOther);
mType = TRemoteWorkerSuspendOp;
}
MOZ_IMPLICIT RemoteWorkerOp::RemoteWorkerOp(RemoteWorkerSuspendOp&& aOther)
{
new (mozilla::KnownNotNull, ptr_RemoteWorkerSuspendOp()) RemoteWorkerSuspendOp(std::move(aOther));
mType = TRemoteWorkerSuspendOp;
}
MOZ_IMPLICIT RemoteWorkerOp::RemoteWorkerOp(const RemoteWorkerResumeOp& aOther)
{
new (mozilla::KnownNotNull, ptr_RemoteWorkerResumeOp()) RemoteWorkerResumeOp(aOther);
mType = TRemoteWorkerResumeOp;
}
MOZ_IMPLICIT RemoteWorkerOp::RemoteWorkerOp(RemoteWorkerResumeOp&& aOther)
{
new (mozilla::KnownNotNull, ptr_RemoteWorkerResumeOp()) RemoteWorkerResumeOp(std::move(aOther));
mType = TRemoteWorkerResumeOp;
}
MOZ_IMPLICIT RemoteWorkerOp::RemoteWorkerOp(const RemoteWorkerFreezeOp& aOther)
{
new (mozilla::KnownNotNull, ptr_RemoteWorkerFreezeOp()) RemoteWorkerFreezeOp(aOther);
mType = TRemoteWorkerFreezeOp;
}
MOZ_IMPLICIT RemoteWorkerOp::RemoteWorkerOp(RemoteWorkerFreezeOp&& aOther)
{
new (mozilla::KnownNotNull, ptr_RemoteWorkerFreezeOp()) RemoteWorkerFreezeOp(std::move(aOther));
mType = TRemoteWorkerFreezeOp;
}
MOZ_IMPLICIT RemoteWorkerOp::RemoteWorkerOp(const RemoteWorkerThawOp& aOther)
{
new (mozilla::KnownNotNull, ptr_RemoteWorkerThawOp()) RemoteWorkerThawOp(aOther);
mType = TRemoteWorkerThawOp;
}
MOZ_IMPLICIT RemoteWorkerOp::RemoteWorkerOp(RemoteWorkerThawOp&& aOther)
{
new (mozilla::KnownNotNull, ptr_RemoteWorkerThawOp()) RemoteWorkerThawOp(std::move(aOther));
mType = TRemoteWorkerThawOp;
}
MOZ_IMPLICIT RemoteWorkerOp::RemoteWorkerOp(const RemoteWorkerTerminateOp& aOther)
{
new (mozilla::KnownNotNull, ptr_RemoteWorkerTerminateOp()) RemoteWorkerTerminateOp(aOther);
mType = TRemoteWorkerTerminateOp;
}
MOZ_IMPLICIT RemoteWorkerOp::RemoteWorkerOp(RemoteWorkerTerminateOp&& aOther)
{
new (mozilla::KnownNotNull, ptr_RemoteWorkerTerminateOp()) RemoteWorkerTerminateOp(std::move(aOther));
mType = TRemoteWorkerTerminateOp;
}
MOZ_IMPLICIT RemoteWorkerOp::RemoteWorkerOp(const RemoteWorkerPortIdentifierOp& aOther)
{
new (mozilla::KnownNotNull, ptr_RemoteWorkerPortIdentifierOp()) RemoteWorkerPortIdentifierOp(aOther);
mType = TRemoteWorkerPortIdentifierOp;
}
MOZ_IMPLICIT RemoteWorkerOp::RemoteWorkerOp(RemoteWorkerPortIdentifierOp&& aOther)
{
new (mozilla::KnownNotNull, ptr_RemoteWorkerPortIdentifierOp()) RemoteWorkerPortIdentifierOp(std::move(aOther));
mType = TRemoteWorkerPortIdentifierOp;
}
MOZ_IMPLICIT RemoteWorkerOp::RemoteWorkerOp(const RemoteWorkerAddWindowIDOp& aOther)
{
new (mozilla::KnownNotNull, ptr_RemoteWorkerAddWindowIDOp()) RemoteWorkerAddWindowIDOp(aOther);
mType = TRemoteWorkerAddWindowIDOp;
}
MOZ_IMPLICIT RemoteWorkerOp::RemoteWorkerOp(RemoteWorkerAddWindowIDOp&& aOther)
{
new (mozilla::KnownNotNull, ptr_RemoteWorkerAddWindowIDOp()) RemoteWorkerAddWindowIDOp(std::move(aOther));
mType = TRemoteWorkerAddWindowIDOp;
}
MOZ_IMPLICIT RemoteWorkerOp::RemoteWorkerOp(const RemoteWorkerRemoveWindowIDOp& aOther)
{
new (mozilla::KnownNotNull, ptr_RemoteWorkerRemoveWindowIDOp()) RemoteWorkerRemoveWindowIDOp(aOther);
mType = TRemoteWorkerRemoveWindowIDOp;
}
MOZ_IMPLICIT RemoteWorkerOp::RemoteWorkerOp(RemoteWorkerRemoveWindowIDOp&& aOther)
{
new (mozilla::KnownNotNull, ptr_RemoteWorkerRemoveWindowIDOp()) RemoteWorkerRemoveWindowIDOp(std::move(aOther));
mType = TRemoteWorkerRemoveWindowIDOp;
}
MOZ_IMPLICIT RemoteWorkerOp::RemoteWorkerOp(const RemoteWorkerOp& aOther)
{
(aOther).AssertSanity();
switch ((aOther).type()) {
case TRemoteWorkerSuspendOp:
{
new (mozilla::KnownNotNull, ptr_RemoteWorkerSuspendOp()) RemoteWorkerSuspendOp((aOther).get_RemoteWorkerSuspendOp());
break;
}
case TRemoteWorkerResumeOp:
{
new (mozilla::KnownNotNull, ptr_RemoteWorkerResumeOp()) RemoteWorkerResumeOp((aOther).get_RemoteWorkerResumeOp());
break;
}
case TRemoteWorkerFreezeOp:
{
new (mozilla::KnownNotNull, ptr_RemoteWorkerFreezeOp()) RemoteWorkerFreezeOp((aOther).get_RemoteWorkerFreezeOp());
break;
}
case TRemoteWorkerThawOp:
{
new (mozilla::KnownNotNull, ptr_RemoteWorkerThawOp()) RemoteWorkerThawOp((aOther).get_RemoteWorkerThawOp());
break;
}
case TRemoteWorkerTerminateOp:
{
new (mozilla::KnownNotNull, ptr_RemoteWorkerTerminateOp()) RemoteWorkerTerminateOp((aOther).get_RemoteWorkerTerminateOp());
break;
}
case TRemoteWorkerPortIdentifierOp:
{
new (mozilla::KnownNotNull, ptr_RemoteWorkerPortIdentifierOp()) RemoteWorkerPortIdentifierOp((aOther).get_RemoteWorkerPortIdentifierOp());
break;
}
case TRemoteWorkerAddWindowIDOp:
{
new (mozilla::KnownNotNull, ptr_RemoteWorkerAddWindowIDOp()) RemoteWorkerAddWindowIDOp((aOther).get_RemoteWorkerAddWindowIDOp());
break;
}
case TRemoteWorkerRemoveWindowIDOp:
{
new (mozilla::KnownNotNull, ptr_RemoteWorkerRemoveWindowIDOp()) RemoteWorkerRemoveWindowIDOp((aOther).get_RemoteWorkerRemoveWindowIDOp());
break;
}
case T__None:
{
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
return;
}
}
mType = (aOther).type();
}
MOZ_IMPLICIT RemoteWorkerOp::RemoteWorkerOp(RemoteWorkerOp&& aOther)
{
(aOther).AssertSanity();
Type t = (aOther).type();
switch (t) {
case TRemoteWorkerSuspendOp:
{
new (mozilla::KnownNotNull, ptr_RemoteWorkerSuspendOp()) RemoteWorkerSuspendOp(std::move((aOther).get_RemoteWorkerSuspendOp()));
(aOther).MaybeDestroy();
break;
}
case TRemoteWorkerResumeOp:
{
new (mozilla::KnownNotNull, ptr_RemoteWorkerResumeOp()) RemoteWorkerResumeOp(std::move((aOther).get_RemoteWorkerResumeOp()));
(aOther).MaybeDestroy();
break;
}
case TRemoteWorkerFreezeOp:
{
new (mozilla::KnownNotNull, ptr_RemoteWorkerFreezeOp()) RemoteWorkerFreezeOp(std::move((aOther).get_RemoteWorkerFreezeOp()));
(aOther).MaybeDestroy();
break;
}
case TRemoteWorkerThawOp:
{
new (mozilla::KnownNotNull, ptr_RemoteWorkerThawOp()) RemoteWorkerThawOp(std::move((aOther).get_RemoteWorkerThawOp()));
(aOther).MaybeDestroy();
break;
}
case TRemoteWorkerTerminateOp:
{
new (mozilla::KnownNotNull, ptr_RemoteWorkerTerminateOp()) RemoteWorkerTerminateOp(std::move((aOther).get_RemoteWorkerTerminateOp()));
(aOther).MaybeDestroy();
break;
}
case TRemoteWorkerPortIdentifierOp:
{
new (mozilla::KnownNotNull, ptr_RemoteWorkerPortIdentifierOp()) RemoteWorkerPortIdentifierOp(std::move((aOther).get_RemoteWorkerPortIdentifierOp()));
(aOther).MaybeDestroy();
break;
}
case TRemoteWorkerAddWindowIDOp:
{
new (mozilla::KnownNotNull, ptr_RemoteWorkerAddWindowIDOp()) RemoteWorkerAddWindowIDOp(std::move((aOther).get_RemoteWorkerAddWindowIDOp()));
(aOther).MaybeDestroy();
break;
}
case TRemoteWorkerRemoveWindowIDOp:
{
new (mozilla::KnownNotNull, ptr_RemoteWorkerRemoveWindowIDOp()) RemoteWorkerRemoveWindowIDOp(std::move((aOther).get_RemoteWorkerRemoveWindowIDOp()));
(aOther).MaybeDestroy();
break;
}
case T__None:
{
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
return;
}
}
(aOther).mType = T__None;
mType = t;
}
RemoteWorkerOp::~RemoteWorkerOp()
{
MaybeDestroy();
}
auto RemoteWorkerOp::operator=(const RemoteWorkerSuspendOp& aRhs) -> RemoteWorkerOp&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_RemoteWorkerSuspendOp()) RemoteWorkerSuspendOp(aRhs);
mType = TRemoteWorkerSuspendOp;
return (*(this));
}
auto RemoteWorkerOp::operator=(RemoteWorkerSuspendOp&& aRhs) -> RemoteWorkerOp&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_RemoteWorkerSuspendOp()) RemoteWorkerSuspendOp(std::move(aRhs));
mType = TRemoteWorkerSuspendOp;
return (*(this));
}
auto RemoteWorkerOp::operator=(const RemoteWorkerResumeOp& aRhs) -> RemoteWorkerOp&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_RemoteWorkerResumeOp()) RemoteWorkerResumeOp(aRhs);
mType = TRemoteWorkerResumeOp;
return (*(this));
}
auto RemoteWorkerOp::operator=(RemoteWorkerResumeOp&& aRhs) -> RemoteWorkerOp&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_RemoteWorkerResumeOp()) RemoteWorkerResumeOp(std::move(aRhs));
mType = TRemoteWorkerResumeOp;
return (*(this));
}
auto RemoteWorkerOp::operator=(const RemoteWorkerFreezeOp& aRhs) -> RemoteWorkerOp&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_RemoteWorkerFreezeOp()) RemoteWorkerFreezeOp(aRhs);
mType = TRemoteWorkerFreezeOp;
return (*(this));
}
auto RemoteWorkerOp::operator=(RemoteWorkerFreezeOp&& aRhs) -> RemoteWorkerOp&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_RemoteWorkerFreezeOp()) RemoteWorkerFreezeOp(std::move(aRhs));
mType = TRemoteWorkerFreezeOp;
return (*(this));
}
auto RemoteWorkerOp::operator=(const RemoteWorkerThawOp& aRhs) -> RemoteWorkerOp&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_RemoteWorkerThawOp()) RemoteWorkerThawOp(aRhs);
mType = TRemoteWorkerThawOp;
return (*(this));
}
auto RemoteWorkerOp::operator=(RemoteWorkerThawOp&& aRhs) -> RemoteWorkerOp&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_RemoteWorkerThawOp()) RemoteWorkerThawOp(std::move(aRhs));
mType = TRemoteWorkerThawOp;
return (*(this));
}
auto RemoteWorkerOp::operator=(const RemoteWorkerTerminateOp& aRhs) -> RemoteWorkerOp&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_RemoteWorkerTerminateOp()) RemoteWorkerTerminateOp(aRhs);
mType = TRemoteWorkerTerminateOp;
return (*(this));
}
auto RemoteWorkerOp::operator=(RemoteWorkerTerminateOp&& aRhs) -> RemoteWorkerOp&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_RemoteWorkerTerminateOp()) RemoteWorkerTerminateOp(std::move(aRhs));
mType = TRemoteWorkerTerminateOp;
return (*(this));
}
auto RemoteWorkerOp::operator=(const RemoteWorkerPortIdentifierOp& aRhs) -> RemoteWorkerOp&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_RemoteWorkerPortIdentifierOp()) RemoteWorkerPortIdentifierOp(aRhs);
mType = TRemoteWorkerPortIdentifierOp;
return (*(this));
}
auto RemoteWorkerOp::operator=(RemoteWorkerPortIdentifierOp&& aRhs) -> RemoteWorkerOp&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_RemoteWorkerPortIdentifierOp()) RemoteWorkerPortIdentifierOp(std::move(aRhs));
mType = TRemoteWorkerPortIdentifierOp;
return (*(this));
}
auto RemoteWorkerOp::operator=(const RemoteWorkerAddWindowIDOp& aRhs) -> RemoteWorkerOp&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_RemoteWorkerAddWindowIDOp()) RemoteWorkerAddWindowIDOp(aRhs);
mType = TRemoteWorkerAddWindowIDOp;
return (*(this));
}
auto RemoteWorkerOp::operator=(RemoteWorkerAddWindowIDOp&& aRhs) -> RemoteWorkerOp&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_RemoteWorkerAddWindowIDOp()) RemoteWorkerAddWindowIDOp(std::move(aRhs));
mType = TRemoteWorkerAddWindowIDOp;
return (*(this));
}
auto RemoteWorkerOp::operator=(const RemoteWorkerRemoveWindowIDOp& aRhs) -> RemoteWorkerOp&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_RemoteWorkerRemoveWindowIDOp()) RemoteWorkerRemoveWindowIDOp(aRhs);
mType = TRemoteWorkerRemoveWindowIDOp;
return (*(this));
}
auto RemoteWorkerOp::operator=(RemoteWorkerRemoveWindowIDOp&& aRhs) -> RemoteWorkerOp&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_RemoteWorkerRemoveWindowIDOp()) RemoteWorkerRemoveWindowIDOp(std::move(aRhs));
mType = TRemoteWorkerRemoveWindowIDOp;
return (*(this));
}
auto RemoteWorkerOp::operator=(const RemoteWorkerOp& aRhs) -> RemoteWorkerOp&
{
(aRhs).AssertSanity();
Type t = (aRhs).type();
switch (t) {
case TRemoteWorkerSuspendOp:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_RemoteWorkerSuspendOp()) RemoteWorkerSuspendOp((aRhs).get_RemoteWorkerSuspendOp());
break;
}
case TRemoteWorkerResumeOp:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_RemoteWorkerResumeOp()) RemoteWorkerResumeOp((aRhs).get_RemoteWorkerResumeOp());
break;
}
case TRemoteWorkerFreezeOp:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_RemoteWorkerFreezeOp()) RemoteWorkerFreezeOp((aRhs).get_RemoteWorkerFreezeOp());
break;
}
case TRemoteWorkerThawOp:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_RemoteWorkerThawOp()) RemoteWorkerThawOp((aRhs).get_RemoteWorkerThawOp());
break;
}
case TRemoteWorkerTerminateOp:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_RemoteWorkerTerminateOp()) RemoteWorkerTerminateOp((aRhs).get_RemoteWorkerTerminateOp());
break;
}
case TRemoteWorkerPortIdentifierOp:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_RemoteWorkerPortIdentifierOp()) RemoteWorkerPortIdentifierOp((aRhs).get_RemoteWorkerPortIdentifierOp());
break;
}
case TRemoteWorkerAddWindowIDOp:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_RemoteWorkerAddWindowIDOp()) RemoteWorkerAddWindowIDOp((aRhs).get_RemoteWorkerAddWindowIDOp());
break;
}
case TRemoteWorkerRemoveWindowIDOp:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_RemoteWorkerRemoveWindowIDOp()) RemoteWorkerRemoveWindowIDOp((aRhs).get_RemoteWorkerRemoveWindowIDOp());
break;
}
case T__None:
{
MaybeDestroy();
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
break;
}
}
mType = t;
return (*(this));
}
auto RemoteWorkerOp::operator=(RemoteWorkerOp&& aRhs) -> RemoteWorkerOp&
{
(aRhs).AssertSanity();
Type t = (aRhs).type();
switch (t) {
case TRemoteWorkerSuspendOp:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_RemoteWorkerSuspendOp()) RemoteWorkerSuspendOp(std::move((aRhs).get_RemoteWorkerSuspendOp()));
(aRhs).MaybeDestroy();
break;
}
case TRemoteWorkerResumeOp:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_RemoteWorkerResumeOp()) RemoteWorkerResumeOp(std::move((aRhs).get_RemoteWorkerResumeOp()));
(aRhs).MaybeDestroy();
break;
}
case TRemoteWorkerFreezeOp:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_RemoteWorkerFreezeOp()) RemoteWorkerFreezeOp(std::move((aRhs).get_RemoteWorkerFreezeOp()));
(aRhs).MaybeDestroy();
break;
}
case TRemoteWorkerThawOp:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_RemoteWorkerThawOp()) RemoteWorkerThawOp(std::move((aRhs).get_RemoteWorkerThawOp()));
(aRhs).MaybeDestroy();
break;
}
case TRemoteWorkerTerminateOp:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_RemoteWorkerTerminateOp()) RemoteWorkerTerminateOp(std::move((aRhs).get_RemoteWorkerTerminateOp()));
(aRhs).MaybeDestroy();
break;
}
case TRemoteWorkerPortIdentifierOp:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_RemoteWorkerPortIdentifierOp()) RemoteWorkerPortIdentifierOp(std::move((aRhs).get_RemoteWorkerPortIdentifierOp()));
(aRhs).MaybeDestroy();
break;
}
case TRemoteWorkerAddWindowIDOp:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_RemoteWorkerAddWindowIDOp()) RemoteWorkerAddWindowIDOp(std::move((aRhs).get_RemoteWorkerAddWindowIDOp()));
(aRhs).MaybeDestroy();
break;
}
case TRemoteWorkerRemoveWindowIDOp:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_RemoteWorkerRemoveWindowIDOp()) RemoteWorkerRemoveWindowIDOp(std::move((aRhs).get_RemoteWorkerRemoveWindowIDOp()));
(aRhs).MaybeDestroy();
break;
}
case T__None:
{
MaybeDestroy();
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
break;
}
}
(aRhs).mType = T__None;
mType = t;
return (*(this));
}
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::RemoteWorkerOp>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
typedef ::mozilla::dom::RemoteWorkerOp union__;
int type = (aVar).type();
IPC::WriteParam(aWriter, type);
// Sentinel = 'RemoteWorkerOp'
(aWriter)->WriteSentinel(706545062);
switch (type) {
case union__::TRemoteWorkerSuspendOp:
{
IPC::WriteParam(aWriter, (aVar).get_RemoteWorkerSuspendOp());
// Sentinel = 'TRemoteWorkerSuspendOp'
(aWriter)->WriteSentinel(1692141788);
return;
}
case union__::TRemoteWorkerResumeOp:
{
IPC::WriteParam(aWriter, (aVar).get_RemoteWorkerResumeOp());
// Sentinel = 'TRemoteWorkerResumeOp'
(aWriter)->WriteSentinel(1537017963);
return;
}
case union__::TRemoteWorkerFreezeOp:
{
IPC::WriteParam(aWriter, (aVar).get_RemoteWorkerFreezeOp());
// Sentinel = 'TRemoteWorkerFreezeOp'
(aWriter)->WriteSentinel(1529350235);
return;
}
case union__::TRemoteWorkerThawOp:
{
IPC::WriteParam(aWriter, (aVar).get_RemoteWorkerThawOp());
// Sentinel = 'TRemoteWorkerThawOp'
(aWriter)->WriteSentinel(1256130446);
return;
}
case union__::TRemoteWorkerTerminateOp:
{
IPC::WriteParam(aWriter, (aVar).get_RemoteWorkerTerminateOp());
// Sentinel = 'TRemoteWorkerTerminateOp'
(aWriter)->WriteSentinel(2003569059);
return;
}
case union__::TRemoteWorkerPortIdentifierOp:
{
IPC::WriteParam(aWriter, (aVar).get_RemoteWorkerPortIdentifierOp());
// Sentinel = 'TRemoteWorkerPortIdentifierOp'
(aWriter)->WriteSentinel(2907114402);
return;
}
case union__::TRemoteWorkerAddWindowIDOp:
{
IPC::WriteParam(aWriter, (aVar).get_RemoteWorkerAddWindowIDOp());
// Sentinel = 'TRemoteWorkerAddWindowIDOp'
(aWriter)->WriteSentinel(2298219016);
return;
}
case union__::TRemoteWorkerRemoveWindowIDOp:
{
IPC::WriteParam(aWriter, (aVar).get_RemoteWorkerRemoveWindowIDOp());
// Sentinel = 'TRemoteWorkerRemoveWindowIDOp'
(aWriter)->WriteSentinel(2900822893);
return;
}
default:
{
aWriter->FatalError("unknown variant of union RemoteWorkerOp");
return;
}
}
}
auto ParamTraits<::mozilla::dom::RemoteWorkerOp>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
typedef ::mozilla::dom::RemoteWorkerOp union__;
auto maybe__type = IPC::ReadParam<int>(aReader);
if (!maybe__type) {
aReader->FatalError("Error deserializing type of union RemoteWorkerOp");
return {};
}
auto& type = *maybe__type;
// Sentinel = 'RemoteWorkerOp'
if ((!((aReader)->ReadSentinel(706545062)))) {
mozilla::ipc::SentinelReadError("Error deserializing type of union RemoteWorkerOp");
return {};
}
switch (type) {
case union__::TRemoteWorkerSuspendOp:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::dom::RemoteWorkerSuspendOp>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TRemoteWorkerSuspendOp of union RemoteWorkerOp");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TRemoteWorkerSuspendOp'
if ((!((aReader)->ReadSentinel(1692141788)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TRemoteWorkerSuspendOp of union RemoteWorkerOp");
return {};
}
return std::move(tmp);
}
case union__::TRemoteWorkerResumeOp:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::dom::RemoteWorkerResumeOp>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TRemoteWorkerResumeOp of union RemoteWorkerOp");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TRemoteWorkerResumeOp'
if ((!((aReader)->ReadSentinel(1537017963)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TRemoteWorkerResumeOp of union RemoteWorkerOp");
return {};
}
return std::move(tmp);
}
case union__::TRemoteWorkerFreezeOp:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::dom::RemoteWorkerFreezeOp>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TRemoteWorkerFreezeOp of union RemoteWorkerOp");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TRemoteWorkerFreezeOp'
if ((!((aReader)->ReadSentinel(1529350235)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TRemoteWorkerFreezeOp of union RemoteWorkerOp");
return {};
}
return std::move(tmp);
}
case union__::TRemoteWorkerThawOp:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::dom::RemoteWorkerThawOp>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TRemoteWorkerThawOp of union RemoteWorkerOp");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TRemoteWorkerThawOp'
if ((!((aReader)->ReadSentinel(1256130446)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TRemoteWorkerThawOp of union RemoteWorkerOp");
return {};
}
return std::move(tmp);
}
case union__::TRemoteWorkerTerminateOp:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::dom::RemoteWorkerTerminateOp>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TRemoteWorkerTerminateOp of union RemoteWorkerOp");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TRemoteWorkerTerminateOp'
if ((!((aReader)->ReadSentinel(2003569059)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TRemoteWorkerTerminateOp of union RemoteWorkerOp");
return {};
}
return std::move(tmp);
}
case union__::TRemoteWorkerPortIdentifierOp:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::dom::RemoteWorkerPortIdentifierOp>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TRemoteWorkerPortIdentifierOp of union RemoteWorkerOp");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TRemoteWorkerPortIdentifierOp'
if ((!((aReader)->ReadSentinel(2907114402)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TRemoteWorkerPortIdentifierOp of union RemoteWorkerOp");
return {};
}
return std::move(tmp);
}
case union__::TRemoteWorkerAddWindowIDOp:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::dom::RemoteWorkerAddWindowIDOp>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TRemoteWorkerAddWindowIDOp of union RemoteWorkerOp");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TRemoteWorkerAddWindowIDOp'
if ((!((aReader)->ReadSentinel(2298219016)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TRemoteWorkerAddWindowIDOp of union RemoteWorkerOp");
return {};
}
return std::move(tmp);
}
case union__::TRemoteWorkerRemoveWindowIDOp:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::dom::RemoteWorkerRemoveWindowIDOp>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TRemoteWorkerRemoveWindowIDOp of union RemoteWorkerOp");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TRemoteWorkerRemoveWindowIDOp'
if ((!((aReader)->ReadSentinel(2900822893)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TRemoteWorkerRemoveWindowIDOp of union RemoteWorkerOp");
return {};
}
return std::move(tmp);
}
default:
{
aReader->FatalError("unknown variant of union RemoteWorkerOp");
return {};
}
}
}
} // namespace IPC