Copy as Markdown
Other Tools
//
// Automatically generated by ipdlc.
// Edit at your own risk
//
#include "mozilla/dom/ServiceWorkerIPCUtils.h"
#include "mozilla/dom/BindingIPCUtils.h"
#include "mozilla/dom/ClientIPCUtils.h"
#include "ipc/ErrorIPCUtils.h"
#include "mozilla/dom/DomSecurityIPCUtils.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/dom/notification/IPCUtils.h"
#include "mozilla/ipc/URIUtils.h"
#include "mozilla/layers/LayersMessageUtils.h"
#include "mozilla/net/NeckoMessageUtils.h"
#include "mozilla/dom/FetchIPCTypes.h"
#include "mozilla/ipc/TransportSecurityInfoUtils.h"
#include "mozilla/dom/ServiceWorkerOpArgs.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"
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct ServiceWorkerCheckScriptEvaluationOpArgs|
//
namespace mozilla {
namespace dom {
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::ServiceWorkerCheckScriptEvaluationOpArgs>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
}
auto ParamTraits<::mozilla::dom::ServiceWorkerCheckScriptEvaluationOpArgs>::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 ServiceWorkerUpdateStateOpArgs|
//
namespace mozilla {
namespace dom {
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::ServiceWorkerUpdateStateOpArgs>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).state());
// Sentinel = 'state'
(aWriter)->WriteSentinel(109314594);
}
auto ParamTraits<::mozilla::dom::ServiceWorkerUpdateStateOpArgs>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___state = IPC::ReadParam<::mozilla::dom::ServiceWorkerState>(aReader);
if (!maybe___state) {
aReader->FatalError("Error deserializing 'state' (ServiceWorkerState) member of 'ServiceWorkerUpdateStateOpArgs'");
return {};
}
auto& _state = *maybe___state;
// Sentinel = 'state'
if ((!((aReader)->ReadSentinel(109314594)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'state' (ServiceWorkerState) member of 'ServiceWorkerUpdateStateOpArgs'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_state)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct ServiceWorkerTerminateWorkerOpArgs|
//
namespace mozilla {
namespace dom {
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::ServiceWorkerTerminateWorkerOpArgs>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
(aWriter)->WriteBytes((&((aVar).shutdownStateId())), 4);
// Sentinel = 'shutdownStateId'
(aWriter)->WriteSentinel(854918699);
}
auto ParamTraits<::mozilla::dom::ServiceWorkerTerminateWorkerOpArgs>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
IPC::ReadResult<paramType> result__{
std::in_place,
::uint32_t{0}};
if ((!((aReader)->ReadBytesInto((&((result__)->shutdownStateId())), 4)))) {
aReader->FatalError("Error bulk reading fields from uint32_t");
return {};
}
// Sentinel = 'shutdownStateId'
if ((!((aReader)->ReadSentinel(854918699)))) {
mozilla::ipc::SentinelReadError("Error bulk reading fields from uint32_t");
return {};
}
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct ServiceWorkerLifeCycleEventOpArgs|
//
namespace mozilla {
namespace dom {
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::ServiceWorkerLifeCycleEventOpArgs>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).eventName());
// Sentinel = 'eventName'
(aWriter)->WriteSentinel(310051748);
}
auto ParamTraits<::mozilla::dom::ServiceWorkerLifeCycleEventOpArgs>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___eventName = IPC::ReadParam<::nsString>(aReader);
if (!maybe___eventName) {
aReader->FatalError("Error deserializing 'eventName' (nsString) member of 'ServiceWorkerLifeCycleEventOpArgs'");
return {};
}
auto& _eventName = *maybe___eventName;
// Sentinel = 'eventName'
if ((!((aReader)->ReadSentinel(310051748)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'eventName' (nsString) member of 'ServiceWorkerLifeCycleEventOpArgs'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_eventName)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |union OptionalPushData|
//
namespace mozilla {
namespace dom {
auto OptionalPushData::MaybeDestroy() -> void
{
if ((mType) == (T__None)) {
return;
}
switch (mType) {
case Tvoid_t:
{
(ptr_void_t())->~void_t__tdef();
break;
}
case TArrayOfuint8_t:
{
(ptr_ArrayOfuint8_t())->~ArrayOfuint8_t__tdef();
break;
}
default:
{
mozilla::ipc::LogicError("not reached");
break;
}
}
}
MOZ_IMPLICIT OptionalPushData::OptionalPushData(const void_t& aOther)
{
new (mozilla::KnownNotNull, ptr_void_t()) void_t(aOther);
mType = Tvoid_t;
}
MOZ_IMPLICIT OptionalPushData::OptionalPushData(void_t&& aOther)
{
new (mozilla::KnownNotNull, ptr_void_t()) void_t(std::move(aOther));
mType = Tvoid_t;
}
MOZ_IMPLICIT OptionalPushData::OptionalPushData(const nsTArray<uint8_t>& aOther)
{
new (mozilla::KnownNotNull, ptr_ArrayOfuint8_t()) nsTArray<uint8_t>((aOther).Clone());
mType = TArrayOfuint8_t;
}
MOZ_IMPLICIT OptionalPushData::OptionalPushData(nsTArray<uint8_t>&& aOther)
{
new (mozilla::KnownNotNull, ptr_ArrayOfuint8_t()) nsTArray<uint8_t>(std::move(aOther));
mType = TArrayOfuint8_t;
}
MOZ_IMPLICIT OptionalPushData::OptionalPushData(const OptionalPushData& aOther)
{
(aOther).AssertSanity();
switch ((aOther).type()) {
case Tvoid_t:
{
new (mozilla::KnownNotNull, ptr_void_t()) void_t((aOther).get_void_t());
break;
}
case TArrayOfuint8_t:
{
new (mozilla::KnownNotNull, ptr_ArrayOfuint8_t()) nsTArray<uint8_t>(((aOther).get_ArrayOfuint8_t()).Clone());
break;
}
case T__None:
{
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
return;
}
}
mType = (aOther).type();
}
MOZ_IMPLICIT OptionalPushData::OptionalPushData(OptionalPushData&& aOther)
{
(aOther).AssertSanity();
Type t = (aOther).type();
switch (t) {
case Tvoid_t:
{
new (mozilla::KnownNotNull, ptr_void_t()) void_t(std::move((aOther).get_void_t()));
(aOther).MaybeDestroy();
break;
}
case TArrayOfuint8_t:
{
new (mozilla::KnownNotNull, ptr_ArrayOfuint8_t()) nsTArray<uint8_t>(std::move((aOther).get_ArrayOfuint8_t()));
(aOther).MaybeDestroy();
break;
}
case T__None:
{
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
return;
}
}
(aOther).mType = T__None;
mType = t;
}
OptionalPushData::~OptionalPushData()
{
MaybeDestroy();
}
auto OptionalPushData::operator=(const void_t& aRhs) -> OptionalPushData&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_void_t()) void_t(aRhs);
mType = Tvoid_t;
return (*(this));
}
auto OptionalPushData::operator=(void_t&& aRhs) -> OptionalPushData&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_void_t()) void_t(std::move(aRhs));
mType = Tvoid_t;
return (*(this));
}
auto OptionalPushData::operator=(const nsTArray<uint8_t>& aRhs) -> OptionalPushData&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_ArrayOfuint8_t()) nsTArray<uint8_t>((aRhs).Clone());
mType = TArrayOfuint8_t;
return (*(this));
}
auto OptionalPushData::operator=(nsTArray<uint8_t>&& aRhs) -> OptionalPushData&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_ArrayOfuint8_t()) nsTArray<uint8_t>(std::move(aRhs));
mType = TArrayOfuint8_t;
return (*(this));
}
auto OptionalPushData::operator=(const OptionalPushData& aRhs) -> OptionalPushData&
{
(aRhs).AssertSanity();
Type t = (aRhs).type();
switch (t) {
case Tvoid_t:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_void_t()) void_t((aRhs).get_void_t());
break;
}
case TArrayOfuint8_t:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_ArrayOfuint8_t()) nsTArray<uint8_t>(((aRhs).get_ArrayOfuint8_t()).Clone());
break;
}
case T__None:
{
MaybeDestroy();
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
break;
}
}
mType = t;
return (*(this));
}
auto OptionalPushData::operator=(OptionalPushData&& aRhs) -> OptionalPushData&
{
(aRhs).AssertSanity();
Type t = (aRhs).type();
switch (t) {
case Tvoid_t:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_void_t()) void_t(std::move((aRhs).get_void_t()));
(aRhs).MaybeDestroy();
break;
}
case TArrayOfuint8_t:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_ArrayOfuint8_t()) nsTArray<uint8_t>(std::move((aRhs).get_ArrayOfuint8_t()));
(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::OptionalPushData>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
typedef ::mozilla::dom::OptionalPushData union__;
int type = (aVar).type();
IPC::WriteParam(aWriter, type);
// Sentinel = 'OptionalPushData'
(aWriter)->WriteSentinel(917112417);
switch (type) {
case union__::Tvoid_t:
{
IPC::WriteParam(aWriter, (aVar).get_void_t());
// Sentinel = 'Tvoid_t'
(aWriter)->WriteSentinel(189006554);
return;
}
case union__::TArrayOfuint8_t:
{
IPC::WriteParam(aWriter, (aVar).get_ArrayOfuint8_t());
// Sentinel = 'TArrayOfuint8_t'
(aWriter)->WriteSentinel(771753428);
return;
}
default:
{
aWriter->FatalError("unknown variant of union OptionalPushData");
return;
}
}
}
auto ParamTraits<::mozilla::dom::OptionalPushData>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
typedef ::mozilla::dom::OptionalPushData union__;
auto maybe__type = IPC::ReadParam<int>(aReader);
if (!maybe__type) {
aReader->FatalError("Error deserializing type of union OptionalPushData");
return {};
}
auto& type = *maybe__type;
// Sentinel = 'OptionalPushData'
if ((!((aReader)->ReadSentinel(917112417)))) {
mozilla::ipc::SentinelReadError("Error deserializing type of union OptionalPushData");
return {};
}
switch (type) {
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 OptionalPushData");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'Tvoid_t'
if ((!((aReader)->ReadSentinel(189006554)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant Tvoid_t of union OptionalPushData");
return {};
}
return std::move(tmp);
}
case union__::TArrayOfuint8_t:
{
auto maybe__tmp = IPC::ReadParam<nsTArray<::uint8_t>>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TArrayOfuint8_t of union OptionalPushData");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TArrayOfuint8_t'
if ((!((aReader)->ReadSentinel(771753428)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TArrayOfuint8_t of union OptionalPushData");
return {};
}
return std::move(tmp);
}
default:
{
aReader->FatalError("unknown variant of union OptionalPushData");
return {};
}
}
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct ServiceWorkerPushEventOpArgs|
//
namespace mozilla {
namespace dom {
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::ServiceWorkerPushEventOpArgs>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).messageId());
// Sentinel = 'messageId'
(aWriter)->WriteSentinel(310576019);
IPC::WriteParam(aWriter, (aVar).data());
// Sentinel = 'data'
(aWriter)->WriteSentinel(67109275);
}
auto ParamTraits<::mozilla::dom::ServiceWorkerPushEventOpArgs>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___messageId = IPC::ReadParam<::nsString>(aReader);
if (!maybe___messageId) {
aReader->FatalError("Error deserializing 'messageId' (nsString) member of 'ServiceWorkerPushEventOpArgs'");
return {};
}
auto& _messageId = *maybe___messageId;
// Sentinel = 'messageId'
if ((!((aReader)->ReadSentinel(310576019)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'messageId' (nsString) member of 'ServiceWorkerPushEventOpArgs'");
return {};
}
auto maybe___data = IPC::ReadParam<::mozilla::dom::OptionalPushData>(aReader);
if (!maybe___data) {
aReader->FatalError("Error deserializing 'data' (OptionalPushData) member of 'ServiceWorkerPushEventOpArgs'");
return {};
}
auto& _data = *maybe___data;
// Sentinel = 'data'
if ((!((aReader)->ReadSentinel(67109275)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'data' (OptionalPushData) member of 'ServiceWorkerPushEventOpArgs'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_messageId),
std::move(_data)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct ServiceWorkerPushSubscriptionChangeEventOpArgs|
//
namespace mozilla {
namespace dom {
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::ServiceWorkerPushSubscriptionChangeEventOpArgs>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
}
auto ParamTraits<::mozilla::dom::ServiceWorkerPushSubscriptionChangeEventOpArgs>::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 ServiceWorkerNotificationEventOpArgs|
//
namespace mozilla {
namespace dom {
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::ServiceWorkerNotificationEventOpArgs>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).eventName());
// Sentinel = 'eventName'
(aWriter)->WriteSentinel(310051748);
IPC::WriteParam(aWriter, (aVar).id());
// Sentinel = 'id'
(aWriter)->WriteSentinel(20447438);
IPC::WriteParam(aWriter, (aVar).title());
// Sentinel = 'title'
(aWriter)->WriteSentinel(109445667);
IPC::WriteParam(aWriter, (aVar).dir());
// Sentinel = 'dir'
(aWriter)->WriteSentinel(41091392);
IPC::WriteParam(aWriter, (aVar).lang());
// Sentinel = 'lang'
(aWriter)->WriteSentinel(68813219);
IPC::WriteParam(aWriter, (aVar).body());
// Sentinel = 'body'
(aWriter)->WriteSentinel(68813231);
IPC::WriteParam(aWriter, (aVar).tag());
// Sentinel = 'tag'
(aWriter)->WriteSentinel(42467645);
IPC::WriteParam(aWriter, (aVar).icon());
// Sentinel = 'icon'
(aWriter)->WriteSentinel(69009834);
IPC::WriteParam(aWriter, (aVar).data());
// Sentinel = 'data'
(aWriter)->WriteSentinel(67109275);
IPC::WriteParam(aWriter, (aVar).behavior());
// Sentinel = 'behavior'
(aWriter)->WriteSentinel(244515665);
IPC::WriteParam(aWriter, (aVar).scope());
// Sentinel = 'scope'
(aWriter)->WriteSentinel(107086363);
(aWriter)->WriteBytes((&((aVar).disableOpenClickDelay())), 4);
// Sentinel = 'disableOpenClickDelay'
(aWriter)->WriteSentinel(1523386428);
}
auto ParamTraits<::mozilla::dom::ServiceWorkerNotificationEventOpArgs>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___eventName = IPC::ReadParam<::nsString>(aReader);
if (!maybe___eventName) {
aReader->FatalError("Error deserializing 'eventName' (nsString) member of 'ServiceWorkerNotificationEventOpArgs'");
return {};
}
auto& _eventName = *maybe___eventName;
// Sentinel = 'eventName'
if ((!((aReader)->ReadSentinel(310051748)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'eventName' (nsString) member of 'ServiceWorkerNotificationEventOpArgs'");
return {};
}
auto maybe___id = IPC::ReadParam<::nsString>(aReader);
if (!maybe___id) {
aReader->FatalError("Error deserializing 'id' (nsString) member of 'ServiceWorkerNotificationEventOpArgs'");
return {};
}
auto& _id = *maybe___id;
// Sentinel = 'id'
if ((!((aReader)->ReadSentinel(20447438)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'id' (nsString) member of 'ServiceWorkerNotificationEventOpArgs'");
return {};
}
auto maybe___title = IPC::ReadParam<::nsString>(aReader);
if (!maybe___title) {
aReader->FatalError("Error deserializing 'title' (nsString) member of 'ServiceWorkerNotificationEventOpArgs'");
return {};
}
auto& _title = *maybe___title;
// Sentinel = 'title'
if ((!((aReader)->ReadSentinel(109445667)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'title' (nsString) member of 'ServiceWorkerNotificationEventOpArgs'");
return {};
}
auto maybe___dir = IPC::ReadParam<::nsString>(aReader);
if (!maybe___dir) {
aReader->FatalError("Error deserializing 'dir' (nsString) member of 'ServiceWorkerNotificationEventOpArgs'");
return {};
}
auto& _dir = *maybe___dir;
// Sentinel = 'dir'
if ((!((aReader)->ReadSentinel(41091392)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'dir' (nsString) member of 'ServiceWorkerNotificationEventOpArgs'");
return {};
}
auto maybe___lang = IPC::ReadParam<::nsString>(aReader);
if (!maybe___lang) {
aReader->FatalError("Error deserializing 'lang' (nsString) member of 'ServiceWorkerNotificationEventOpArgs'");
return {};
}
auto& _lang = *maybe___lang;
// Sentinel = 'lang'
if ((!((aReader)->ReadSentinel(68813219)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'lang' (nsString) member of 'ServiceWorkerNotificationEventOpArgs'");
return {};
}
auto maybe___body = IPC::ReadParam<::nsString>(aReader);
if (!maybe___body) {
aReader->FatalError("Error deserializing 'body' (nsString) member of 'ServiceWorkerNotificationEventOpArgs'");
return {};
}
auto& _body = *maybe___body;
// Sentinel = 'body'
if ((!((aReader)->ReadSentinel(68813231)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'body' (nsString) member of 'ServiceWorkerNotificationEventOpArgs'");
return {};
}
auto maybe___tag = IPC::ReadParam<::nsString>(aReader);
if (!maybe___tag) {
aReader->FatalError("Error deserializing 'tag' (nsString) member of 'ServiceWorkerNotificationEventOpArgs'");
return {};
}
auto& _tag = *maybe___tag;
// Sentinel = 'tag'
if ((!((aReader)->ReadSentinel(42467645)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'tag' (nsString) member of 'ServiceWorkerNotificationEventOpArgs'");
return {};
}
auto maybe___icon = IPC::ReadParam<::nsString>(aReader);
if (!maybe___icon) {
aReader->FatalError("Error deserializing 'icon' (nsString) member of 'ServiceWorkerNotificationEventOpArgs'");
return {};
}
auto& _icon = *maybe___icon;
// Sentinel = 'icon'
if ((!((aReader)->ReadSentinel(69009834)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'icon' (nsString) member of 'ServiceWorkerNotificationEventOpArgs'");
return {};
}
auto maybe___data = IPC::ReadParam<::nsString>(aReader);
if (!maybe___data) {
aReader->FatalError("Error deserializing 'data' (nsString) member of 'ServiceWorkerNotificationEventOpArgs'");
return {};
}
auto& _data = *maybe___data;
// Sentinel = 'data'
if ((!((aReader)->ReadSentinel(67109275)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'data' (nsString) member of 'ServiceWorkerNotificationEventOpArgs'");
return {};
}
auto maybe___behavior = IPC::ReadParam<::nsString>(aReader);
if (!maybe___behavior) {
aReader->FatalError("Error deserializing 'behavior' (nsString) member of 'ServiceWorkerNotificationEventOpArgs'");
return {};
}
auto& _behavior = *maybe___behavior;
// Sentinel = 'behavior'
if ((!((aReader)->ReadSentinel(244515665)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'behavior' (nsString) member of 'ServiceWorkerNotificationEventOpArgs'");
return {};
}
auto maybe___scope = IPC::ReadParam<::nsString>(aReader);
if (!maybe___scope) {
aReader->FatalError("Error deserializing 'scope' (nsString) member of 'ServiceWorkerNotificationEventOpArgs'");
return {};
}
auto& _scope = *maybe___scope;
// Sentinel = 'scope'
if ((!((aReader)->ReadSentinel(107086363)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'scope' (nsString) member of 'ServiceWorkerNotificationEventOpArgs'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_eventName),
std::move(_id),
std::move(_title),
std::move(_dir),
std::move(_lang),
std::move(_body),
std::move(_tag),
std::move(_icon),
std::move(_data),
std::move(_behavior),
std::move(_scope),
::uint32_t{0}};
if ((!((aReader)->ReadBytesInto((&((result__)->disableOpenClickDelay())), 4)))) {
aReader->FatalError("Error bulk reading fields from uint32_t");
return {};
}
// Sentinel = 'disableOpenClickDelay'
if ((!((aReader)->ReadSentinel(1523386428)))) {
mozilla::ipc::SentinelReadError("Error bulk reading fields from uint32_t");
return {};
}
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct ServiceWorkerExtensionAPIEventOpArgs|
//
namespace mozilla {
namespace dom {
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::ServiceWorkerExtensionAPIEventOpArgs>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).apiNamespace());
// Sentinel = 'apiNamespace'
(aWriter)->WriteSentinel(518915272);
IPC::WriteParam(aWriter, (aVar).apiEventName());
// Sentinel = 'apiEventName'
(aWriter)->WriteSentinel(517211326);
}
auto ParamTraits<::mozilla::dom::ServiceWorkerExtensionAPIEventOpArgs>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___apiNamespace = IPC::ReadParam<::nsString>(aReader);
if (!maybe___apiNamespace) {
aReader->FatalError("Error deserializing 'apiNamespace' (nsString) member of 'ServiceWorkerExtensionAPIEventOpArgs'");
return {};
}
auto& _apiNamespace = *maybe___apiNamespace;
// Sentinel = 'apiNamespace'
if ((!((aReader)->ReadSentinel(518915272)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'apiNamespace' (nsString) member of 'ServiceWorkerExtensionAPIEventOpArgs'");
return {};
}
auto maybe___apiEventName = IPC::ReadParam<::nsString>(aReader);
if (!maybe___apiEventName) {
aReader->FatalError("Error deserializing 'apiEventName' (nsString) member of 'ServiceWorkerExtensionAPIEventOpArgs'");
return {};
}
auto& _apiEventName = *maybe___apiEventName;
// Sentinel = 'apiEventName'
if ((!((aReader)->ReadSentinel(517211326)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'apiEventName' (nsString) member of 'ServiceWorkerExtensionAPIEventOpArgs'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_apiNamespace),
std::move(_apiEventName)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct ServiceWorkerMessageEventOpArgs|
//
namespace mozilla {
namespace dom {
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::ServiceWorkerMessageEventOpArgs>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).source());
// Sentinel = 'source'
(aWriter)->WriteSentinel(154665618);
IPC::WriteParam(aWriter, (aVar).clonedData());
// Sentinel = 'clonedData'
(aWriter)->WriteSentinel(368837616);
}
auto ParamTraits<::mozilla::dom::ServiceWorkerMessageEventOpArgs>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___source = IPC::ReadParam<::mozilla::dom::PostMessageSource>(aReader);
if (!maybe___source) {
aReader->FatalError("Error deserializing 'source' (PostMessageSource) member of 'ServiceWorkerMessageEventOpArgs'");
return {};
}
auto& _source = *maybe___source;
// Sentinel = 'source'
if ((!((aReader)->ReadSentinel(154665618)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'source' (PostMessageSource) member of 'ServiceWorkerMessageEventOpArgs'");
return {};
}
auto maybe___clonedData = IPC::ReadParam<::mozilla::dom::ClonedOrErrorMessageData>(aReader);
if (!maybe___clonedData) {
aReader->FatalError("Error deserializing 'clonedData' (ClonedOrErrorMessageData) member of 'ServiceWorkerMessageEventOpArgs'");
return {};
}
auto& _clonedData = *maybe___clonedData;
// Sentinel = 'clonedData'
if ((!((aReader)->ReadSentinel(368837616)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'clonedData' (ClonedOrErrorMessageData) member of 'ServiceWorkerMessageEventOpArgs'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_source),
std::move(_clonedData)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct ServiceWorkerFetchEventOpArgsCommon|
//
namespace mozilla {
namespace dom {
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::ServiceWorkerFetchEventOpArgsCommon>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).workerScriptSpec());
// Sentinel = 'workerScriptSpec'
(aWriter)->WriteSentinel(958596763);
IPC::WriteParam(aWriter, (aVar).internalRequest());
// Sentinel = 'internalRequest'
(aWriter)->WriteSentinel(839059015);
IPC::WriteParam(aWriter, (aVar).clientId());
// Sentinel = 'clientId'
(aWriter)->WriteSentinel(244122413);
IPC::WriteParam(aWriter, (aVar).resultingClientId());
// Sentinel = 'resultingClientId'
(aWriter)->WriteSentinel(1073022698);
IPC::WriteParam(aWriter, (aVar).isNonSubresourceRequest());
// Sentinel = 'isNonSubresourceRequest'
(aWriter)->WriteSentinel(1894386051);
IPC::WriteParam(aWriter, (aVar).preloadNavigation());
// Sentinel = 'preloadNavigation'
(aWriter)->WriteSentinel(1050216184);
IPC::WriteParam(aWriter, (aVar).testingInjectCancellation());
// Sentinel = 'testingInjectCancellation'
(aWriter)->WriteSentinel(2219510313);
}
auto ParamTraits<::mozilla::dom::ServiceWorkerFetchEventOpArgsCommon>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___workerScriptSpec = IPC::ReadParam<::nsCString>(aReader);
if (!maybe___workerScriptSpec) {
aReader->FatalError("Error deserializing 'workerScriptSpec' (nsCString) member of 'ServiceWorkerFetchEventOpArgsCommon'");
return {};
}
auto& _workerScriptSpec = *maybe___workerScriptSpec;
// Sentinel = 'workerScriptSpec'
if ((!((aReader)->ReadSentinel(958596763)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'workerScriptSpec' (nsCString) member of 'ServiceWorkerFetchEventOpArgsCommon'");
return {};
}
auto maybe___internalRequest = IPC::ReadParam<::mozilla::dom::IPCInternalRequest>(aReader);
if (!maybe___internalRequest) {
aReader->FatalError("Error deserializing 'internalRequest' (IPCInternalRequest) member of 'ServiceWorkerFetchEventOpArgsCommon'");
return {};
}
auto& _internalRequest = *maybe___internalRequest;
// Sentinel = 'internalRequest'
if ((!((aReader)->ReadSentinel(839059015)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'internalRequest' (IPCInternalRequest) member of 'ServiceWorkerFetchEventOpArgsCommon'");
return {};
}
auto maybe___clientId = IPC::ReadParam<::nsString>(aReader);
if (!maybe___clientId) {
aReader->FatalError("Error deserializing 'clientId' (nsString) member of 'ServiceWorkerFetchEventOpArgsCommon'");
return {};
}
auto& _clientId = *maybe___clientId;
// Sentinel = 'clientId'
if ((!((aReader)->ReadSentinel(244122413)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'clientId' (nsString) member of 'ServiceWorkerFetchEventOpArgsCommon'");
return {};
}
auto maybe___resultingClientId = IPC::ReadParam<::nsString>(aReader);
if (!maybe___resultingClientId) {
aReader->FatalError("Error deserializing 'resultingClientId' (nsString) member of 'ServiceWorkerFetchEventOpArgsCommon'");
return {};
}
auto& _resultingClientId = *maybe___resultingClientId;
// Sentinel = 'resultingClientId'
if ((!((aReader)->ReadSentinel(1073022698)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'resultingClientId' (nsString) member of 'ServiceWorkerFetchEventOpArgsCommon'");
return {};
}
auto maybe___isNonSubresourceRequest = IPC::ReadParam<bool>(aReader);
if (!maybe___isNonSubresourceRequest) {
aReader->FatalError("Error deserializing 'isNonSubresourceRequest' (bool) member of 'ServiceWorkerFetchEventOpArgsCommon'");
return {};
}
auto& _isNonSubresourceRequest = *maybe___isNonSubresourceRequest;
// Sentinel = 'isNonSubresourceRequest'
if ((!((aReader)->ReadSentinel(1894386051)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'isNonSubresourceRequest' (bool) member of 'ServiceWorkerFetchEventOpArgsCommon'");
return {};
}
auto maybe___preloadNavigation = IPC::ReadParam<bool>(aReader);
if (!maybe___preloadNavigation) {
aReader->FatalError("Error deserializing 'preloadNavigation' (bool) member of 'ServiceWorkerFetchEventOpArgsCommon'");
return {};
}
auto& _preloadNavigation = *maybe___preloadNavigation;
// Sentinel = 'preloadNavigation'
if ((!((aReader)->ReadSentinel(1050216184)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'preloadNavigation' (bool) member of 'ServiceWorkerFetchEventOpArgsCommon'");
return {};
}
auto maybe___testingInjectCancellation = IPC::ReadParam<::nsresult>(aReader);
if (!maybe___testingInjectCancellation) {
aReader->FatalError("Error deserializing 'testingInjectCancellation' (nsresult) member of 'ServiceWorkerFetchEventOpArgsCommon'");
return {};
}
auto& _testingInjectCancellation = *maybe___testingInjectCancellation;
// Sentinel = 'testingInjectCancellation'
if ((!((aReader)->ReadSentinel(2219510313)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'testingInjectCancellation' (nsresult) member of 'ServiceWorkerFetchEventOpArgsCommon'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_workerScriptSpec),
std::move(_internalRequest),
std::move(_clientId),
std::move(_resultingClientId),
std::move(_isNonSubresourceRequest),
std::move(_preloadNavigation),
std::move(_testingInjectCancellation)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct ParentToParentServiceWorkerFetchEventOpArgs|
//
namespace mozilla {
namespace dom {
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::ParentToParentServiceWorkerFetchEventOpArgs>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).common());
// Sentinel = 'common'
(aWriter)->WriteSentinel(147456650);
IPC::WriteParam(aWriter, (aVar).preloadResponse());
// Sentinel = 'preloadResponse'
(aWriter)->WriteSentinel(832898615);
IPC::WriteParam(aWriter, (aVar).preloadResponseTiming());
// Sentinel = 'preloadResponseTiming'
(aWriter)->WriteSentinel(1596328095);
IPC::WriteParam(aWriter, (aVar).preloadResponseEndArgs());
// Sentinel = 'preloadResponseEndArgs'
(aWriter)->WriteSentinel(1730939099);
}
auto ParamTraits<::mozilla::dom::ParentToParentServiceWorkerFetchEventOpArgs>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___common = IPC::ReadParam<::mozilla::dom::ServiceWorkerFetchEventOpArgsCommon>(aReader);
if (!maybe___common) {
aReader->FatalError("Error deserializing 'common' (ServiceWorkerFetchEventOpArgsCommon) member of 'ParentToParentServiceWorkerFetchEventOpArgs'");
return {};
}
auto& _common = *maybe___common;
// Sentinel = 'common'
if ((!((aReader)->ReadSentinel(147456650)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'common' (ServiceWorkerFetchEventOpArgsCommon) member of 'ParentToParentServiceWorkerFetchEventOpArgs'");
return {};
}
auto maybe___preloadResponse = IPC::ReadParam<mozilla::Maybe<::mozilla::dom::ParentToParentInternalResponse>>(aReader);
if (!maybe___preloadResponse) {
aReader->FatalError("Error deserializing 'preloadResponse' (ParentToParentInternalResponse?) member of 'ParentToParentServiceWorkerFetchEventOpArgs'");
return {};
}
auto& _preloadResponse = *maybe___preloadResponse;
// Sentinel = 'preloadResponse'
if ((!((aReader)->ReadSentinel(832898615)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'preloadResponse' (ParentToParentInternalResponse?) member of 'ParentToParentServiceWorkerFetchEventOpArgs'");
return {};
}
auto maybe___preloadResponseTiming = IPC::ReadParam<mozilla::Maybe<::mozilla::dom::ResponseTiming>>(aReader);
if (!maybe___preloadResponseTiming) {
aReader->FatalError("Error deserializing 'preloadResponseTiming' (ResponseTiming?) member of 'ParentToParentServiceWorkerFetchEventOpArgs'");
return {};
}
auto& _preloadResponseTiming = *maybe___preloadResponseTiming;
// Sentinel = 'preloadResponseTiming'
if ((!((aReader)->ReadSentinel(1596328095)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'preloadResponseTiming' (ResponseTiming?) member of 'ParentToParentServiceWorkerFetchEventOpArgs'");
return {};
}
auto maybe___preloadResponseEndArgs = IPC::ReadParam<mozilla::Maybe<::mozilla::dom::ResponseEndArgs>>(aReader);
if (!maybe___preloadResponseEndArgs) {
aReader->FatalError("Error deserializing 'preloadResponseEndArgs' (ResponseEndArgs?) member of 'ParentToParentServiceWorkerFetchEventOpArgs'");
return {};
}
auto& _preloadResponseEndArgs = *maybe___preloadResponseEndArgs;
// Sentinel = 'preloadResponseEndArgs'
if ((!((aReader)->ReadSentinel(1730939099)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'preloadResponseEndArgs' (ResponseEndArgs?) member of 'ParentToParentServiceWorkerFetchEventOpArgs'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_common),
std::move(_preloadResponse),
std::move(_preloadResponseTiming),
std::move(_preloadResponseEndArgs)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct ParentToChildServiceWorkerFetchEventOpArgs|
//
namespace mozilla {
namespace dom {
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::ParentToChildServiceWorkerFetchEventOpArgs>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).common());
// Sentinel = 'common'
(aWriter)->WriteSentinel(147456650);
IPC::WriteParam(aWriter, (aVar).preloadResponse());
// Sentinel = 'preloadResponse'
(aWriter)->WriteSentinel(832898615);
IPC::WriteParam(aWriter, (aVar).preloadResponseTiming());
// Sentinel = 'preloadResponseTiming'
(aWriter)->WriteSentinel(1596328095);
IPC::WriteParam(aWriter, (aVar).preloadResponseEndArgs());
// Sentinel = 'preloadResponseEndArgs'
(aWriter)->WriteSentinel(1730939099);
}
auto ParamTraits<::mozilla::dom::ParentToChildServiceWorkerFetchEventOpArgs>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___common = IPC::ReadParam<::mozilla::dom::ServiceWorkerFetchEventOpArgsCommon>(aReader);
if (!maybe___common) {
aReader->FatalError("Error deserializing 'common' (ServiceWorkerFetchEventOpArgsCommon) member of 'ParentToChildServiceWorkerFetchEventOpArgs'");
return {};
}
auto& _common = *maybe___common;
// Sentinel = 'common'
if ((!((aReader)->ReadSentinel(147456650)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'common' (ServiceWorkerFetchEventOpArgsCommon) member of 'ParentToChildServiceWorkerFetchEventOpArgs'");
return {};
}
auto maybe___preloadResponse = IPC::ReadParam<mozilla::Maybe<::mozilla::dom::ParentToChildInternalResponse>>(aReader);
if (!maybe___preloadResponse) {
aReader->FatalError("Error deserializing 'preloadResponse' (ParentToChildInternalResponse?) member of 'ParentToChildServiceWorkerFetchEventOpArgs'");
return {};
}
auto& _preloadResponse = *maybe___preloadResponse;
// Sentinel = 'preloadResponse'
if ((!((aReader)->ReadSentinel(832898615)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'preloadResponse' (ParentToChildInternalResponse?) member of 'ParentToChildServiceWorkerFetchEventOpArgs'");
return {};
}
auto maybe___preloadResponseTiming = IPC::ReadParam<mozilla::Maybe<::mozilla::dom::ResponseTiming>>(aReader);
if (!maybe___preloadResponseTiming) {
aReader->FatalError("Error deserializing 'preloadResponseTiming' (ResponseTiming?) member of 'ParentToChildServiceWorkerFetchEventOpArgs'");
return {};
}
auto& _preloadResponseTiming = *maybe___preloadResponseTiming;
// Sentinel = 'preloadResponseTiming'
if ((!((aReader)->ReadSentinel(1596328095)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'preloadResponseTiming' (ResponseTiming?) member of 'ParentToChildServiceWorkerFetchEventOpArgs'");
return {};
}
auto maybe___preloadResponseEndArgs = IPC::ReadParam<mozilla::Maybe<::mozilla::dom::ResponseEndArgs>>(aReader);
if (!maybe___preloadResponseEndArgs) {
aReader->FatalError("Error deserializing 'preloadResponseEndArgs' (ResponseEndArgs?) member of 'ParentToChildServiceWorkerFetchEventOpArgs'");
return {};
}
auto& _preloadResponseEndArgs = *maybe___preloadResponseEndArgs;
// Sentinel = 'preloadResponseEndArgs'
if ((!((aReader)->ReadSentinel(1730939099)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'preloadResponseEndArgs' (ResponseEndArgs?) member of 'ParentToChildServiceWorkerFetchEventOpArgs'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_common),
std::move(_preloadResponse),
std::move(_preloadResponseTiming),
std::move(_preloadResponseEndArgs)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |union ServiceWorkerOpArgs|
//
namespace mozilla {
namespace dom {
auto ServiceWorkerOpArgs::MaybeDestroy() -> void
{
if ((mType) == (T__None)) {
return;
}
switch (mType) {
case TServiceWorkerCheckScriptEvaluationOpArgs:
{
(ptr_ServiceWorkerCheckScriptEvaluationOpArgs())->~ServiceWorkerCheckScriptEvaluationOpArgs__tdef();
break;
}
case TServiceWorkerUpdateStateOpArgs:
{
(ptr_ServiceWorkerUpdateStateOpArgs())->~ServiceWorkerUpdateStateOpArgs__tdef();
break;
}
case TServiceWorkerTerminateWorkerOpArgs:
{
(ptr_ServiceWorkerTerminateWorkerOpArgs())->~ServiceWorkerTerminateWorkerOpArgs__tdef();
break;
}
case TServiceWorkerLifeCycleEventOpArgs:
{
(ptr_ServiceWorkerLifeCycleEventOpArgs())->~ServiceWorkerLifeCycleEventOpArgs__tdef();
break;
}
case TServiceWorkerPushEventOpArgs:
{
(ptr_ServiceWorkerPushEventOpArgs())->~ServiceWorkerPushEventOpArgs__tdef();
break;
}
case TServiceWorkerPushSubscriptionChangeEventOpArgs:
{
(ptr_ServiceWorkerPushSubscriptionChangeEventOpArgs())->~ServiceWorkerPushSubscriptionChangeEventOpArgs__tdef();
break;
}
case TServiceWorkerNotificationEventOpArgs:
{
(ptr_ServiceWorkerNotificationEventOpArgs())->~ServiceWorkerNotificationEventOpArgs__tdef();
break;
}
case TServiceWorkerMessageEventOpArgs:
{
(ptr_ServiceWorkerMessageEventOpArgs())->~ServiceWorkerMessageEventOpArgs__tdef();
break;
}
case TServiceWorkerExtensionAPIEventOpArgs:
{
(ptr_ServiceWorkerExtensionAPIEventOpArgs())->~ServiceWorkerExtensionAPIEventOpArgs__tdef();
break;
}
case TParentToChildServiceWorkerFetchEventOpArgs:
{
(ptr_ParentToChildServiceWorkerFetchEventOpArgs())->~ParentToChildServiceWorkerFetchEventOpArgs__tdef();
break;
}
default:
{
mozilla::ipc::LogicError("not reached");
break;
}
}
}
MOZ_IMPLICIT ServiceWorkerOpArgs::ServiceWorkerOpArgs(const ServiceWorkerCheckScriptEvaluationOpArgs& aOther)
{
new (mozilla::KnownNotNull, ptr_ServiceWorkerCheckScriptEvaluationOpArgs()) ServiceWorkerCheckScriptEvaluationOpArgs(aOther);
mType = TServiceWorkerCheckScriptEvaluationOpArgs;
}
MOZ_IMPLICIT ServiceWorkerOpArgs::ServiceWorkerOpArgs(ServiceWorkerCheckScriptEvaluationOpArgs&& aOther)
{
new (mozilla::KnownNotNull, ptr_ServiceWorkerCheckScriptEvaluationOpArgs()) ServiceWorkerCheckScriptEvaluationOpArgs(std::move(aOther));
mType = TServiceWorkerCheckScriptEvaluationOpArgs;
}
MOZ_IMPLICIT ServiceWorkerOpArgs::ServiceWorkerOpArgs(const ServiceWorkerUpdateStateOpArgs& aOther)
{
new (mozilla::KnownNotNull, ptr_ServiceWorkerUpdateStateOpArgs()) ServiceWorkerUpdateStateOpArgs(aOther);
mType = TServiceWorkerUpdateStateOpArgs;
}
MOZ_IMPLICIT ServiceWorkerOpArgs::ServiceWorkerOpArgs(ServiceWorkerUpdateStateOpArgs&& aOther)
{
new (mozilla::KnownNotNull, ptr_ServiceWorkerUpdateStateOpArgs()) ServiceWorkerUpdateStateOpArgs(std::move(aOther));
mType = TServiceWorkerUpdateStateOpArgs;
}
MOZ_IMPLICIT ServiceWorkerOpArgs::ServiceWorkerOpArgs(const ServiceWorkerTerminateWorkerOpArgs& aOther)
{
new (mozilla::KnownNotNull, ptr_ServiceWorkerTerminateWorkerOpArgs()) ServiceWorkerTerminateWorkerOpArgs(aOther);
mType = TServiceWorkerTerminateWorkerOpArgs;
}
MOZ_IMPLICIT ServiceWorkerOpArgs::ServiceWorkerOpArgs(ServiceWorkerTerminateWorkerOpArgs&& aOther)
{
new (mozilla::KnownNotNull, ptr_ServiceWorkerTerminateWorkerOpArgs()) ServiceWorkerTerminateWorkerOpArgs(std::move(aOther));
mType = TServiceWorkerTerminateWorkerOpArgs;
}
MOZ_IMPLICIT ServiceWorkerOpArgs::ServiceWorkerOpArgs(const ServiceWorkerLifeCycleEventOpArgs& aOther)
{
new (mozilla::KnownNotNull, ptr_ServiceWorkerLifeCycleEventOpArgs()) ServiceWorkerLifeCycleEventOpArgs(aOther);
mType = TServiceWorkerLifeCycleEventOpArgs;
}
MOZ_IMPLICIT ServiceWorkerOpArgs::ServiceWorkerOpArgs(ServiceWorkerLifeCycleEventOpArgs&& aOther)
{
new (mozilla::KnownNotNull, ptr_ServiceWorkerLifeCycleEventOpArgs()) ServiceWorkerLifeCycleEventOpArgs(std::move(aOther));
mType = TServiceWorkerLifeCycleEventOpArgs;
}
MOZ_IMPLICIT ServiceWorkerOpArgs::ServiceWorkerOpArgs(const ServiceWorkerPushEventOpArgs& aOther)
{
new (mozilla::KnownNotNull, ptr_ServiceWorkerPushEventOpArgs()) ServiceWorkerPushEventOpArgs(aOther);
mType = TServiceWorkerPushEventOpArgs;
}
MOZ_IMPLICIT ServiceWorkerOpArgs::ServiceWorkerOpArgs(ServiceWorkerPushEventOpArgs&& aOther)
{
new (mozilla::KnownNotNull, ptr_ServiceWorkerPushEventOpArgs()) ServiceWorkerPushEventOpArgs(std::move(aOther));
mType = TServiceWorkerPushEventOpArgs;
}
MOZ_IMPLICIT ServiceWorkerOpArgs::ServiceWorkerOpArgs(const ServiceWorkerPushSubscriptionChangeEventOpArgs& aOther)
{
new (mozilla::KnownNotNull, ptr_ServiceWorkerPushSubscriptionChangeEventOpArgs()) ServiceWorkerPushSubscriptionChangeEventOpArgs(aOther);
mType = TServiceWorkerPushSubscriptionChangeEventOpArgs;
}
MOZ_IMPLICIT ServiceWorkerOpArgs::ServiceWorkerOpArgs(ServiceWorkerPushSubscriptionChangeEventOpArgs&& aOther)
{
new (mozilla::KnownNotNull, ptr_ServiceWorkerPushSubscriptionChangeEventOpArgs()) ServiceWorkerPushSubscriptionChangeEventOpArgs(std::move(aOther));
mType = TServiceWorkerPushSubscriptionChangeEventOpArgs;
}
MOZ_IMPLICIT ServiceWorkerOpArgs::ServiceWorkerOpArgs(const ServiceWorkerNotificationEventOpArgs& aOther)
{
new (mozilla::KnownNotNull, ptr_ServiceWorkerNotificationEventOpArgs()) ServiceWorkerNotificationEventOpArgs(aOther);
mType = TServiceWorkerNotificationEventOpArgs;
}
MOZ_IMPLICIT ServiceWorkerOpArgs::ServiceWorkerOpArgs(ServiceWorkerNotificationEventOpArgs&& aOther)
{
new (mozilla::KnownNotNull, ptr_ServiceWorkerNotificationEventOpArgs()) ServiceWorkerNotificationEventOpArgs(std::move(aOther));
mType = TServiceWorkerNotificationEventOpArgs;
}
MOZ_IMPLICIT ServiceWorkerOpArgs::ServiceWorkerOpArgs(ServiceWorkerMessageEventOpArgs&& aOther)
{
new (mozilla::KnownNotNull, ptr_ServiceWorkerMessageEventOpArgs()) ServiceWorkerMessageEventOpArgs(std::move(aOther));
mType = TServiceWorkerMessageEventOpArgs;
}
MOZ_IMPLICIT ServiceWorkerOpArgs::ServiceWorkerOpArgs(const ServiceWorkerExtensionAPIEventOpArgs& aOther)
{
new (mozilla::KnownNotNull, ptr_ServiceWorkerExtensionAPIEventOpArgs()) ServiceWorkerExtensionAPIEventOpArgs(aOther);
mType = TServiceWorkerExtensionAPIEventOpArgs;
}
MOZ_IMPLICIT ServiceWorkerOpArgs::ServiceWorkerOpArgs(ServiceWorkerExtensionAPIEventOpArgs&& aOther)
{
new (mozilla::KnownNotNull, ptr_ServiceWorkerExtensionAPIEventOpArgs()) ServiceWorkerExtensionAPIEventOpArgs(std::move(aOther));
mType = TServiceWorkerExtensionAPIEventOpArgs;
}
MOZ_IMPLICIT ServiceWorkerOpArgs::ServiceWorkerOpArgs(const ParentToChildServiceWorkerFetchEventOpArgs& aOther)
{
new (mozilla::KnownNotNull, ptr_ParentToChildServiceWorkerFetchEventOpArgs()) ParentToChildServiceWorkerFetchEventOpArgs(aOther);
mType = TParentToChildServiceWorkerFetchEventOpArgs;
}
MOZ_IMPLICIT ServiceWorkerOpArgs::ServiceWorkerOpArgs(ParentToChildServiceWorkerFetchEventOpArgs&& aOther)
{
new (mozilla::KnownNotNull, ptr_ParentToChildServiceWorkerFetchEventOpArgs()) ParentToChildServiceWorkerFetchEventOpArgs(std::move(aOther));
mType = TParentToChildServiceWorkerFetchEventOpArgs;
}
MOZ_IMPLICIT ServiceWorkerOpArgs::ServiceWorkerOpArgs(ServiceWorkerOpArgs&& aOther)
{
(aOther).AssertSanity();
Type t = (aOther).type();
switch (t) {
case TServiceWorkerCheckScriptEvaluationOpArgs:
{
new (mozilla::KnownNotNull, ptr_ServiceWorkerCheckScriptEvaluationOpArgs()) ServiceWorkerCheckScriptEvaluationOpArgs(std::move((aOther).get_ServiceWorkerCheckScriptEvaluationOpArgs()));
(aOther).MaybeDestroy();
break;
}
case TServiceWorkerUpdateStateOpArgs:
{
new (mozilla::KnownNotNull, ptr_ServiceWorkerUpdateStateOpArgs()) ServiceWorkerUpdateStateOpArgs(std::move((aOther).get_ServiceWorkerUpdateStateOpArgs()));
(aOther).MaybeDestroy();
break;
}
case TServiceWorkerTerminateWorkerOpArgs:
{
new (mozilla::KnownNotNull, ptr_ServiceWorkerTerminateWorkerOpArgs()) ServiceWorkerTerminateWorkerOpArgs(std::move((aOther).get_ServiceWorkerTerminateWorkerOpArgs()));
(aOther).MaybeDestroy();
break;
}
case TServiceWorkerLifeCycleEventOpArgs:
{
new (mozilla::KnownNotNull, ptr_ServiceWorkerLifeCycleEventOpArgs()) ServiceWorkerLifeCycleEventOpArgs(std::move((aOther).get_ServiceWorkerLifeCycleEventOpArgs()));
(aOther).MaybeDestroy();
break;
}
case TServiceWorkerPushEventOpArgs:
{
new (mozilla::KnownNotNull, ptr_ServiceWorkerPushEventOpArgs()) ServiceWorkerPushEventOpArgs(std::move((aOther).get_ServiceWorkerPushEventOpArgs()));
(aOther).MaybeDestroy();
break;
}
case TServiceWorkerPushSubscriptionChangeEventOpArgs:
{
new (mozilla::KnownNotNull, ptr_ServiceWorkerPushSubscriptionChangeEventOpArgs()) ServiceWorkerPushSubscriptionChangeEventOpArgs(std::move((aOther).get_ServiceWorkerPushSubscriptionChangeEventOpArgs()));
(aOther).MaybeDestroy();
break;
}
case TServiceWorkerNotificationEventOpArgs:
{
new (mozilla::KnownNotNull, ptr_ServiceWorkerNotificationEventOpArgs()) ServiceWorkerNotificationEventOpArgs(std::move((aOther).get_ServiceWorkerNotificationEventOpArgs()));
(aOther).MaybeDestroy();
break;
}
case TServiceWorkerMessageEventOpArgs:
{
new (mozilla::KnownNotNull, ptr_ServiceWorkerMessageEventOpArgs()) ServiceWorkerMessageEventOpArgs(std::move((aOther).get_ServiceWorkerMessageEventOpArgs()));
(aOther).MaybeDestroy();
break;
}
case TServiceWorkerExtensionAPIEventOpArgs:
{
new (mozilla::KnownNotNull, ptr_ServiceWorkerExtensionAPIEventOpArgs()) ServiceWorkerExtensionAPIEventOpArgs(std::move((aOther).get_ServiceWorkerExtensionAPIEventOpArgs()));
(aOther).MaybeDestroy();
break;
}
case TParentToChildServiceWorkerFetchEventOpArgs:
{
new (mozilla::KnownNotNull, ptr_ParentToChildServiceWorkerFetchEventOpArgs()) ParentToChildServiceWorkerFetchEventOpArgs(std::move((aOther).get_ParentToChildServiceWorkerFetchEventOpArgs()));
(aOther).MaybeDestroy();
break;
}
case T__None:
{
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
return;
}
}
(aOther).mType = T__None;
mType = t;
}
ServiceWorkerOpArgs::~ServiceWorkerOpArgs()
{
MaybeDestroy();
}
auto ServiceWorkerOpArgs::operator=(const ServiceWorkerCheckScriptEvaluationOpArgs& aRhs) -> ServiceWorkerOpArgs&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_ServiceWorkerCheckScriptEvaluationOpArgs()) ServiceWorkerCheckScriptEvaluationOpArgs(aRhs);
mType = TServiceWorkerCheckScriptEvaluationOpArgs;
return (*(this));
}
auto ServiceWorkerOpArgs::operator=(ServiceWorkerCheckScriptEvaluationOpArgs&& aRhs) -> ServiceWorkerOpArgs&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_ServiceWorkerCheckScriptEvaluationOpArgs()) ServiceWorkerCheckScriptEvaluationOpArgs(std::move(aRhs));
mType = TServiceWorkerCheckScriptEvaluationOpArgs;
return (*(this));
}
auto ServiceWorkerOpArgs::operator=(const ServiceWorkerUpdateStateOpArgs& aRhs) -> ServiceWorkerOpArgs&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_ServiceWorkerUpdateStateOpArgs()) ServiceWorkerUpdateStateOpArgs(aRhs);
mType = TServiceWorkerUpdateStateOpArgs;
return (*(this));
}
auto ServiceWorkerOpArgs::operator=(ServiceWorkerUpdateStateOpArgs&& aRhs) -> ServiceWorkerOpArgs&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_ServiceWorkerUpdateStateOpArgs()) ServiceWorkerUpdateStateOpArgs(std::move(aRhs));
mType = TServiceWorkerUpdateStateOpArgs;
return (*(this));
}
auto ServiceWorkerOpArgs::operator=(const ServiceWorkerTerminateWorkerOpArgs& aRhs) -> ServiceWorkerOpArgs&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_ServiceWorkerTerminateWorkerOpArgs()) ServiceWorkerTerminateWorkerOpArgs(aRhs);
mType = TServiceWorkerTerminateWorkerOpArgs;
return (*(this));
}
auto ServiceWorkerOpArgs::operator=(ServiceWorkerTerminateWorkerOpArgs&& aRhs) -> ServiceWorkerOpArgs&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_ServiceWorkerTerminateWorkerOpArgs()) ServiceWorkerTerminateWorkerOpArgs(std::move(aRhs));
mType = TServiceWorkerTerminateWorkerOpArgs;
return (*(this));
}
auto ServiceWorkerOpArgs::operator=(const ServiceWorkerLifeCycleEventOpArgs& aRhs) -> ServiceWorkerOpArgs&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_ServiceWorkerLifeCycleEventOpArgs()) ServiceWorkerLifeCycleEventOpArgs(aRhs);
mType = TServiceWorkerLifeCycleEventOpArgs;
return (*(this));
}
auto ServiceWorkerOpArgs::operator=(ServiceWorkerLifeCycleEventOpArgs&& aRhs) -> ServiceWorkerOpArgs&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_ServiceWorkerLifeCycleEventOpArgs()) ServiceWorkerLifeCycleEventOpArgs(std::move(aRhs));
mType = TServiceWorkerLifeCycleEventOpArgs;
return (*(this));
}
auto ServiceWorkerOpArgs::operator=(const ServiceWorkerPushEventOpArgs& aRhs) -> ServiceWorkerOpArgs&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_ServiceWorkerPushEventOpArgs()) ServiceWorkerPushEventOpArgs(aRhs);
mType = TServiceWorkerPushEventOpArgs;
return (*(this));
}
auto ServiceWorkerOpArgs::operator=(ServiceWorkerPushEventOpArgs&& aRhs) -> ServiceWorkerOpArgs&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_ServiceWorkerPushEventOpArgs()) ServiceWorkerPushEventOpArgs(std::move(aRhs));
mType = TServiceWorkerPushEventOpArgs;
return (*(this));
}
auto ServiceWorkerOpArgs::operator=(const ServiceWorkerPushSubscriptionChangeEventOpArgs& aRhs) -> ServiceWorkerOpArgs&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_ServiceWorkerPushSubscriptionChangeEventOpArgs()) ServiceWorkerPushSubscriptionChangeEventOpArgs(aRhs);
mType = TServiceWorkerPushSubscriptionChangeEventOpArgs;
return (*(this));
}
auto ServiceWorkerOpArgs::operator=(ServiceWorkerPushSubscriptionChangeEventOpArgs&& aRhs) -> ServiceWorkerOpArgs&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_ServiceWorkerPushSubscriptionChangeEventOpArgs()) ServiceWorkerPushSubscriptionChangeEventOpArgs(std::move(aRhs));
mType = TServiceWorkerPushSubscriptionChangeEventOpArgs;
return (*(this));
}
auto ServiceWorkerOpArgs::operator=(const ServiceWorkerNotificationEventOpArgs& aRhs) -> ServiceWorkerOpArgs&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_ServiceWorkerNotificationEventOpArgs()) ServiceWorkerNotificationEventOpArgs(aRhs);
mType = TServiceWorkerNotificationEventOpArgs;
return (*(this));
}
auto ServiceWorkerOpArgs::operator=(ServiceWorkerNotificationEventOpArgs&& aRhs) -> ServiceWorkerOpArgs&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_ServiceWorkerNotificationEventOpArgs()) ServiceWorkerNotificationEventOpArgs(std::move(aRhs));
mType = TServiceWorkerNotificationEventOpArgs;
return (*(this));
}
auto ServiceWorkerOpArgs::operator=(ServiceWorkerMessageEventOpArgs&& aRhs) -> ServiceWorkerOpArgs&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_ServiceWorkerMessageEventOpArgs()) ServiceWorkerMessageEventOpArgs(std::move(aRhs));
mType = TServiceWorkerMessageEventOpArgs;
return (*(this));
}
auto ServiceWorkerOpArgs::operator=(const ServiceWorkerExtensionAPIEventOpArgs& aRhs) -> ServiceWorkerOpArgs&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_ServiceWorkerExtensionAPIEventOpArgs()) ServiceWorkerExtensionAPIEventOpArgs(aRhs);
mType = TServiceWorkerExtensionAPIEventOpArgs;
return (*(this));
}
auto ServiceWorkerOpArgs::operator=(ServiceWorkerExtensionAPIEventOpArgs&& aRhs) -> ServiceWorkerOpArgs&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_ServiceWorkerExtensionAPIEventOpArgs()) ServiceWorkerExtensionAPIEventOpArgs(std::move(aRhs));
mType = TServiceWorkerExtensionAPIEventOpArgs;
return (*(this));
}
auto ServiceWorkerOpArgs::operator=(const ParentToChildServiceWorkerFetchEventOpArgs& aRhs) -> ServiceWorkerOpArgs&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_ParentToChildServiceWorkerFetchEventOpArgs()) ParentToChildServiceWorkerFetchEventOpArgs(aRhs);
mType = TParentToChildServiceWorkerFetchEventOpArgs;
return (*(this));
}
auto ServiceWorkerOpArgs::operator=(ParentToChildServiceWorkerFetchEventOpArgs&& aRhs) -> ServiceWorkerOpArgs&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_ParentToChildServiceWorkerFetchEventOpArgs()) ParentToChildServiceWorkerFetchEventOpArgs(std::move(aRhs));
mType = TParentToChildServiceWorkerFetchEventOpArgs;
return (*(this));
}
auto ServiceWorkerOpArgs::operator=(ServiceWorkerOpArgs&& aRhs) -> ServiceWorkerOpArgs&
{
(aRhs).AssertSanity();
Type t = (aRhs).type();
switch (t) {
case TServiceWorkerCheckScriptEvaluationOpArgs:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_ServiceWorkerCheckScriptEvaluationOpArgs()) ServiceWorkerCheckScriptEvaluationOpArgs(std::move((aRhs).get_ServiceWorkerCheckScriptEvaluationOpArgs()));
(aRhs).MaybeDestroy();
break;
}
case TServiceWorkerUpdateStateOpArgs:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_ServiceWorkerUpdateStateOpArgs()) ServiceWorkerUpdateStateOpArgs(std::move((aRhs).get_ServiceWorkerUpdateStateOpArgs()));
(aRhs).MaybeDestroy();
break;
}
case TServiceWorkerTerminateWorkerOpArgs:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_ServiceWorkerTerminateWorkerOpArgs()) ServiceWorkerTerminateWorkerOpArgs(std::move((aRhs).get_ServiceWorkerTerminateWorkerOpArgs()));
(aRhs).MaybeDestroy();
break;
}
case TServiceWorkerLifeCycleEventOpArgs:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_ServiceWorkerLifeCycleEventOpArgs()) ServiceWorkerLifeCycleEventOpArgs(std::move((aRhs).get_ServiceWorkerLifeCycleEventOpArgs()));
(aRhs).MaybeDestroy();
break;
}
case TServiceWorkerPushEventOpArgs:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_ServiceWorkerPushEventOpArgs()) ServiceWorkerPushEventOpArgs(std::move((aRhs).get_ServiceWorkerPushEventOpArgs()));
(aRhs).MaybeDestroy();
break;
}
case TServiceWorkerPushSubscriptionChangeEventOpArgs:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_ServiceWorkerPushSubscriptionChangeEventOpArgs()) ServiceWorkerPushSubscriptionChangeEventOpArgs(std::move((aRhs).get_ServiceWorkerPushSubscriptionChangeEventOpArgs()));
(aRhs).MaybeDestroy();
break;
}
case TServiceWorkerNotificationEventOpArgs:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_ServiceWorkerNotificationEventOpArgs()) ServiceWorkerNotificationEventOpArgs(std::move((aRhs).get_ServiceWorkerNotificationEventOpArgs()));
(aRhs).MaybeDestroy();
break;
}
case TServiceWorkerMessageEventOpArgs:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_ServiceWorkerMessageEventOpArgs()) ServiceWorkerMessageEventOpArgs(std::move((aRhs).get_ServiceWorkerMessageEventOpArgs()));
(aRhs).MaybeDestroy();
break;
}
case TServiceWorkerExtensionAPIEventOpArgs:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_ServiceWorkerExtensionAPIEventOpArgs()) ServiceWorkerExtensionAPIEventOpArgs(std::move((aRhs).get_ServiceWorkerExtensionAPIEventOpArgs()));
(aRhs).MaybeDestroy();
break;
}
case TParentToChildServiceWorkerFetchEventOpArgs:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_ParentToChildServiceWorkerFetchEventOpArgs()) ParentToChildServiceWorkerFetchEventOpArgs(std::move((aRhs).get_ParentToChildServiceWorkerFetchEventOpArgs()));
(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::ServiceWorkerOpArgs>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
typedef ::mozilla::dom::ServiceWorkerOpArgs union__;
int type = (aVar).type();
IPC::WriteParam(aWriter, type);
// Sentinel = 'ServiceWorkerOpArgs'
(aWriter)->WriteSentinel(1274349464);
switch (type) {
case union__::TServiceWorkerCheckScriptEvaluationOpArgs:
{
IPC::WriteParam(aWriter, (aVar).get_ServiceWorkerCheckScriptEvaluationOpArgs());
// Sentinel = 'TServiceWorkerCheckScriptEvaluationOpArgs'
(aWriter)->WriteSentinel(1425936471);
return;
}
case union__::TServiceWorkerUpdateStateOpArgs:
{
IPC::WriteParam(aWriter, (aVar).get_ServiceWorkerUpdateStateOpArgs());
// Sentinel = 'TServiceWorkerUpdateStateOpArgs'
(aWriter)->WriteSentinel(3300527184);
return;
}
case union__::TServiceWorkerTerminateWorkerOpArgs:
{
IPC::WriteParam(aWriter, (aVar).get_ServiceWorkerTerminateWorkerOpArgs());
// Sentinel = 'TServiceWorkerTerminateWorkerOpArgs'
(aWriter)->WriteSentinel(4230286863);
return;
}
case union__::TServiceWorkerLifeCycleEventOpArgs:
{
IPC::WriteParam(aWriter, (aVar).get_ServiceWorkerLifeCycleEventOpArgs());
// Sentinel = 'TServiceWorkerLifeCycleEventOpArgs'
(aWriter)->WriteSentinel(3917942110);
return;
}
case union__::TServiceWorkerPushEventOpArgs:
{
IPC::WriteParam(aWriter, (aVar).get_ServiceWorkerPushEventOpArgs());
// Sentinel = 'TServiceWorkerPushEventOpArgs'
(aWriter)->WriteSentinel(2897152910);
return;
}
case union__::TServiceWorkerPushSubscriptionChangeEventOpArgs:
{
IPC::WriteParam(aWriter, (aVar).get_ServiceWorkerPushSubscriptionChangeEventOpArgs());
// Sentinel = 'TServiceWorkerPushSubscriptionChangeEventOpArgs'
(aWriter)->WriteSentinel(3308065497);
return;
}
case union__::TServiceWorkerNotificationEventOpArgs:
{
IPC::WriteParam(aWriter, (aVar).get_ServiceWorkerNotificationEventOpArgs());
// Sentinel = 'TServiceWorkerNotificationEventOpArgs'
(aWriter)->WriteSentinel(421596885);
return;
}
case union__::TServiceWorkerMessageEventOpArgs:
{
IPC::WriteParam(aWriter, (aVar).get_ServiceWorkerMessageEventOpArgs());
// Sentinel = 'TServiceWorkerMessageEventOpArgs'
(aWriter)->WriteSentinel(3507686579);
return;
}
case union__::TServiceWorkerExtensionAPIEventOpArgs:
{
IPC::WriteParam(aWriter, (aVar).get_ServiceWorkerExtensionAPIEventOpArgs());
// Sentinel = 'TServiceWorkerExtensionAPIEventOpArgs'
(aWriter)->WriteSentinel(360779397);
return;
}
case union__::TParentToChildServiceWorkerFetchEventOpArgs:
{
IPC::WriteParam(aWriter, (aVar).get_ParentToChildServiceWorkerFetchEventOpArgs());
// Sentinel = 'TParentToChildServiceWorkerFetchEventOpArgs'
(aWriter)->WriteSentinel(1905725673);
return;
}
default:
{
aWriter->FatalError("unknown variant of union ServiceWorkerOpArgs");
return;
}
}
}
auto ParamTraits<::mozilla::dom::ServiceWorkerOpArgs>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
typedef ::mozilla::dom::ServiceWorkerOpArgs union__;
auto maybe__type = IPC::ReadParam<int>(aReader);
if (!maybe__type) {
aReader->FatalError("Error deserializing type of union ServiceWorkerOpArgs");
return {};
}
auto& type = *maybe__type;
// Sentinel = 'ServiceWorkerOpArgs'
if ((!((aReader)->ReadSentinel(1274349464)))) {
mozilla::ipc::SentinelReadError("Error deserializing type of union ServiceWorkerOpArgs");
return {};
}
switch (type) {
case union__::TServiceWorkerCheckScriptEvaluationOpArgs:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::dom::ServiceWorkerCheckScriptEvaluationOpArgs>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TServiceWorkerCheckScriptEvaluationOpArgs of union ServiceWorkerOpArgs");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TServiceWorkerCheckScriptEvaluationOpArgs'
if ((!((aReader)->ReadSentinel(1425936471)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TServiceWorkerCheckScriptEvaluationOpArgs of union ServiceWorkerOpArgs");
return {};
}
return std::move(tmp);
}
case union__::TServiceWorkerUpdateStateOpArgs:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::dom::ServiceWorkerUpdateStateOpArgs>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TServiceWorkerUpdateStateOpArgs of union ServiceWorkerOpArgs");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TServiceWorkerUpdateStateOpArgs'
if ((!((aReader)->ReadSentinel(3300527184)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TServiceWorkerUpdateStateOpArgs of union ServiceWorkerOpArgs");
return {};
}
return std::move(tmp);
}
case union__::TServiceWorkerTerminateWorkerOpArgs:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::dom::ServiceWorkerTerminateWorkerOpArgs>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TServiceWorkerTerminateWorkerOpArgs of union ServiceWorkerOpArgs");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TServiceWorkerTerminateWorkerOpArgs'
if ((!((aReader)->ReadSentinel(4230286863)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TServiceWorkerTerminateWorkerOpArgs of union ServiceWorkerOpArgs");
return {};
}
return std::move(tmp);
}
case union__::TServiceWorkerLifeCycleEventOpArgs:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::dom::ServiceWorkerLifeCycleEventOpArgs>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TServiceWorkerLifeCycleEventOpArgs of union ServiceWorkerOpArgs");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TServiceWorkerLifeCycleEventOpArgs'
if ((!((aReader)->ReadSentinel(3917942110)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TServiceWorkerLifeCycleEventOpArgs of union ServiceWorkerOpArgs");
return {};
}
return std::move(tmp);
}
case union__::TServiceWorkerPushEventOpArgs:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::dom::ServiceWorkerPushEventOpArgs>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TServiceWorkerPushEventOpArgs of union ServiceWorkerOpArgs");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TServiceWorkerPushEventOpArgs'
if ((!((aReader)->ReadSentinel(2897152910)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TServiceWorkerPushEventOpArgs of union ServiceWorkerOpArgs");
return {};
}
return std::move(tmp);
}
case union__::TServiceWorkerPushSubscriptionChangeEventOpArgs:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::dom::ServiceWorkerPushSubscriptionChangeEventOpArgs>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TServiceWorkerPushSubscriptionChangeEventOpArgs of union ServiceWorkerOpArgs");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TServiceWorkerPushSubscriptionChangeEventOpArgs'
if ((!((aReader)->ReadSentinel(3308065497)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TServiceWorkerPushSubscriptionChangeEventOpArgs of union ServiceWorkerOpArgs");
return {};
}
return std::move(tmp);
}
case union__::TServiceWorkerNotificationEventOpArgs:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::dom::ServiceWorkerNotificationEventOpArgs>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TServiceWorkerNotificationEventOpArgs of union ServiceWorkerOpArgs");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TServiceWorkerNotificationEventOpArgs'
if ((!((aReader)->ReadSentinel(421596885)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TServiceWorkerNotificationEventOpArgs of union ServiceWorkerOpArgs");
return {};
}
return std::move(tmp);
}
case union__::TServiceWorkerMessageEventOpArgs:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::dom::ServiceWorkerMessageEventOpArgs>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TServiceWorkerMessageEventOpArgs of union ServiceWorkerOpArgs");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TServiceWorkerMessageEventOpArgs'
if ((!((aReader)->ReadSentinel(3507686579)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TServiceWorkerMessageEventOpArgs of union ServiceWorkerOpArgs");
return {};
}
return std::move(tmp);
}
case union__::TServiceWorkerExtensionAPIEventOpArgs:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::dom::ServiceWorkerExtensionAPIEventOpArgs>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TServiceWorkerExtensionAPIEventOpArgs of union ServiceWorkerOpArgs");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TServiceWorkerExtensionAPIEventOpArgs'
if ((!((aReader)->ReadSentinel(360779397)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TServiceWorkerExtensionAPIEventOpArgs of union ServiceWorkerOpArgs");
return {};
}
return std::move(tmp);
}
case union__::TParentToChildServiceWorkerFetchEventOpArgs:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::dom::ParentToChildServiceWorkerFetchEventOpArgs>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TParentToChildServiceWorkerFetchEventOpArgs of union ServiceWorkerOpArgs");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TParentToChildServiceWorkerFetchEventOpArgs'
if ((!((aReader)->ReadSentinel(1905725673)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TParentToChildServiceWorkerFetchEventOpArgs of union ServiceWorkerOpArgs");
return {};
}
return std::move(tmp);
}
default:
{
aReader->FatalError("unknown variant of union ServiceWorkerOpArgs");
return {};
}
}
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct FetchEventRespondWithClosure|
//
namespace mozilla {
namespace dom {
auto FetchEventRespondWithClosure::StaticAssertions() const -> void
{
static_assert(
(offsetof(FetchEventRespondWithClosure, respondWithColumnNumber_) - offsetof(FetchEventRespondWithClosure, respondWithLineNumber_)) == 4,
"Bad assumptions about field layout!");
}
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::FetchEventRespondWithClosure>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).respondWithScriptSpec());
// Sentinel = 'respondWithScriptSpec'
(aWriter)->WriteSentinel(1605044376);
(aWriter)->WriteBytes((&((aVar).respondWithLineNumber())), 8);
// Sentinel = 'respondWithLineNumber | respondWithColumnNumber'
(aWriter)->WriteSentinel(3238269619);
}
auto ParamTraits<::mozilla::dom::FetchEventRespondWithClosure>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___respondWithScriptSpec = IPC::ReadParam<::nsCString>(aReader);
if (!maybe___respondWithScriptSpec) {
aReader->FatalError("Error deserializing 'respondWithScriptSpec' (nsCString) member of 'FetchEventRespondWithClosure'");
return {};
}
auto& _respondWithScriptSpec = *maybe___respondWithScriptSpec;
// Sentinel = 'respondWithScriptSpec'
if ((!((aReader)->ReadSentinel(1605044376)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'respondWithScriptSpec' (nsCString) member of 'FetchEventRespondWithClosure'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_respondWithScriptSpec),
::uint32_t{0},
::uint32_t{0}};
if ((!((aReader)->ReadBytesInto((&((result__)->respondWithLineNumber())), 8)))) {
aReader->FatalError("Error bulk reading fields from uint32_t");
return {};
}
// Sentinel = 'respondWithLineNumber | respondWithColumnNumber'
if ((!((aReader)->ReadSentinel(3238269619)))) {
mozilla::ipc::SentinelReadError("Error bulk reading fields from uint32_t");
return {};
}
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct FetchEventTimeStamps|
//
namespace mozilla {
namespace dom {
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::FetchEventTimeStamps>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).fetchHandlerStart());
// Sentinel = 'fetchHandlerStart'
(aWriter)->WriteSentinel(1018758871);
IPC::WriteParam(aWriter, (aVar).fetchHandlerFinish());
// Sentinel = 'fetchHandlerFinish'
(aWriter)->WriteSentinel(1133119274);
}
auto ParamTraits<::mozilla::dom::FetchEventTimeStamps>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___fetchHandlerStart = IPC::ReadParam<::mozilla::TimeStamp>(aReader);
if (!maybe___fetchHandlerStart) {
aReader->FatalError("Error deserializing 'fetchHandlerStart' (TimeStamp) member of 'FetchEventTimeStamps'");
return {};
}
auto& _fetchHandlerStart = *maybe___fetchHandlerStart;
// Sentinel = 'fetchHandlerStart'
if ((!((aReader)->ReadSentinel(1018758871)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'fetchHandlerStart' (TimeStamp) member of 'FetchEventTimeStamps'");
return {};
}
auto maybe___fetchHandlerFinish = IPC::ReadParam<::mozilla::TimeStamp>(aReader);
if (!maybe___fetchHandlerFinish) {
aReader->FatalError("Error deserializing 'fetchHandlerFinish' (TimeStamp) member of 'FetchEventTimeStamps'");
return {};
}
auto& _fetchHandlerFinish = *maybe___fetchHandlerFinish;
// Sentinel = 'fetchHandlerFinish'
if ((!((aReader)->ReadSentinel(1133119274)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'fetchHandlerFinish' (TimeStamp) member of 'FetchEventTimeStamps'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_fetchHandlerStart),
std::move(_fetchHandlerFinish)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct ChildToParentSynthesizeResponseArgs|
//
namespace mozilla {
namespace dom {
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::ChildToParentSynthesizeResponseArgs>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).internalResponse());
// Sentinel = 'internalResponse'
(aWriter)->WriteSentinel(951649965);
IPC::WriteParam(aWriter, (aVar).closure());
// Sentinel = 'closure'
(aWriter)->WriteSentinel(199426814);
IPC::WriteParam(aWriter, (aVar).timeStamps());
// Sentinel = 'timeStamps'
(aWriter)->WriteSentinel(381813800);
}
auto ParamTraits<::mozilla::dom::ChildToParentSynthesizeResponseArgs>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___internalResponse = IPC::ReadParam<::mozilla::dom::ChildToParentInternalResponse>(aReader);
if (!maybe___internalResponse) {
aReader->FatalError("Error deserializing 'internalResponse' (ChildToParentInternalResponse) member of 'ChildToParentSynthesizeResponseArgs'");
return {};
}
auto& _internalResponse = *maybe___internalResponse;
// Sentinel = 'internalResponse'
if ((!((aReader)->ReadSentinel(951649965)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'internalResponse' (ChildToParentInternalResponse) member of 'ChildToParentSynthesizeResponseArgs'");
return {};
}
auto maybe___closure = IPC::ReadParam<::mozilla::dom::FetchEventRespondWithClosure>(aReader);
if (!maybe___closure) {
aReader->FatalError("Error deserializing 'closure' (FetchEventRespondWithClosure) member of 'ChildToParentSynthesizeResponseArgs'");
return {};
}
auto& _closure = *maybe___closure;
// Sentinel = 'closure'
if ((!((aReader)->ReadSentinel(199426814)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'closure' (FetchEventRespondWithClosure) member of 'ChildToParentSynthesizeResponseArgs'");
return {};
}
auto maybe___timeStamps = IPC::ReadParam<::mozilla::dom::FetchEventTimeStamps>(aReader);
if (!maybe___timeStamps) {
aReader->FatalError("Error deserializing 'timeStamps' (FetchEventTimeStamps) member of 'ChildToParentSynthesizeResponseArgs'");
return {};
}
auto& _timeStamps = *maybe___timeStamps;
// Sentinel = 'timeStamps'
if ((!((aReader)->ReadSentinel(381813800)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'timeStamps' (FetchEventTimeStamps) member of 'ChildToParentSynthesizeResponseArgs'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_internalResponse),
std::move(_closure),
std::move(_timeStamps)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct ParentToParentSynthesizeResponseArgs|
//
namespace mozilla {
namespace dom {
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::ParentToParentSynthesizeResponseArgs>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).internalResponse());
// Sentinel = 'internalResponse'
(aWriter)->WriteSentinel(951649965);
IPC::WriteParam(aWriter, (aVar).closure());
// Sentinel = 'closure'
(aWriter)->WriteSentinel(199426814);
IPC::WriteParam(aWriter, (aVar).timeStamps());
// Sentinel = 'timeStamps'
(aWriter)->WriteSentinel(381813800);
}
auto ParamTraits<::mozilla::dom::ParentToParentSynthesizeResponseArgs>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___internalResponse = IPC::ReadParam<::mozilla::dom::ParentToParentInternalResponse>(aReader);
if (!maybe___internalResponse) {
aReader->FatalError("Error deserializing 'internalResponse' (ParentToParentInternalResponse) member of 'ParentToParentSynthesizeResponseArgs'");
return {};
}
auto& _internalResponse = *maybe___internalResponse;
// Sentinel = 'internalResponse'
if ((!((aReader)->ReadSentinel(951649965)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'internalResponse' (ParentToParentInternalResponse) member of 'ParentToParentSynthesizeResponseArgs'");
return {};
}
auto maybe___closure = IPC::ReadParam<::mozilla::dom::FetchEventRespondWithClosure>(aReader);
if (!maybe___closure) {
aReader->FatalError("Error deserializing 'closure' (FetchEventRespondWithClosure) member of 'ParentToParentSynthesizeResponseArgs'");
return {};
}
auto& _closure = *maybe___closure;
// Sentinel = 'closure'
if ((!((aReader)->ReadSentinel(199426814)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'closure' (FetchEventRespondWithClosure) member of 'ParentToParentSynthesizeResponseArgs'");
return {};
}
auto maybe___timeStamps = IPC::ReadParam<::mozilla::dom::FetchEventTimeStamps>(aReader);
if (!maybe___timeStamps) {
aReader->FatalError("Error deserializing 'timeStamps' (FetchEventTimeStamps) member of 'ParentToParentSynthesizeResponseArgs'");
return {};
}
auto& _timeStamps = *maybe___timeStamps;
// Sentinel = 'timeStamps'
if ((!((aReader)->ReadSentinel(381813800)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'timeStamps' (FetchEventTimeStamps) member of 'ParentToParentSynthesizeResponseArgs'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_internalResponse),
std::move(_closure),
std::move(_timeStamps)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct ResetInterceptionArgs|
//
namespace mozilla {
namespace dom {
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::ResetInterceptionArgs>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).timeStamps());
// Sentinel = 'timeStamps'
(aWriter)->WriteSentinel(381813800);
}
auto ParamTraits<::mozilla::dom::ResetInterceptionArgs>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___timeStamps = IPC::ReadParam<::mozilla::dom::FetchEventTimeStamps>(aReader);
if (!maybe___timeStamps) {
aReader->FatalError("Error deserializing 'timeStamps' (FetchEventTimeStamps) member of 'ResetInterceptionArgs'");
return {};
}
auto& _timeStamps = *maybe___timeStamps;
// Sentinel = 'timeStamps'
if ((!((aReader)->ReadSentinel(381813800)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'timeStamps' (FetchEventTimeStamps) member of 'ResetInterceptionArgs'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_timeStamps)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct CancelInterceptionArgs|
//
namespace mozilla {
namespace dom {
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::CancelInterceptionArgs>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).status());
// Sentinel = 'status'
(aWriter)->WriteSentinel(154731173);
IPC::WriteParam(aWriter, (aVar).timeStamps());
// Sentinel = 'timeStamps'
(aWriter)->WriteSentinel(381813800);
}
auto ParamTraits<::mozilla::dom::CancelInterceptionArgs>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___status = IPC::ReadParam<::nsresult>(aReader);
if (!maybe___status) {
aReader->FatalError("Error deserializing 'status' (nsresult) member of 'CancelInterceptionArgs'");
return {};
}
auto& _status = *maybe___status;
// Sentinel = 'status'
if ((!((aReader)->ReadSentinel(154731173)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'status' (nsresult) member of 'CancelInterceptionArgs'");
return {};
}
auto maybe___timeStamps = IPC::ReadParam<::mozilla::dom::FetchEventTimeStamps>(aReader);
if (!maybe___timeStamps) {
aReader->FatalError("Error deserializing 'timeStamps' (FetchEventTimeStamps) member of 'CancelInterceptionArgs'");
return {};
}
auto& _timeStamps = *maybe___timeStamps;
// Sentinel = 'timeStamps'
if ((!((aReader)->ReadSentinel(381813800)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'timeStamps' (FetchEventTimeStamps) member of 'CancelInterceptionArgs'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_status),
std::move(_timeStamps)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |union ChildToParentFetchEventRespondWithResult|
//
namespace mozilla {
namespace dom {
auto ChildToParentFetchEventRespondWithResult::MaybeDestroy() -> void
{
if ((mType) == (T__None)) {
return;
}
switch (mType) {
case TChildToParentSynthesizeResponseArgs:
{
(ptr_ChildToParentSynthesizeResponseArgs())->~ChildToParentSynthesizeResponseArgs__tdef();
break;
}
case TResetInterceptionArgs:
{
(ptr_ResetInterceptionArgs())->~ResetInterceptionArgs__tdef();
break;
}
case TCancelInterceptionArgs:
{
(ptr_CancelInterceptionArgs())->~CancelInterceptionArgs__tdef();
break;
}
default:
{
mozilla::ipc::LogicError("not reached");
break;
}
}
}
MOZ_IMPLICIT ChildToParentFetchEventRespondWithResult::ChildToParentFetchEventRespondWithResult(const ChildToParentSynthesizeResponseArgs& aOther)
{
new (mozilla::KnownNotNull, ptr_ChildToParentSynthesizeResponseArgs()) ChildToParentSynthesizeResponseArgs(aOther);
mType = TChildToParentSynthesizeResponseArgs;
}
MOZ_IMPLICIT ChildToParentFetchEventRespondWithResult::ChildToParentFetchEventRespondWithResult(ChildToParentSynthesizeResponseArgs&& aOther)
{
new (mozilla::KnownNotNull, ptr_ChildToParentSynthesizeResponseArgs()) ChildToParentSynthesizeResponseArgs(std::move(aOther));
mType = TChildToParentSynthesizeResponseArgs;
}
MOZ_IMPLICIT ChildToParentFetchEventRespondWithResult::ChildToParentFetchEventRespondWithResult(const ResetInterceptionArgs& aOther)
{
new (mozilla::KnownNotNull, ptr_ResetInterceptionArgs()) ResetInterceptionArgs(aOther);
mType = TResetInterceptionArgs;
}
MOZ_IMPLICIT ChildToParentFetchEventRespondWithResult::ChildToParentFetchEventRespondWithResult(ResetInterceptionArgs&& aOther)
{
new (mozilla::KnownNotNull, ptr_ResetInterceptionArgs()) ResetInterceptionArgs(std::move(aOther));
mType = TResetInterceptionArgs;
}
MOZ_IMPLICIT ChildToParentFetchEventRespondWithResult::ChildToParentFetchEventRespondWithResult(const CancelInterceptionArgs& aOther)
{
new (mozilla::KnownNotNull, ptr_CancelInterceptionArgs()) CancelInterceptionArgs(aOther);
mType = TCancelInterceptionArgs;
}
MOZ_IMPLICIT ChildToParentFetchEventRespondWithResult::ChildToParentFetchEventRespondWithResult(CancelInterceptionArgs&& aOther)
{
new (mozilla::KnownNotNull, ptr_CancelInterceptionArgs()) CancelInterceptionArgs(std::move(aOther));
mType = TCancelInterceptionArgs;
}
MOZ_IMPLICIT ChildToParentFetchEventRespondWithResult::ChildToParentFetchEventRespondWithResult(const ChildToParentFetchEventRespondWithResult& aOther)
{
(aOther).AssertSanity();
switch ((aOther).type()) {
case TChildToParentSynthesizeResponseArgs:
{
new (mozilla::KnownNotNull, ptr_ChildToParentSynthesizeResponseArgs()) ChildToParentSynthesizeResponseArgs((aOther).get_ChildToParentSynthesizeResponseArgs());
break;
}
case TResetInterceptionArgs:
{
new (mozilla::KnownNotNull, ptr_ResetInterceptionArgs()) ResetInterceptionArgs((aOther).get_ResetInterceptionArgs());
break;
}
case TCancelInterceptionArgs:
{
new (mozilla::KnownNotNull, ptr_CancelInterceptionArgs()) CancelInterceptionArgs((aOther).get_CancelInterceptionArgs());
break;
}
case T__None:
{
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
return;
}
}
mType = (aOther).type();
}
MOZ_IMPLICIT ChildToParentFetchEventRespondWithResult::ChildToParentFetchEventRespondWithResult(ChildToParentFetchEventRespondWithResult&& aOther)
{
(aOther).AssertSanity();
Type t = (aOther).type();
switch (t) {
case TChildToParentSynthesizeResponseArgs:
{
new (mozilla::KnownNotNull, ptr_ChildToParentSynthesizeResponseArgs()) ChildToParentSynthesizeResponseArgs(std::move((aOther).get_ChildToParentSynthesizeResponseArgs()));
(aOther).MaybeDestroy();
break;
}
case TResetInterceptionArgs:
{
new (mozilla::KnownNotNull, ptr_ResetInterceptionArgs()) ResetInterceptionArgs(std::move((aOther).get_ResetInterceptionArgs()));
(aOther).MaybeDestroy();
break;
}
case TCancelInterceptionArgs:
{
new (mozilla::KnownNotNull, ptr_CancelInterceptionArgs()) CancelInterceptionArgs(std::move((aOther).get_CancelInterceptionArgs()));
(aOther).MaybeDestroy();
break;
}
case T__None:
{
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
return;
}
}
(aOther).mType = T__None;
mType = t;
}
ChildToParentFetchEventRespondWithResult::~ChildToParentFetchEventRespondWithResult()
{
MaybeDestroy();
}
auto ChildToParentFetchEventRespondWithResult::operator=(const ChildToParentSynthesizeResponseArgs& aRhs) -> ChildToParentFetchEventRespondWithResult&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_ChildToParentSynthesizeResponseArgs()) ChildToParentSynthesizeResponseArgs(aRhs);
mType = TChildToParentSynthesizeResponseArgs;
return (*(this));
}
auto ChildToParentFetchEventRespondWithResult::operator=(ChildToParentSynthesizeResponseArgs&& aRhs) -> ChildToParentFetchEventRespondWithResult&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_ChildToParentSynthesizeResponseArgs()) ChildToParentSynthesizeResponseArgs(std::move(aRhs));
mType = TChildToParentSynthesizeResponseArgs;
return (*(this));
}
auto ChildToParentFetchEventRespondWithResult::operator=(const ResetInterceptionArgs& aRhs) -> ChildToParentFetchEventRespondWithResult&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_ResetInterceptionArgs()) ResetInterceptionArgs(aRhs);
mType = TResetInterceptionArgs;
return (*(this));
}
auto ChildToParentFetchEventRespondWithResult::operator=(ResetInterceptionArgs&& aRhs) -> ChildToParentFetchEventRespondWithResult&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_ResetInterceptionArgs()) ResetInterceptionArgs(std::move(aRhs));
mType = TResetInterceptionArgs;
return (*(this));
}
auto ChildToParentFetchEventRespondWithResult::operator=(const CancelInterceptionArgs& aRhs) -> ChildToParentFetchEventRespondWithResult&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_CancelInterceptionArgs()) CancelInterceptionArgs(aRhs);
mType = TCancelInterceptionArgs;
return (*(this));
}
auto ChildToParentFetchEventRespondWithResult::operator=(CancelInterceptionArgs&& aRhs) -> ChildToParentFetchEventRespondWithResult&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_CancelInterceptionArgs()) CancelInterceptionArgs(std::move(aRhs));
mType = TCancelInterceptionArgs;
return (*(this));
}
auto ChildToParentFetchEventRespondWithResult::operator=(const ChildToParentFetchEventRespondWithResult& aRhs) -> ChildToParentFetchEventRespondWithResult&
{
(aRhs).AssertSanity();
Type t = (aRhs).type();
switch (t) {
case TChildToParentSynthesizeResponseArgs:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_ChildToParentSynthesizeResponseArgs()) ChildToParentSynthesizeResponseArgs((aRhs).get_ChildToParentSynthesizeResponseArgs());
break;
}
case TResetInterceptionArgs:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_ResetInterceptionArgs()) ResetInterceptionArgs((aRhs).get_ResetInterceptionArgs());
break;
}
case TCancelInterceptionArgs:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_CancelInterceptionArgs()) CancelInterceptionArgs((aRhs).get_CancelInterceptionArgs());
break;
}
case T__None:
{
MaybeDestroy();
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
break;
}
}
mType = t;
return (*(this));
}
auto ChildToParentFetchEventRespondWithResult::operator=(ChildToParentFetchEventRespondWithResult&& aRhs) -> ChildToParentFetchEventRespondWithResult&
{
(aRhs).AssertSanity();
Type t = (aRhs).type();
switch (t) {
case TChildToParentSynthesizeResponseArgs:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_ChildToParentSynthesizeResponseArgs()) ChildToParentSynthesizeResponseArgs(std::move((aRhs).get_ChildToParentSynthesizeResponseArgs()));
(aRhs).MaybeDestroy();
break;
}
case TResetInterceptionArgs:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_ResetInterceptionArgs()) ResetInterceptionArgs(std::move((aRhs).get_ResetInterceptionArgs()));
(aRhs).MaybeDestroy();
break;
}
case TCancelInterceptionArgs:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_CancelInterceptionArgs()) CancelInterceptionArgs(std::move((aRhs).get_CancelInterceptionArgs()));
(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::ChildToParentFetchEventRespondWithResult>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
typedef ::mozilla::dom::ChildToParentFetchEventRespondWithResult union__;
int type = (aVar).type();
IPC::WriteParam(aWriter, type);
// Sentinel = 'ChildToParentFetchEventRespondWithResult'
(aWriter)->WriteSentinel(1078464500);
switch (type) {
case union__::TChildToParentSynthesizeResponseArgs:
{
IPC::WriteParam(aWriter, (aVar).get_ChildToParentSynthesizeResponseArgs());
// Sentinel = 'TChildToParentSynthesizeResponseArgs'
(aWriter)->WriteSentinel(108859000);
return;
}
case union__::TResetInterceptionArgs:
{
IPC::WriteParam(aWriter, (aVar).get_ResetInterceptionArgs());
// Sentinel = 'TResetInterceptionArgs'
(aWriter)->WriteSentinel(1678969049);
return;
}
case union__::TCancelInterceptionArgs:
{
IPC::WriteParam(aWriter, (aVar).get_CancelInterceptionArgs());
// Sentinel = 'TCancelInterceptionArgs'
(aWriter)->WriteSentinel(1784744220);
return;
}
default:
{
aWriter->FatalError("unknown variant of union ChildToParentFetchEventRespondWithResult");
return;
}
}
}
auto ParamTraits<::mozilla::dom::ChildToParentFetchEventRespondWithResult>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
typedef ::mozilla::dom::ChildToParentFetchEventRespondWithResult union__;
auto maybe__type = IPC::ReadParam<int>(aReader);
if (!maybe__type) {
aReader->FatalError("Error deserializing type of union ChildToParentFetchEventRespondWithResult");
return {};
}
auto& type = *maybe__type;
// Sentinel = 'ChildToParentFetchEventRespondWithResult'
if ((!((aReader)->ReadSentinel(1078464500)))) {
mozilla::ipc::SentinelReadError("Error deserializing type of union ChildToParentFetchEventRespondWithResult");
return {};
}
switch (type) {
case union__::TChildToParentSynthesizeResponseArgs:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::dom::ChildToParentSynthesizeResponseArgs>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TChildToParentSynthesizeResponseArgs of union ChildToParentFetchEventRespondWithResult");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TChildToParentSynthesizeResponseArgs'
if ((!((aReader)->ReadSentinel(108859000)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TChildToParentSynthesizeResponseArgs of union ChildToParentFetchEventRespondWithResult");
return {};
}
return std::move(tmp);
}
case union__::TResetInterceptionArgs:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::dom::ResetInterceptionArgs>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TResetInterceptionArgs of union ChildToParentFetchEventRespondWithResult");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TResetInterceptionArgs'
if ((!((aReader)->ReadSentinel(1678969049)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TResetInterceptionArgs of union ChildToParentFetchEventRespondWithResult");
return {};
}
return std::move(tmp);
}
case union__::TCancelInterceptionArgs:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::dom::CancelInterceptionArgs>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TCancelInterceptionArgs of union ChildToParentFetchEventRespondWithResult");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TCancelInterceptionArgs'
if ((!((aReader)->ReadSentinel(1784744220)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TCancelInterceptionArgs of union ChildToParentFetchEventRespondWithResult");
return {};
}
return std::move(tmp);
}
default:
{
aReader->FatalError("unknown variant of union ChildToParentFetchEventRespondWithResult");
return {};
}
}
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |union ParentToParentFetchEventRespondWithResult|
//
namespace mozilla {
namespace dom {
auto ParentToParentFetchEventRespondWithResult::MaybeDestroy() -> void
{
if ((mType) == (T__None)) {
return;
}
switch (mType) {
case TParentToParentSynthesizeResponseArgs:
{
(ptr_ParentToParentSynthesizeResponseArgs())->~ParentToParentSynthesizeResponseArgs__tdef();
break;
}
case TResetInterceptionArgs:
{
(ptr_ResetInterceptionArgs())->~ResetInterceptionArgs__tdef();
break;
}
case TCancelInterceptionArgs:
{
(ptr_CancelInterceptionArgs())->~CancelInterceptionArgs__tdef();
break;
}
default:
{
mozilla::ipc::LogicError("not reached");
break;
}
}
}
MOZ_IMPLICIT ParentToParentFetchEventRespondWithResult::ParentToParentFetchEventRespondWithResult(const ParentToParentSynthesizeResponseArgs& aOther)
{
new (mozilla::KnownNotNull, ptr_ParentToParentSynthesizeResponseArgs()) ParentToParentSynthesizeResponseArgs(aOther);
mType = TParentToParentSynthesizeResponseArgs;
}
MOZ_IMPLICIT ParentToParentFetchEventRespondWithResult::ParentToParentFetchEventRespondWithResult(ParentToParentSynthesizeResponseArgs&& aOther)
{
new (mozilla::KnownNotNull, ptr_ParentToParentSynthesizeResponseArgs()) ParentToParentSynthesizeResponseArgs(std::move(aOther));
mType = TParentToParentSynthesizeResponseArgs;
}
MOZ_IMPLICIT ParentToParentFetchEventRespondWithResult::ParentToParentFetchEventRespondWithResult(const ResetInterceptionArgs& aOther)
{
new (mozilla::KnownNotNull, ptr_ResetInterceptionArgs()) ResetInterceptionArgs(aOther);
mType = TResetInterceptionArgs;
}
MOZ_IMPLICIT ParentToParentFetchEventRespondWithResult::ParentToParentFetchEventRespondWithResult(ResetInterceptionArgs&& aOther)
{
new (mozilla::KnownNotNull, ptr_ResetInterceptionArgs()) ResetInterceptionArgs(std::move(aOther));
mType = TResetInterceptionArgs;
}
MOZ_IMPLICIT ParentToParentFetchEventRespondWithResult::ParentToParentFetchEventRespondWithResult(const CancelInterceptionArgs& aOther)
{
new (mozilla::KnownNotNull, ptr_CancelInterceptionArgs()) CancelInterceptionArgs(aOther);
mType = TCancelInterceptionArgs;
}
MOZ_IMPLICIT ParentToParentFetchEventRespondWithResult::ParentToParentFetchEventRespondWithResult(CancelInterceptionArgs&& aOther)
{
new (mozilla::KnownNotNull, ptr_CancelInterceptionArgs()) CancelInterceptionArgs(std::move(aOther));
mType = TCancelInterceptionArgs;
}
MOZ_IMPLICIT ParentToParentFetchEventRespondWithResult::ParentToParentFetchEventRespondWithResult(const ParentToParentFetchEventRespondWithResult& aOther)
{
(aOther).AssertSanity();
switch ((aOther).type()) {
case TParentToParentSynthesizeResponseArgs:
{
new (mozilla::KnownNotNull, ptr_ParentToParentSynthesizeResponseArgs()) ParentToParentSynthesizeResponseArgs((aOther).get_ParentToParentSynthesizeResponseArgs());
break;
}
case TResetInterceptionArgs:
{
new (mozilla::KnownNotNull, ptr_ResetInterceptionArgs()) ResetInterceptionArgs((aOther).get_ResetInterceptionArgs());
break;
}
case TCancelInterceptionArgs:
{
new (mozilla::KnownNotNull, ptr_CancelInterceptionArgs()) CancelInterceptionArgs((aOther).get_CancelInterceptionArgs());
break;
}
case T__None:
{
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
return;
}
}
mType = (aOther).type();
}
MOZ_IMPLICIT ParentToParentFetchEventRespondWithResult::ParentToParentFetchEventRespondWithResult(ParentToParentFetchEventRespondWithResult&& aOther)
{
(aOther).AssertSanity();
Type t = (aOther).type();
switch (t) {
case TParentToParentSynthesizeResponseArgs:
{
new (mozilla::KnownNotNull, ptr_ParentToParentSynthesizeResponseArgs()) ParentToParentSynthesizeResponseArgs(std::move((aOther).get_ParentToParentSynthesizeResponseArgs()));
(aOther).MaybeDestroy();
break;
}
case TResetInterceptionArgs:
{
new (mozilla::KnownNotNull, ptr_ResetInterceptionArgs()) ResetInterceptionArgs(std::move((aOther).get_ResetInterceptionArgs()));
(aOther).MaybeDestroy();
break;
}
case TCancelInterceptionArgs:
{
new (mozilla::KnownNotNull, ptr_CancelInterceptionArgs()) CancelInterceptionArgs(std::move((aOther).get_CancelInterceptionArgs()));
(aOther).MaybeDestroy();
break;
}
case T__None:
{
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
return;
}
}
(aOther).mType = T__None;
mType = t;
}
ParentToParentFetchEventRespondWithResult::~ParentToParentFetchEventRespondWithResult()
{
MaybeDestroy();
}
auto ParentToParentFetchEventRespondWithResult::operator=(const ParentToParentSynthesizeResponseArgs& aRhs) -> ParentToParentFetchEventRespondWithResult&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_ParentToParentSynthesizeResponseArgs()) ParentToParentSynthesizeResponseArgs(aRhs);
mType = TParentToParentSynthesizeResponseArgs;
return (*(this));
}
auto ParentToParentFetchEventRespondWithResult::operator=(ParentToParentSynthesizeResponseArgs&& aRhs) -> ParentToParentFetchEventRespondWithResult&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_ParentToParentSynthesizeResponseArgs()) ParentToParentSynthesizeResponseArgs(std::move(aRhs));
mType = TParentToParentSynthesizeResponseArgs;
return (*(this));
}
auto ParentToParentFetchEventRespondWithResult::operator=(const ResetInterceptionArgs& aRhs) -> ParentToParentFetchEventRespondWithResult&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_ResetInterceptionArgs()) ResetInterceptionArgs(aRhs);
mType = TResetInterceptionArgs;
return (*(this));
}
auto ParentToParentFetchEventRespondWithResult::operator=(ResetInterceptionArgs&& aRhs) -> ParentToParentFetchEventRespondWithResult&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_ResetInterceptionArgs()) ResetInterceptionArgs(std::move(aRhs));
mType = TResetInterceptionArgs;
return (*(this));
}
auto ParentToParentFetchEventRespondWithResult::operator=(const CancelInterceptionArgs& aRhs) -> ParentToParentFetchEventRespondWithResult&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_CancelInterceptionArgs()) CancelInterceptionArgs(aRhs);
mType = TCancelInterceptionArgs;
return (*(this));
}
auto ParentToParentFetchEventRespondWithResult::operator=(CancelInterceptionArgs&& aRhs) -> ParentToParentFetchEventRespondWithResult&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_CancelInterceptionArgs()) CancelInterceptionArgs(std::move(aRhs));
mType = TCancelInterceptionArgs;
return (*(this));
}
auto ParentToParentFetchEventRespondWithResult::operator=(const ParentToParentFetchEventRespondWithResult& aRhs) -> ParentToParentFetchEventRespondWithResult&
{
(aRhs).AssertSanity();
Type t = (aRhs).type();
switch (t) {
case TParentToParentSynthesizeResponseArgs:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_ParentToParentSynthesizeResponseArgs()) ParentToParentSynthesizeResponseArgs((aRhs).get_ParentToParentSynthesizeResponseArgs());
break;
}
case TResetInterceptionArgs:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_ResetInterceptionArgs()) ResetInterceptionArgs((aRhs).get_ResetInterceptionArgs());
break;
}
case TCancelInterceptionArgs:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_CancelInterceptionArgs()) CancelInterceptionArgs((aRhs).get_CancelInterceptionArgs());
break;
}
case T__None:
{
MaybeDestroy();
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
break;
}
}
mType = t;
return (*(this));
}
auto ParentToParentFetchEventRespondWithResult::operator=(ParentToParentFetchEventRespondWithResult&& aRhs) -> ParentToParentFetchEventRespondWithResult&
{
(aRhs).AssertSanity();
Type t = (aRhs).type();
switch (t) {
case TParentToParentSynthesizeResponseArgs:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_ParentToParentSynthesizeResponseArgs()) ParentToParentSynthesizeResponseArgs(std::move((aRhs).get_ParentToParentSynthesizeResponseArgs()));
(aRhs).MaybeDestroy();
break;
}
case TResetInterceptionArgs:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_ResetInterceptionArgs()) ResetInterceptionArgs(std::move((aRhs).get_ResetInterceptionArgs()));
(aRhs).MaybeDestroy();
break;
}
case TCancelInterceptionArgs:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_CancelInterceptionArgs()) CancelInterceptionArgs(std::move((aRhs).get_CancelInterceptionArgs()));
(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::ParentToParentFetchEventRespondWithResult>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
typedef ::mozilla::dom::ParentToParentFetchEventRespondWithResult union__;
int type = (aVar).type();
IPC::WriteParam(aWriter, type);
// Sentinel = 'ParentToParentFetchEventRespondWithResult'
(aWriter)->WriteSentinel(1430327418);
switch (type) {
case union__::TParentToParentSynthesizeResponseArgs:
{
IPC::WriteParam(aWriter, (aVar).get_ParentToParentSynthesizeResponseArgs());
// Sentinel = 'TParentToParentSynthesizeResponseArgs'
(aWriter)->WriteSentinel(422317822);
return;
}
case union__::TResetInterceptionArgs:
{
IPC::WriteParam(aWriter, (aVar).get_ResetInterceptionArgs());
// Sentinel = 'TResetInterceptionArgs'
(aWriter)->WriteSentinel(1678969049);
return;
}
case union__::TCancelInterceptionArgs:
{
IPC::WriteParam(aWriter, (aVar).get_CancelInterceptionArgs());
// Sentinel = 'TCancelInterceptionArgs'
(aWriter)->WriteSentinel(1784744220);
return;
}
default:
{
aWriter->FatalError("unknown variant of union ParentToParentFetchEventRespondWithResult");
return;
}
}
}
auto ParamTraits<::mozilla::dom::ParentToParentFetchEventRespondWithResult>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
typedef ::mozilla::dom::ParentToParentFetchEventRespondWithResult union__;
auto maybe__type = IPC::ReadParam<int>(aReader);
if (!maybe__type) {
aReader->FatalError("Error deserializing type of union ParentToParentFetchEventRespondWithResult");
return {};
}
auto& type = *maybe__type;
// Sentinel = 'ParentToParentFetchEventRespondWithResult'
if ((!((aReader)->ReadSentinel(1430327418)))) {
mozilla::ipc::SentinelReadError("Error deserializing type of union ParentToParentFetchEventRespondWithResult");
return {};
}
switch (type) {
case union__::TParentToParentSynthesizeResponseArgs:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::dom::ParentToParentSynthesizeResponseArgs>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TParentToParentSynthesizeResponseArgs of union ParentToParentFetchEventRespondWithResult");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TParentToParentSynthesizeResponseArgs'
if ((!((aReader)->ReadSentinel(422317822)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TParentToParentSynthesizeResponseArgs of union ParentToParentFetchEventRespondWithResult");
return {};
}
return std::move(tmp);
}
case union__::TResetInterceptionArgs:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::dom::ResetInterceptionArgs>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TResetInterceptionArgs of union ParentToParentFetchEventRespondWithResult");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TResetInterceptionArgs'
if ((!((aReader)->ReadSentinel(1678969049)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TResetInterceptionArgs of union ParentToParentFetchEventRespondWithResult");
return {};
}
return std::move(tmp);
}
case union__::TCancelInterceptionArgs:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::dom::CancelInterceptionArgs>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TCancelInterceptionArgs of union ParentToParentFetchEventRespondWithResult");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TCancelInterceptionArgs'
if ((!((aReader)->ReadSentinel(1784744220)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TCancelInterceptionArgs of union ParentToParentFetchEventRespondWithResult");
return {};
}
return std::move(tmp);
}
default:
{
aReader->FatalError("unknown variant of union ParentToParentFetchEventRespondWithResult");
return {};
}
}
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct ServiceWorkerCheckScriptEvaluationOpResult|
//
namespace mozilla {
namespace dom {
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::ServiceWorkerCheckScriptEvaluationOpResult>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).workerScriptExecutedSuccessfully());
// Sentinel = 'workerScriptExecutedSuccessfully'
(aWriter)->WriteSentinel(3669167436);
IPC::WriteParam(aWriter, (aVar).fetchHandlerWasAdded());
// Sentinel = 'fetchHandlerWasAdded'
(aWriter)->WriteSentinel(1382680518);
}
auto ParamTraits<::mozilla::dom::ServiceWorkerCheckScriptEvaluationOpResult>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___workerScriptExecutedSuccessfully = IPC::ReadParam<bool>(aReader);
if (!maybe___workerScriptExecutedSuccessfully) {
aReader->FatalError("Error deserializing 'workerScriptExecutedSuccessfully' (bool) member of 'ServiceWorkerCheckScriptEvaluationOpResult'");
return {};
}
auto& _workerScriptExecutedSuccessfully = *maybe___workerScriptExecutedSuccessfully;
// Sentinel = 'workerScriptExecutedSuccessfully'
if ((!((aReader)->ReadSentinel(3669167436)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'workerScriptExecutedSuccessfully' (bool) member of 'ServiceWorkerCheckScriptEvaluationOpResult'");
return {};
}
auto maybe___fetchHandlerWasAdded = IPC::ReadParam<bool>(aReader);
if (!maybe___fetchHandlerWasAdded) {
aReader->FatalError("Error deserializing 'fetchHandlerWasAdded' (bool) member of 'ServiceWorkerCheckScriptEvaluationOpResult'");
return {};
}
auto& _fetchHandlerWasAdded = *maybe___fetchHandlerWasAdded;
// Sentinel = 'fetchHandlerWasAdded'
if ((!((aReader)->ReadSentinel(1382680518)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'fetchHandlerWasAdded' (bool) member of 'ServiceWorkerCheckScriptEvaluationOpResult'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_workerScriptExecutedSuccessfully),
std::move(_fetchHandlerWasAdded)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct ServiceWorkerFetchEventOpResult|
//
namespace mozilla {
namespace dom {
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::ServiceWorkerFetchEventOpResult>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).rv());
// Sentinel = 'rv'
(aWriter)->WriteSentinel(22806761);
}
auto ParamTraits<::mozilla::dom::ServiceWorkerFetchEventOpResult>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___rv = IPC::ReadParam<::nsresult>(aReader);
if (!maybe___rv) {
aReader->FatalError("Error deserializing 'rv' (nsresult) member of 'ServiceWorkerFetchEventOpResult'");
return {};
}
auto& _rv = *maybe___rv;
// Sentinel = 'rv'
if ((!((aReader)->ReadSentinel(22806761)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'rv' (nsresult) member of 'ServiceWorkerFetchEventOpResult'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_rv)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct ServiceWorkerExtensionAPIEventOpResult|
//
namespace mozilla {
namespace dom {
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::ServiceWorkerExtensionAPIEventOpResult>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).extensionAPIEventListenerWasAdded());
// Sentinel = 'extensionAPIEventListenerWasAdded'
(aWriter)->WriteSentinel(3745910013);
}
auto ParamTraits<::mozilla::dom::ServiceWorkerExtensionAPIEventOpResult>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___extensionAPIEventListenerWasAdded = IPC::ReadParam<bool>(aReader);
if (!maybe___extensionAPIEventListenerWasAdded) {
aReader->FatalError("Error deserializing 'extensionAPIEventListenerWasAdded' (bool) member of 'ServiceWorkerExtensionAPIEventOpResult'");
return {};
}
auto& _extensionAPIEventListenerWasAdded = *maybe___extensionAPIEventListenerWasAdded;
// Sentinel = 'extensionAPIEventListenerWasAdded'
if ((!((aReader)->ReadSentinel(3745910013)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'extensionAPIEventListenerWasAdded' (bool) member of 'ServiceWorkerExtensionAPIEventOpResult'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_extensionAPIEventListenerWasAdded)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |union ServiceWorkerOpResult|
//
namespace mozilla {
namespace dom {
auto ServiceWorkerOpResult::MaybeDestroy() -> void
{
if ((mType) == (T__None)) {
return;
}
switch (mType) {
case Tnsresult:
{
(ptr_nsresult())->~nsresult__tdef();
break;
}
case TServiceWorkerCheckScriptEvaluationOpResult:
{
(ptr_ServiceWorkerCheckScriptEvaluationOpResult())->~ServiceWorkerCheckScriptEvaluationOpResult__tdef();
break;
}
case TServiceWorkerFetchEventOpResult:
{
(ptr_ServiceWorkerFetchEventOpResult())->~ServiceWorkerFetchEventOpResult__tdef();
break;
}
case TServiceWorkerExtensionAPIEventOpResult:
{
(ptr_ServiceWorkerExtensionAPIEventOpResult())->~ServiceWorkerExtensionAPIEventOpResult__tdef();
break;
}
default:
{
mozilla::ipc::LogicError("not reached");
break;
}
}
}
MOZ_IMPLICIT ServiceWorkerOpResult::ServiceWorkerOpResult(const nsresult& aOther)
{
new (mozilla::KnownNotNull, ptr_nsresult()) nsresult(aOther);
mType = Tnsresult;
}
MOZ_IMPLICIT ServiceWorkerOpResult::ServiceWorkerOpResult(nsresult&& aOther)
{
new (mozilla::KnownNotNull, ptr_nsresult()) nsresult(std::move(aOther));
mType = Tnsresult;
}
MOZ_IMPLICIT ServiceWorkerOpResult::ServiceWorkerOpResult(const ServiceWorkerCheckScriptEvaluationOpResult& aOther)
{
new (mozilla::KnownNotNull, ptr_ServiceWorkerCheckScriptEvaluationOpResult()) ServiceWorkerCheckScriptEvaluationOpResult(aOther);
mType = TServiceWorkerCheckScriptEvaluationOpResult;
}
MOZ_IMPLICIT ServiceWorkerOpResult::ServiceWorkerOpResult(ServiceWorkerCheckScriptEvaluationOpResult&& aOther)
{
new (mozilla::KnownNotNull, ptr_ServiceWorkerCheckScriptEvaluationOpResult()) ServiceWorkerCheckScriptEvaluationOpResult(std::move(aOther));
mType = TServiceWorkerCheckScriptEvaluationOpResult;
}
MOZ_IMPLICIT ServiceWorkerOpResult::ServiceWorkerOpResult(const ServiceWorkerFetchEventOpResult& aOther)
{
new (mozilla::KnownNotNull, ptr_ServiceWorkerFetchEventOpResult()) ServiceWorkerFetchEventOpResult(aOther);
mType = TServiceWorkerFetchEventOpResult;
}
MOZ_IMPLICIT ServiceWorkerOpResult::ServiceWorkerOpResult(ServiceWorkerFetchEventOpResult&& aOther)
{
new (mozilla::KnownNotNull, ptr_ServiceWorkerFetchEventOpResult()) ServiceWorkerFetchEventOpResult(std::move(aOther));
mType = TServiceWorkerFetchEventOpResult;
}
MOZ_IMPLICIT ServiceWorkerOpResult::ServiceWorkerOpResult(const ServiceWorkerExtensionAPIEventOpResult& aOther)
{
new (mozilla::KnownNotNull, ptr_ServiceWorkerExtensionAPIEventOpResult()) ServiceWorkerExtensionAPIEventOpResult(aOther);
mType = TServiceWorkerExtensionAPIEventOpResult;
}
MOZ_IMPLICIT ServiceWorkerOpResult::ServiceWorkerOpResult(ServiceWorkerExtensionAPIEventOpResult&& aOther)
{
new (mozilla::KnownNotNull, ptr_ServiceWorkerExtensionAPIEventOpResult()) ServiceWorkerExtensionAPIEventOpResult(std::move(aOther));
mType = TServiceWorkerExtensionAPIEventOpResult;
}
MOZ_IMPLICIT ServiceWorkerOpResult::ServiceWorkerOpResult(const ServiceWorkerOpResult& aOther)
{
(aOther).AssertSanity();
switch ((aOther).type()) {
case Tnsresult:
{
new (mozilla::KnownNotNull, ptr_nsresult()) nsresult((aOther).get_nsresult());
break;
}
case TServiceWorkerCheckScriptEvaluationOpResult:
{
new (mozilla::KnownNotNull, ptr_ServiceWorkerCheckScriptEvaluationOpResult()) ServiceWorkerCheckScriptEvaluationOpResult((aOther).get_ServiceWorkerCheckScriptEvaluationOpResult());
break;
}
case TServiceWorkerFetchEventOpResult:
{
new (mozilla::KnownNotNull, ptr_ServiceWorkerFetchEventOpResult()) ServiceWorkerFetchEventOpResult((aOther).get_ServiceWorkerFetchEventOpResult());
break;
}
case TServiceWorkerExtensionAPIEventOpResult:
{
new (mozilla::KnownNotNull, ptr_ServiceWorkerExtensionAPIEventOpResult()) ServiceWorkerExtensionAPIEventOpResult((aOther).get_ServiceWorkerExtensionAPIEventOpResult());
break;
}
case T__None:
{
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
return;
}
}
mType = (aOther).type();
}
MOZ_IMPLICIT ServiceWorkerOpResult::ServiceWorkerOpResult(ServiceWorkerOpResult&& 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 TServiceWorkerCheckScriptEvaluationOpResult:
{
new (mozilla::KnownNotNull, ptr_ServiceWorkerCheckScriptEvaluationOpResult()) ServiceWorkerCheckScriptEvaluationOpResult(std::move((aOther).get_ServiceWorkerCheckScriptEvaluationOpResult()));
(aOther).MaybeDestroy();
break;
}
case TServiceWorkerFetchEventOpResult:
{
new (mozilla::KnownNotNull, ptr_ServiceWorkerFetchEventOpResult()) ServiceWorkerFetchEventOpResult(std::move((aOther).get_ServiceWorkerFetchEventOpResult()));
(aOther).MaybeDestroy();
break;
}
case TServiceWorkerExtensionAPIEventOpResult:
{
new (mozilla::KnownNotNull, ptr_ServiceWorkerExtensionAPIEventOpResult()) ServiceWorkerExtensionAPIEventOpResult(std::move((aOther).get_ServiceWorkerExtensionAPIEventOpResult()));
(aOther).MaybeDestroy();
break;
}
case T__None:
{
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
return;
}
}
(aOther).mType = T__None;
mType = t;
}
ServiceWorkerOpResult::~ServiceWorkerOpResult()
{
MaybeDestroy();
}
auto ServiceWorkerOpResult::operator=(const nsresult& aRhs) -> ServiceWorkerOpResult&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_nsresult()) nsresult(aRhs);
mType = Tnsresult;
return (*(this));
}
auto ServiceWorkerOpResult::operator=(nsresult&& aRhs) -> ServiceWorkerOpResult&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_nsresult()) nsresult(std::move(aRhs));
mType = Tnsresult;
return (*(this));
}
auto ServiceWorkerOpResult::operator=(const ServiceWorkerCheckScriptEvaluationOpResult& aRhs) -> ServiceWorkerOpResult&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_ServiceWorkerCheckScriptEvaluationOpResult()) ServiceWorkerCheckScriptEvaluationOpResult(aRhs);
mType = TServiceWorkerCheckScriptEvaluationOpResult;
return (*(this));
}
auto ServiceWorkerOpResult::operator=(ServiceWorkerCheckScriptEvaluationOpResult&& aRhs) -> ServiceWorkerOpResult&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_ServiceWorkerCheckScriptEvaluationOpResult()) ServiceWorkerCheckScriptEvaluationOpResult(std::move(aRhs));
mType = TServiceWorkerCheckScriptEvaluationOpResult;
return (*(this));
}
auto ServiceWorkerOpResult::operator=(const ServiceWorkerFetchEventOpResult& aRhs) -> ServiceWorkerOpResult&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_ServiceWorkerFetchEventOpResult()) ServiceWorkerFetchEventOpResult(aRhs);
mType = TServiceWorkerFetchEventOpResult;
return (*(this));
}
auto ServiceWorkerOpResult::operator=(ServiceWorkerFetchEventOpResult&& aRhs) -> ServiceWorkerOpResult&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_ServiceWorkerFetchEventOpResult()) ServiceWorkerFetchEventOpResult(std::move(aRhs));
mType = TServiceWorkerFetchEventOpResult;
return (*(this));
}
auto ServiceWorkerOpResult::operator=(const ServiceWorkerExtensionAPIEventOpResult& aRhs) -> ServiceWorkerOpResult&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_ServiceWorkerExtensionAPIEventOpResult()) ServiceWorkerExtensionAPIEventOpResult(aRhs);
mType = TServiceWorkerExtensionAPIEventOpResult;
return (*(this));
}
auto ServiceWorkerOpResult::operator=(ServiceWorkerExtensionAPIEventOpResult&& aRhs) -> ServiceWorkerOpResult&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_ServiceWorkerExtensionAPIEventOpResult()) ServiceWorkerExtensionAPIEventOpResult(std::move(aRhs));
mType = TServiceWorkerExtensionAPIEventOpResult;
return (*(this));
}
auto ServiceWorkerOpResult::operator=(const ServiceWorkerOpResult& aRhs) -> ServiceWorkerOpResult&
{
(aRhs).AssertSanity();
Type t = (aRhs).type();
switch (t) {
case Tnsresult:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_nsresult()) nsresult((aRhs).get_nsresult());
break;
}
case TServiceWorkerCheckScriptEvaluationOpResult:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_ServiceWorkerCheckScriptEvaluationOpResult()) ServiceWorkerCheckScriptEvaluationOpResult((aRhs).get_ServiceWorkerCheckScriptEvaluationOpResult());
break;
}
case TServiceWorkerFetchEventOpResult:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_ServiceWorkerFetchEventOpResult()) ServiceWorkerFetchEventOpResult((aRhs).get_ServiceWorkerFetchEventOpResult());
break;
}
case TServiceWorkerExtensionAPIEventOpResult:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_ServiceWorkerExtensionAPIEventOpResult()) ServiceWorkerExtensionAPIEventOpResult((aRhs).get_ServiceWorkerExtensionAPIEventOpResult());
break;
}
case T__None:
{
MaybeDestroy();
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
break;
}
}
mType = t;
return (*(this));
}
auto ServiceWorkerOpResult::operator=(ServiceWorkerOpResult&& aRhs) -> ServiceWorkerOpResult&
{
(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 TServiceWorkerCheckScriptEvaluationOpResult:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_ServiceWorkerCheckScriptEvaluationOpResult()) ServiceWorkerCheckScriptEvaluationOpResult(std::move((aRhs).get_ServiceWorkerCheckScriptEvaluationOpResult()));
(aRhs).MaybeDestroy();
break;
}
case TServiceWorkerFetchEventOpResult:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_ServiceWorkerFetchEventOpResult()) ServiceWorkerFetchEventOpResult(std::move((aRhs).get_ServiceWorkerFetchEventOpResult()));
(aRhs).MaybeDestroy();
break;
}
case TServiceWorkerExtensionAPIEventOpResult:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_ServiceWorkerExtensionAPIEventOpResult()) ServiceWorkerExtensionAPIEventOpResult(std::move((aRhs).get_ServiceWorkerExtensionAPIEventOpResult()));
(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::ServiceWorkerOpResult>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
typedef ::mozilla::dom::ServiceWorkerOpResult union__;
int type = (aVar).type();
IPC::WriteParam(aWriter, type);
// Sentinel = 'ServiceWorkerOpResult'
(aWriter)->WriteSentinel(1556875402);
switch (type) {
case union__::Tnsresult:
{
IPC::WriteParam(aWriter, (aVar).get_nsresult());
// Sentinel = 'Tnsresult'
(aWriter)->WriteSentinel(313394133);
return;
}
case union__::TServiceWorkerCheckScriptEvaluationOpResult:
{
IPC::WriteParam(aWriter, (aVar).get_ServiceWorkerCheckScriptEvaluationOpResult());
// Sentinel = 'TServiceWorkerCheckScriptEvaluationOpResult'
(aWriter)->WriteSentinel(2001932617);
return;
}
case union__::TServiceWorkerFetchEventOpResult:
{
IPC::WriteParam(aWriter, (aVar).get_ServiceWorkerFetchEventOpResult());
// Sentinel = 'TServiceWorkerFetchEventOpResult'
(aWriter)->WriteSentinel(3496152266);
return;
}
case union__::TServiceWorkerExtensionAPIEventOpResult:
{
IPC::WriteParam(aWriter, (aVar).get_ServiceWorkerExtensionAPIEventOpResult());
// Sentinel = 'TServiceWorkerExtensionAPIEventOpResult'
(aWriter)->WriteSentinel(875695991);
return;
}
default:
{
aWriter->FatalError("unknown variant of union ServiceWorkerOpResult");
return;
}
}
}
auto ParamTraits<::mozilla::dom::ServiceWorkerOpResult>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
typedef ::mozilla::dom::ServiceWorkerOpResult union__;
auto maybe__type = IPC::ReadParam<int>(aReader);
if (!maybe__type) {
aReader->FatalError("Error deserializing type of union ServiceWorkerOpResult");
return {};
}
auto& type = *maybe__type;
// Sentinel = 'ServiceWorkerOpResult'
if ((!((aReader)->ReadSentinel(1556875402)))) {
mozilla::ipc::SentinelReadError("Error deserializing type of union ServiceWorkerOpResult");
return {};
}
switch (type) {
case union__::Tnsresult:
{
auto maybe__tmp = IPC::ReadParam<::nsresult>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant Tnsresult of union ServiceWorkerOpResult");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'Tnsresult'
if ((!((aReader)->ReadSentinel(313394133)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant Tnsresult of union ServiceWorkerOpResult");
return {};
}
return std::move(tmp);
}
case union__::TServiceWorkerCheckScriptEvaluationOpResult:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::dom::ServiceWorkerCheckScriptEvaluationOpResult>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TServiceWorkerCheckScriptEvaluationOpResult of union ServiceWorkerOpResult");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TServiceWorkerCheckScriptEvaluationOpResult'
if ((!((aReader)->ReadSentinel(2001932617)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TServiceWorkerCheckScriptEvaluationOpResult of union ServiceWorkerOpResult");
return {};
}
return std::move(tmp);
}
case union__::TServiceWorkerFetchEventOpResult:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::dom::ServiceWorkerFetchEventOpResult>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TServiceWorkerFetchEventOpResult of union ServiceWorkerOpResult");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TServiceWorkerFetchEventOpResult'
if ((!((aReader)->ReadSentinel(3496152266)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TServiceWorkerFetchEventOpResult of union ServiceWorkerOpResult");
return {};
}
return std::move(tmp);
}
case union__::TServiceWorkerExtensionAPIEventOpResult:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::dom::ServiceWorkerExtensionAPIEventOpResult>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TServiceWorkerExtensionAPIEventOpResult of union ServiceWorkerOpResult");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TServiceWorkerExtensionAPIEventOpResult'
if ((!((aReader)->ReadSentinel(875695991)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TServiceWorkerExtensionAPIEventOpResult of union ServiceWorkerOpResult");
return {};
}
return std::move(tmp);
}
default:
{
aReader->FatalError("unknown variant of union ServiceWorkerOpResult");
return {};
}
}
}
} // namespace IPC