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

Copy as Markdown

Other Tools

//
// Automatically generated by ipdlc.
// Edit at your own risk
//
#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/DOMTypes.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 MessagePortIdentifier|
//
namespace mozilla {
namespace dom {
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::MessagePortIdentifier>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).uuid());
// Sentinel = 'uuid'
(aWriter)->WriteSentinel(74252728);
IPC::WriteParam(aWriter, (aVar).destinationUuid());
// Sentinel = 'destinationUuid'
(aWriter)->WriteSentinel(840435258);
IPC::WriteParam(aWriter, (aVar).neutered());
// Sentinel = 'neutered'
(aWriter)->WriteSentinel(257229661);
(aWriter)->WriteBytes((&((aVar).sequenceId())), 4);
// Sentinel = 'sequenceId'
(aWriter)->WriteSentinel(386204679);
}
auto ParamTraits<::mozilla::dom::MessagePortIdentifier>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___uuid = IPC::ReadParam<::nsID>(aReader);
if (!maybe___uuid) {
aReader->FatalError("Error deserializing 'uuid' (nsID) member of 'MessagePortIdentifier'");
return {};
}
auto& _uuid = *maybe___uuid;
// Sentinel = 'uuid'
if ((!((aReader)->ReadSentinel(74252728)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uuid' (nsID) member of 'MessagePortIdentifier'");
return {};
}
auto maybe___destinationUuid = IPC::ReadParam<::nsID>(aReader);
if (!maybe___destinationUuid) {
aReader->FatalError("Error deserializing 'destinationUuid' (nsID) member of 'MessagePortIdentifier'");
return {};
}
auto& _destinationUuid = *maybe___destinationUuid;
// Sentinel = 'destinationUuid'
if ((!((aReader)->ReadSentinel(840435258)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'destinationUuid' (nsID) member of 'MessagePortIdentifier'");
return {};
}
auto maybe___neutered = IPC::ReadParam<bool>(aReader);
if (!maybe___neutered) {
aReader->FatalError("Error deserializing 'neutered' (bool) member of 'MessagePortIdentifier'");
return {};
}
auto& _neutered = *maybe___neutered;
// Sentinel = 'neutered'
if ((!((aReader)->ReadSentinel(257229661)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'neutered' (bool) member of 'MessagePortIdentifier'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_uuid),
std::move(_destinationUuid),
::uint32_t{0},
std::move(_neutered)};
if ((!((aReader)->ReadBytesInto((&((result__)->sequenceId())), 4)))) {
aReader->FatalError("Error bulk reading fields from uint32_t");
return {};
}
// Sentinel = 'sequenceId'
if ((!((aReader)->ReadSentinel(386204679)))) {
mozilla::ipc::SentinelReadError("Error bulk reading fields from uint32_t");
return {};
}
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct ClonedMessageData|
//
namespace mozilla {
namespace dom {
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::ClonedMessageData>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).data());
// Sentinel = 'data'
(aWriter)->WriteSentinel(67109275);
IPC::WriteParam(aWriter, (aVar).blobs());
// Sentinel = 'blobs'
(aWriter)->WriteSentinel(102957587);
IPC::WriteParam(aWriter, (aVar).inputStreams());
// Sentinel = 'inputStreams'
(aWriter)->WriteSentinel(554304784);
IPC::WriteParam(aWriter, (aVar).identifiers());
// Sentinel = 'identifiers'
(aWriter)->WriteSentinel(456983703);
}
auto ParamTraits<::mozilla::dom::ClonedMessageData>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___data = IPC::ReadParam<::mozilla::SerializedStructuredCloneBuffer>(aReader);
if (!maybe___data) {
aReader->FatalError("Error deserializing 'data' (SerializedStructuredCloneBuffer) member of 'ClonedMessageData'");
return {};
}
auto& _data = *maybe___data;
// Sentinel = 'data'
if ((!((aReader)->ReadSentinel(67109275)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'data' (SerializedStructuredCloneBuffer) member of 'ClonedMessageData'");
return {};
}
auto maybe___blobs = IPC::ReadParam<nsTArray<::mozilla::dom::IPCBlob>>(aReader);
if (!maybe___blobs) {
aReader->FatalError("Error deserializing 'blobs' (IPCBlob[]) member of 'ClonedMessageData'");
return {};
}
auto& _blobs = *maybe___blobs;
// Sentinel = 'blobs'
if ((!((aReader)->ReadSentinel(102957587)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'blobs' (IPCBlob[]) member of 'ClonedMessageData'");
return {};
}
auto maybe___inputStreams = IPC::ReadParam<nsTArray<::mozilla::ipc::IPCStream>>(aReader);
if (!maybe___inputStreams) {
aReader->FatalError("Error deserializing 'inputStreams' (IPCStream[]) member of 'ClonedMessageData'");
return {};
}
auto& _inputStreams = *maybe___inputStreams;
// Sentinel = 'inputStreams'
if ((!((aReader)->ReadSentinel(554304784)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'inputStreams' (IPCStream[]) member of 'ClonedMessageData'");
return {};
}
auto maybe___identifiers = IPC::ReadParam<nsTArray<::mozilla::dom::MessagePortIdentifier>>(aReader);
if (!maybe___identifiers) {
aReader->FatalError("Error deserializing 'identifiers' (MessagePortIdentifier[]) member of 'ClonedMessageData'");
return {};
}
auto& _identifiers = *maybe___identifiers;
// Sentinel = 'identifiers'
if ((!((aReader)->ReadSentinel(456983703)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'identifiers' (MessagePortIdentifier[]) member of 'ClonedMessageData'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_data),
std::move(_blobs),
std::move(_inputStreams),
std::move(_identifiers)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct ErrorMessageData|
//
namespace mozilla {
namespace dom {
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::ErrorMessageData>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
}
auto ParamTraits<::mozilla::dom::ErrorMessageData>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
IPC::ReadResult<paramType> result__{std::in_place};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |union ClonedOrErrorMessageData|
//
namespace mozilla {
namespace dom {
auto ClonedOrErrorMessageData::MaybeDestroy() -> void
{
if ((mType) == (T__None)) {
return;
}
switch (mType) {
case TClonedMessageData:
{
(ptr_ClonedMessageData())->~ClonedMessageData__tdef();
break;
}
case TErrorMessageData:
{
(ptr_ErrorMessageData())->~ErrorMessageData__tdef();
break;
}
default:
{
mozilla::ipc::LogicError("not reached");
break;
}
}
}
MOZ_IMPLICIT ClonedOrErrorMessageData::ClonedOrErrorMessageData(ClonedMessageData&& aOther)
{
new (mozilla::KnownNotNull, ptr_ClonedMessageData()) ClonedMessageData(std::move(aOther));
mType = TClonedMessageData;
}
MOZ_IMPLICIT ClonedOrErrorMessageData::ClonedOrErrorMessageData(const ErrorMessageData& aOther)
{
new (mozilla::KnownNotNull, ptr_ErrorMessageData()) ErrorMessageData(aOther);
mType = TErrorMessageData;
}
MOZ_IMPLICIT ClonedOrErrorMessageData::ClonedOrErrorMessageData(ErrorMessageData&& aOther)
{
new (mozilla::KnownNotNull, ptr_ErrorMessageData()) ErrorMessageData(std::move(aOther));
mType = TErrorMessageData;
}
MOZ_IMPLICIT ClonedOrErrorMessageData::ClonedOrErrorMessageData(ClonedOrErrorMessageData&& aOther)
{
(aOther).AssertSanity();
Type t = (aOther).type();
switch (t) {
case TClonedMessageData:
{
new (mozilla::KnownNotNull, ptr_ClonedMessageData()) ClonedMessageData(std::move((aOther).get_ClonedMessageData()));
(aOther).MaybeDestroy();
break;
}
case TErrorMessageData:
{
new (mozilla::KnownNotNull, ptr_ErrorMessageData()) ErrorMessageData(std::move((aOther).get_ErrorMessageData()));
(aOther).MaybeDestroy();
break;
}
case T__None:
{
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
return;
}
}
(aOther).mType = T__None;
mType = t;
}
ClonedOrErrorMessageData::~ClonedOrErrorMessageData()
{
MaybeDestroy();
}
auto ClonedOrErrorMessageData::operator=(ClonedMessageData&& aRhs) -> ClonedOrErrorMessageData&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_ClonedMessageData()) ClonedMessageData(std::move(aRhs));
mType = TClonedMessageData;
return (*(this));
}
auto ClonedOrErrorMessageData::operator=(const ErrorMessageData& aRhs) -> ClonedOrErrorMessageData&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_ErrorMessageData()) ErrorMessageData(aRhs);
mType = TErrorMessageData;
return (*(this));
}
auto ClonedOrErrorMessageData::operator=(ErrorMessageData&& aRhs) -> ClonedOrErrorMessageData&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_ErrorMessageData()) ErrorMessageData(std::move(aRhs));
mType = TErrorMessageData;
return (*(this));
}
auto ClonedOrErrorMessageData::operator=(ClonedOrErrorMessageData&& aRhs) -> ClonedOrErrorMessageData&
{
(aRhs).AssertSanity();
Type t = (aRhs).type();
switch (t) {
case TClonedMessageData:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_ClonedMessageData()) ClonedMessageData(std::move((aRhs).get_ClonedMessageData()));
(aRhs).MaybeDestroy();
break;
}
case TErrorMessageData:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_ErrorMessageData()) ErrorMessageData(std::move((aRhs).get_ErrorMessageData()));
(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::ClonedOrErrorMessageData>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
typedef ::mozilla::dom::ClonedOrErrorMessageData union__;
int type = (aVar).type();
IPC::WriteParam(aWriter, type);
// Sentinel = 'ClonedOrErrorMessageData'
(aWriter)->WriteSentinel(1957890400);
switch (type) {
case union__::TClonedMessageData:
{
IPC::WriteParam(aWriter, (aVar).get_ClonedMessageData());
// Sentinel = 'TClonedMessageData'
(aWriter)->WriteSentinel(1089275625);
return;
}
case union__::TErrorMessageData:
{
IPC::WriteParam(aWriter, (aVar).get_ErrorMessageData());
// Sentinel = 'TErrorMessageData'
(aWriter)->WriteSentinel(994313886);
return;
}
default:
{
aWriter->FatalError("unknown variant of union ClonedOrErrorMessageData");
return;
}
}
}
auto ParamTraits<::mozilla::dom::ClonedOrErrorMessageData>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
typedef ::mozilla::dom::ClonedOrErrorMessageData union__;
auto maybe__type = IPC::ReadParam<int>(aReader);
if (!maybe__type) {
aReader->FatalError("Error deserializing type of union ClonedOrErrorMessageData");
return {};
}
auto& type = *maybe__type;
// Sentinel = 'ClonedOrErrorMessageData'
if ((!((aReader)->ReadSentinel(1957890400)))) {
mozilla::ipc::SentinelReadError("Error deserializing type of union ClonedOrErrorMessageData");
return {};
}
switch (type) {
case union__::TClonedMessageData:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::dom::ClonedMessageData>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TClonedMessageData of union ClonedOrErrorMessageData");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TClonedMessageData'
if ((!((aReader)->ReadSentinel(1089275625)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TClonedMessageData of union ClonedOrErrorMessageData");
return {};
}
return std::move(tmp);
}
case union__::TErrorMessageData:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::dom::ErrorMessageData>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TErrorMessageData of union ClonedOrErrorMessageData");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TErrorMessageData'
if ((!((aReader)->ReadSentinel(994313886)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TErrorMessageData of union ClonedOrErrorMessageData");
return {};
}
return std::move(tmp);
}
default:
{
aReader->FatalError("unknown variant of union ClonedOrErrorMessageData");
return {};
}
}
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct RefMessageData|
//
namespace mozilla {
namespace dom {
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::RefMessageData>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).uuid());
// Sentinel = 'uuid'
(aWriter)->WriteSentinel(74252728);
}
auto ParamTraits<::mozilla::dom::RefMessageData>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___uuid = IPC::ReadParam<::nsID>(aReader);
if (!maybe___uuid) {
aReader->FatalError("Error deserializing 'uuid' (nsID) member of 'RefMessageData'");
return {};
}
auto& _uuid = *maybe___uuid;
// Sentinel = 'uuid'
if ((!((aReader)->ReadSentinel(74252728)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uuid' (nsID) member of 'RefMessageData'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_uuid)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |union MessageDataType|
//
namespace mozilla {
namespace dom {
auto MessageDataType::MaybeDestroy() -> void
{
if ((mType) == (T__None)) {
return;
}
switch (mType) {
case TClonedMessageData:
{
(ptr_ClonedMessageData())->~ClonedMessageData__tdef();
break;
}
case TRefMessageData:
{
(ptr_RefMessageData())->~RefMessageData__tdef();
break;
}
default:
{
mozilla::ipc::LogicError("not reached");
break;
}
}
}
MOZ_IMPLICIT MessageDataType::MessageDataType(ClonedMessageData&& aOther)
{
new (mozilla::KnownNotNull, ptr_ClonedMessageData()) ClonedMessageData(std::move(aOther));
mType = TClonedMessageData;
}
MOZ_IMPLICIT MessageDataType::MessageDataType(const RefMessageData& aOther)
{
new (mozilla::KnownNotNull, ptr_RefMessageData()) RefMessageData(aOther);
mType = TRefMessageData;
}
MOZ_IMPLICIT MessageDataType::MessageDataType(RefMessageData&& aOther)
{
new (mozilla::KnownNotNull, ptr_RefMessageData()) RefMessageData(std::move(aOther));
mType = TRefMessageData;
}
MOZ_IMPLICIT MessageDataType::MessageDataType(MessageDataType&& aOther)
{
(aOther).AssertSanity();
Type t = (aOther).type();
switch (t) {
case TClonedMessageData:
{
new (mozilla::KnownNotNull, ptr_ClonedMessageData()) ClonedMessageData(std::move((aOther).get_ClonedMessageData()));
(aOther).MaybeDestroy();
break;
}
case TRefMessageData:
{
new (mozilla::KnownNotNull, ptr_RefMessageData()) RefMessageData(std::move((aOther).get_RefMessageData()));
(aOther).MaybeDestroy();
break;
}
case T__None:
{
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
return;
}
}
(aOther).mType = T__None;
mType = t;
}
MessageDataType::~MessageDataType()
{
MaybeDestroy();
}
auto MessageDataType::operator=(ClonedMessageData&& aRhs) -> MessageDataType&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_ClonedMessageData()) ClonedMessageData(std::move(aRhs));
mType = TClonedMessageData;
return (*(this));
}
auto MessageDataType::operator=(const RefMessageData& aRhs) -> MessageDataType&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_RefMessageData()) RefMessageData(aRhs);
mType = TRefMessageData;
return (*(this));
}
auto MessageDataType::operator=(RefMessageData&& aRhs) -> MessageDataType&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_RefMessageData()) RefMessageData(std::move(aRhs));
mType = TRefMessageData;
return (*(this));
}
auto MessageDataType::operator=(MessageDataType&& aRhs) -> MessageDataType&
{
(aRhs).AssertSanity();
Type t = (aRhs).type();
switch (t) {
case TClonedMessageData:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_ClonedMessageData()) ClonedMessageData(std::move((aRhs).get_ClonedMessageData()));
(aRhs).MaybeDestroy();
break;
}
case TRefMessageData:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_RefMessageData()) RefMessageData(std::move((aRhs).get_RefMessageData()));
(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::MessageDataType>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
typedef ::mozilla::dom::MessageDataType union__;
int type = (aVar).type();
IPC::WriteParam(aWriter, type);
// Sentinel = 'MessageDataType'
(aWriter)->WriteSentinel(779421154);
switch (type) {
case union__::TClonedMessageData:
{
IPC::WriteParam(aWriter, (aVar).get_ClonedMessageData());
// Sentinel = 'TClonedMessageData'
(aWriter)->WriteSentinel(1089275625);
return;
}
case union__::TRefMessageData:
{
IPC::WriteParam(aWriter, (aVar).get_RefMessageData());
// Sentinel = 'TRefMessageData'
(aWriter)->WriteSentinel(751437233);
return;
}
default:
{
aWriter->FatalError("unknown variant of union MessageDataType");
return;
}
}
}
auto ParamTraits<::mozilla::dom::MessageDataType>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
typedef ::mozilla::dom::MessageDataType union__;
auto maybe__type = IPC::ReadParam<int>(aReader);
if (!maybe__type) {
aReader->FatalError("Error deserializing type of union MessageDataType");
return {};
}
auto& type = *maybe__type;
// Sentinel = 'MessageDataType'
if ((!((aReader)->ReadSentinel(779421154)))) {
mozilla::ipc::SentinelReadError("Error deserializing type of union MessageDataType");
return {};
}
switch (type) {
case union__::TClonedMessageData:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::dom::ClonedMessageData>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TClonedMessageData of union MessageDataType");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TClonedMessageData'
if ((!((aReader)->ReadSentinel(1089275625)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TClonedMessageData of union MessageDataType");
return {};
}
return std::move(tmp);
}
case union__::TRefMessageData:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::dom::RefMessageData>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TRefMessageData of union MessageDataType");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TRefMessageData'
if ((!((aReader)->ReadSentinel(751437233)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TRefMessageData of union MessageDataType");
return {};
}
return std::move(tmp);
}
default:
{
aReader->FatalError("unknown variant of union MessageDataType");
return {};
}
}
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct MessageData|
//
namespace mozilla {
namespace dom {
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::MessageData>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).agentClusterId());
// Sentinel = 'agentClusterId'
(aWriter)->WriteSentinel(710477215);
IPC::WriteParam(aWriter, (aVar).data());
// Sentinel = 'data'
(aWriter)->WriteSentinel(67109275);
}
auto ParamTraits<::mozilla::dom::MessageData>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___agentClusterId = IPC::ReadParam<mozilla::Maybe<::nsID>>(aReader);
if (!maybe___agentClusterId) {
aReader->FatalError("Error deserializing 'agentClusterId' (nsID?) member of 'MessageData'");
return {};
}
auto& _agentClusterId = *maybe___agentClusterId;
// Sentinel = 'agentClusterId'
if ((!((aReader)->ReadSentinel(710477215)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'agentClusterId' (nsID?) member of 'MessageData'");
return {};
}
auto maybe___data = IPC::ReadParam<::mozilla::dom::MessageDataType>(aReader);
if (!maybe___data) {
aReader->FatalError("Error deserializing 'data' (MessageDataType) member of 'MessageData'");
return {};
}
auto& _data = *maybe___data;
// Sentinel = 'data'
if ((!((aReader)->ReadSentinel(67109275)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'data' (MessageDataType) member of 'MessageData'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_agentClusterId),
std::move(_data)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct ScreenDetails|
//
namespace mozilla {
namespace dom {
auto ScreenDetails::StaticAssertions() const -> void
{
static_assert(
(offsetof(ScreenDetails, dpi_) - offsetof(ScreenDetails, pixelDepth_)) == 12,
"Bad assumptions about field layout!");
}
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::ScreenDetails>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).rect());
// Sentinel = 'rect'
(aWriter)->WriteSentinel(70582703);
IPC::WriteParam(aWriter, (aVar).rectDisplayPix());
// Sentinel = 'rectDisplayPix'
(aWriter)->WriteSentinel(714540470);
IPC::WriteParam(aWriter, (aVar).availRect());
// Sentinel = 'availRect'
(aWriter)->WriteSentinel(302777244);
IPC::WriteParam(aWriter, (aVar).availRectDisplayPix());
// Sentinel = 'availRectDisplayPix'
(aWriter)->WriteSentinel(1269827491);
IPC::WriteParam(aWriter, (aVar).contentsScaleFactor());
// Sentinel = 'contentsScaleFactor'
(aWriter)->WriteSentinel(1304102838);
IPC::WriteParam(aWriter, (aVar).defaultCSSScaleFactor());
// Sentinel = 'defaultCSSScaleFactor'
(aWriter)->WriteSentinel(1482885142);
IPC::WriteParam(aWriter, (aVar).orientation());
// Sentinel = 'orientation'
(aWriter)->WriteSentinel(471008429);
IPC::WriteParam(aWriter, (aVar).isPseudoDisplay());
// Sentinel = 'isPseudoDisplay'
(aWriter)->WriteSentinel(816383523);
IPC::WriteParam(aWriter, (aVar).isHDR());
// Sentinel = 'isHDR'
(aWriter)->WriteSentinel(93323707);
(aWriter)->WriteBytes((&((aVar).pixelDepth())), 16);
// Sentinel = 'pixelDepth | colorDepth | refreshRate | dpi'
(aWriter)->WriteSentinel(1735462936);
(aWriter)->WriteBytes((&((aVar).orientationAngle())), 2);
// Sentinel = 'orientationAngle'
(aWriter)->WriteSentinel(954402452);
}
auto ParamTraits<::mozilla::dom::ScreenDetails>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___rect = IPC::ReadParam<::mozilla::LayoutDeviceIntRect>(aReader);
if (!maybe___rect) {
aReader->FatalError("Error deserializing 'rect' (LayoutDeviceIntRect) member of 'ScreenDetails'");
return {};
}
auto& _rect = *maybe___rect;
// Sentinel = 'rect'
if ((!((aReader)->ReadSentinel(70582703)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'rect' (LayoutDeviceIntRect) member of 'ScreenDetails'");
return {};
}
auto maybe___rectDisplayPix = IPC::ReadParam<::mozilla::DesktopIntRect>(aReader);
if (!maybe___rectDisplayPix) {
aReader->FatalError("Error deserializing 'rectDisplayPix' (DesktopIntRect) member of 'ScreenDetails'");
return {};
}
auto& _rectDisplayPix = *maybe___rectDisplayPix;
// Sentinel = 'rectDisplayPix'
if ((!((aReader)->ReadSentinel(714540470)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'rectDisplayPix' (DesktopIntRect) member of 'ScreenDetails'");
return {};
}
auto maybe___availRect = IPC::ReadParam<::mozilla::LayoutDeviceIntRect>(aReader);
if (!maybe___availRect) {
aReader->FatalError("Error deserializing 'availRect' (LayoutDeviceIntRect) member of 'ScreenDetails'");
return {};
}
auto& _availRect = *maybe___availRect;
// Sentinel = 'availRect'
if ((!((aReader)->ReadSentinel(302777244)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'availRect' (LayoutDeviceIntRect) member of 'ScreenDetails'");
return {};
}
auto maybe___availRectDisplayPix = IPC::ReadParam<::mozilla::DesktopIntRect>(aReader);
if (!maybe___availRectDisplayPix) {
aReader->FatalError("Error deserializing 'availRectDisplayPix' (DesktopIntRect) member of 'ScreenDetails'");
return {};
}
auto& _availRectDisplayPix = *maybe___availRectDisplayPix;
// Sentinel = 'availRectDisplayPix'
if ((!((aReader)->ReadSentinel(1269827491)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'availRectDisplayPix' (DesktopIntRect) member of 'ScreenDetails'");
return {};
}
auto maybe___contentsScaleFactor = IPC::ReadParam<::mozilla::DesktopToLayoutDeviceScale>(aReader);
if (!maybe___contentsScaleFactor) {
aReader->FatalError("Error deserializing 'contentsScaleFactor' (DesktopToLayoutDeviceScale) member of 'ScreenDetails'");
return {};
}
auto& _contentsScaleFactor = *maybe___contentsScaleFactor;
// Sentinel = 'contentsScaleFactor'
if ((!((aReader)->ReadSentinel(1304102838)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'contentsScaleFactor' (DesktopToLayoutDeviceScale) member of 'ScreenDetails'");
return {};
}
auto maybe___defaultCSSScaleFactor = IPC::ReadParam<::mozilla::CSSToLayoutDeviceScale>(aReader);
if (!maybe___defaultCSSScaleFactor) {
aReader->FatalError("Error deserializing 'defaultCSSScaleFactor' (CSSToLayoutDeviceScale) member of 'ScreenDetails'");
return {};
}
auto& _defaultCSSScaleFactor = *maybe___defaultCSSScaleFactor;
// Sentinel = 'defaultCSSScaleFactor'
if ((!((aReader)->ReadSentinel(1482885142)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'defaultCSSScaleFactor' (CSSToLayoutDeviceScale) member of 'ScreenDetails'");
return {};
}
auto maybe___orientation = IPC::ReadParam<::mozilla::hal::ScreenOrientation>(aReader);
if (!maybe___orientation) {
aReader->FatalError("Error deserializing 'orientation' (ScreenOrientation) member of 'ScreenDetails'");
return {};
}
auto& _orientation = *maybe___orientation;
// Sentinel = 'orientation'
if ((!((aReader)->ReadSentinel(471008429)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'orientation' (ScreenOrientation) member of 'ScreenDetails'");
return {};
}
auto maybe___isPseudoDisplay = IPC::ReadParam<bool>(aReader);
if (!maybe___isPseudoDisplay) {
aReader->FatalError("Error deserializing 'isPseudoDisplay' (bool) member of 'ScreenDetails'");
return {};
}
auto& _isPseudoDisplay = *maybe___isPseudoDisplay;
// Sentinel = 'isPseudoDisplay'
if ((!((aReader)->ReadSentinel(816383523)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'isPseudoDisplay' (bool) member of 'ScreenDetails'");
return {};
}
auto maybe___isHDR = IPC::ReadParam<bool>(aReader);
if (!maybe___isHDR) {
aReader->FatalError("Error deserializing 'isHDR' (bool) member of 'ScreenDetails'");
return {};
}
auto& _isHDR = *maybe___isHDR;
// Sentinel = 'isHDR'
if ((!((aReader)->ReadSentinel(93323707)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'isHDR' (bool) member of 'ScreenDetails'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_rect),
std::move(_rectDisplayPix),
std::move(_availRect),
std::move(_availRectDisplayPix),
::int32_t{0},
::int32_t{0},
::uint32_t{0},
std::move(_contentsScaleFactor),
std::move(_defaultCSSScaleFactor),
float{0},
std::move(_orientation),
::uint16_t{0},
std::move(_isPseudoDisplay),
std::move(_isHDR)};
if ((!((aReader)->ReadBytesInto((&((result__)->pixelDepth())), 16)))) {
aReader->FatalError("Error bulk reading fields from int32_t");
return {};
}
// Sentinel = 'pixelDepth | colorDepth | refreshRate | dpi'
if ((!((aReader)->ReadSentinel(1735462936)))) {
mozilla::ipc::SentinelReadError("Error bulk reading fields from int32_t");
return {};
}
if ((!((aReader)->ReadBytesInto((&((result__)->orientationAngle())), 2)))) {
aReader->FatalError("Error bulk reading fields from uint16_t");
return {};
}
// Sentinel = 'orientationAngle'
if ((!((aReader)->ReadSentinel(954402452)))) {
mozilla::ipc::SentinelReadError("Error bulk reading fields from uint16_t");
return {};
}
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct DimensionInfo|
//
namespace mozilla {
namespace dom {
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::DimensionInfo>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).rect());
// Sentinel = 'rect'
(aWriter)->WriteSentinel(70582703);
IPC::WriteParam(aWriter, (aVar).size());
// Sentinel = 'size'
(aWriter)->WriteSentinel(73662908);
IPC::WriteParam(aWriter, (aVar).clientOffset());
// Sentinel = 'clientOffset'
(aWriter)->WriteSentinel(530449639);
IPC::WriteParam(aWriter, (aVar).chromeOffset());
// Sentinel = 'chromeOffset'
(aWriter)->WriteSentinel(531956966);
}
auto ParamTraits<::mozilla::dom::DimensionInfo>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___rect = IPC::ReadParam<::mozilla::CSSRect>(aReader);
if (!maybe___rect) {
aReader->FatalError("Error deserializing 'rect' (CSSRect) member of 'DimensionInfo'");
return {};
}
auto& _rect = *maybe___rect;
// Sentinel = 'rect'
if ((!((aReader)->ReadSentinel(70582703)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'rect' (CSSRect) member of 'DimensionInfo'");
return {};
}
auto maybe___size = IPC::ReadParam<::mozilla::CSSSize>(aReader);
if (!maybe___size) {
aReader->FatalError("Error deserializing 'size' (CSSSize) member of 'DimensionInfo'");
return {};
}
auto& _size = *maybe___size;
// Sentinel = 'size'
if ((!((aReader)->ReadSentinel(73662908)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'size' (CSSSize) member of 'DimensionInfo'");
return {};
}
auto maybe___clientOffset = IPC::ReadParam<::mozilla::LayoutDeviceIntPoint>(aReader);
if (!maybe___clientOffset) {
aReader->FatalError("Error deserializing 'clientOffset' (LayoutDeviceIntPoint) member of 'DimensionInfo'");
return {};
}
auto& _clientOffset = *maybe___clientOffset;
// Sentinel = 'clientOffset'
if ((!((aReader)->ReadSentinel(530449639)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'clientOffset' (LayoutDeviceIntPoint) member of 'DimensionInfo'");
return {};
}
auto maybe___chromeOffset = IPC::ReadParam<::mozilla::LayoutDeviceIntPoint>(aReader);
if (!maybe___chromeOffset) {
aReader->FatalError("Error deserializing 'chromeOffset' (LayoutDeviceIntPoint) member of 'DimensionInfo'");
return {};
}
auto& _chromeOffset = *maybe___chromeOffset;
// Sentinel = 'chromeOffset'
if ((!((aReader)->ReadSentinel(531956966)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'chromeOffset' (LayoutDeviceIntPoint) member of 'DimensionInfo'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_rect),
std::move(_size),
std::move(_clientOffset),
std::move(_chromeOffset)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct FrameScriptInfo|
//
namespace mozilla {
namespace dom {
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::FrameScriptInfo>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).url());
// Sentinel = 'url'
(aWriter)->WriteSentinel(45220180);
IPC::WriteParam(aWriter, (aVar).runInGlobalScope());
// Sentinel = 'runInGlobalScope'
(aWriter)->WriteSentinel(907282008);
}
auto ParamTraits<::mozilla::dom::FrameScriptInfo>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___url = IPC::ReadParam<::nsString>(aReader);
if (!maybe___url) {
aReader->FatalError("Error deserializing 'url' (nsString) member of 'FrameScriptInfo'");
return {};
}
auto& _url = *maybe___url;
// Sentinel = 'url'
if ((!((aReader)->ReadSentinel(45220180)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'url' (nsString) member of 'FrameScriptInfo'");
return {};
}
auto maybe___runInGlobalScope = IPC::ReadParam<bool>(aReader);
if (!maybe___runInGlobalScope) {
aReader->FatalError("Error deserializing 'runInGlobalScope' (bool) member of 'FrameScriptInfo'");
return {};
}
auto& _runInGlobalScope = *maybe___runInGlobalScope;
// Sentinel = 'runInGlobalScope'
if ((!((aReader)->ReadSentinel(907282008)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'runInGlobalScope' (bool) member of 'FrameScriptInfo'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_url),
std::move(_runInGlobalScope)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct CreatedWindowInfo|
//
namespace mozilla {
namespace dom {
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::CreatedWindowInfo>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).rv());
// Sentinel = 'rv'
(aWriter)->WriteSentinel(22806761);
IPC::WriteParam(aWriter, (aVar).windowOpened());
// Sentinel = 'windowOpened'
(aWriter)->WriteSentinel(549586164);
IPC::WriteParam(aWriter, (aVar).frameScripts());
// Sentinel = 'frameScripts'
(aWriter)->WriteSentinel(530646260);
IPC::WriteParam(aWriter, (aVar).dimensions());
// Sentinel = 'dimensions'
(aWriter)->WriteSentinel(383845434);
(aWriter)->WriteBytes((&((aVar).maxTouchPoints())), 4);
// Sentinel = 'maxTouchPoints'
(aWriter)->WriteSentinel(719586759);
}
auto ParamTraits<::mozilla::dom::CreatedWindowInfo>::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 'CreatedWindowInfo'");
return {};
}
auto& _rv = *maybe___rv;
// Sentinel = 'rv'
if ((!((aReader)->ReadSentinel(22806761)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'rv' (nsresult) member of 'CreatedWindowInfo'");
return {};
}
auto maybe___windowOpened = IPC::ReadParam<bool>(aReader);
if (!maybe___windowOpened) {
aReader->FatalError("Error deserializing 'windowOpened' (bool) member of 'CreatedWindowInfo'");
return {};
}
auto& _windowOpened = *maybe___windowOpened;
// Sentinel = 'windowOpened'
if ((!((aReader)->ReadSentinel(549586164)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'windowOpened' (bool) member of 'CreatedWindowInfo'");
return {};
}
auto maybe___frameScripts = IPC::ReadParam<nsTArray<::mozilla::dom::FrameScriptInfo>>(aReader);
if (!maybe___frameScripts) {
aReader->FatalError("Error deserializing 'frameScripts' (FrameScriptInfo[]) member of 'CreatedWindowInfo'");
return {};
}
auto& _frameScripts = *maybe___frameScripts;
// Sentinel = 'frameScripts'
if ((!((aReader)->ReadSentinel(530646260)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'frameScripts' (FrameScriptInfo[]) member of 'CreatedWindowInfo'");
return {};
}
auto maybe___dimensions = IPC::ReadParam<::mozilla::dom::DimensionInfo>(aReader);
if (!maybe___dimensions) {
aReader->FatalError("Error deserializing 'dimensions' (DimensionInfo) member of 'CreatedWindowInfo'");
return {};
}
auto& _dimensions = *maybe___dimensions;
// Sentinel = 'dimensions'
if ((!((aReader)->ReadSentinel(383845434)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'dimensions' (DimensionInfo) member of 'CreatedWindowInfo'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_rv),
std::move(_windowOpened),
std::move(_frameScripts),
::uint32_t{0},
std::move(_dimensions)};
if ((!((aReader)->ReadBytesInto((&((result__)->maxTouchPoints())), 4)))) {
aReader->FatalError("Error bulk reading fields from uint32_t");
return {};
}
// Sentinel = 'maxTouchPoints'
if ((!((aReader)->ReadSentinel(719586759)))) {
mozilla::ipc::SentinelReadError("Error bulk reading fields from uint32_t");
return {};
}
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct DocShellLoadStateInit|
//
namespace mozilla {
namespace dom {
auto DocShellLoadStateInit::StaticAssertions() const -> void
{
static_assert(
(offsetof(DocShellLoadStateInit, TriggeringWindowId_) - offsetof(DocShellLoadStateInit, LoadIdentifier_)) == 8,
"Bad assumptions about field layout!");
static_assert(
(offsetof(DocShellLoadStateInit, TriggeringSandboxFlags_) - offsetof(DocShellLoadStateInit, LoadType_)) == 12,
"Bad assumptions about field layout!");
}
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::DocShellLoadStateInit>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).URI());
// Sentinel = 'URI'
(aWriter)->WriteSentinel(32440561);
IPC::WriteParam(aWriter, (aVar).OriginalURI());
// Sentinel = 'OriginalURI'
(aWriter)->WriteSentinel(432079910);
IPC::WriteParam(aWriter, (aVar).ResultPrincipalURI());
// Sentinel = 'ResultPrincipalURI'
(aWriter)->WriteSentinel(1159202578);
IPC::WriteParam(aWriter, (aVar).TriggeringPrincipal());
// Sentinel = 'TriggeringPrincipal'
(aWriter)->WriteSentinel(1285883829);
IPC::WriteParam(aWriter, (aVar).ReferrerInfo());
// Sentinel = 'ReferrerInfo'
(aWriter)->WriteSentinel(515048650);
IPC::WriteParam(aWriter, (aVar).PrincipalToInherit());
// Sentinel = 'PrincipalToInherit'
(aWriter)->WriteSentinel(1138689849);
IPC::WriteParam(aWriter, (aVar).PartitionedPrincipalToInherit());
// Sentinel = 'PartitionedPrincipalToInherit'
(aWriter)->WriteSentinel(2949909436);
IPC::WriteParam(aWriter, (aVar).BaseURI());
// Sentinel = 'BaseURI'
(aWriter)->WriteSentinel(165282412);
IPC::WriteParam(aWriter, (aVar).Csp());
// Sentinel = 'Csp'
(aWriter)->WriteSentinel(35782951);
IPC::WriteParam(aWriter, (aVar).PostDataStream());
// Sentinel = 'PostDataStream'
(aWriter)->WriteSentinel(690292109);
IPC::WriteParam(aWriter, (aVar).HeadersStream());
// Sentinel = 'HeadersStream'
(aWriter)->WriteSentinel(589432105);
IPC::WriteParam(aWriter, (aVar).UnstrippedURI());
// Sentinel = 'UnstrippedURI'
(aWriter)->WriteSentinel(627967263);
IPC::WriteParam(aWriter, (aVar).Target());
// Sentinel = 'Target'
(aWriter)->WriteSentinel(136184424);
IPC::WriteParam(aWriter, (aVar).TypeHint());
// Sentinel = 'TypeHint'
(aWriter)->WriteSentinel(238748470);
IPC::WriteParam(aWriter, (aVar).FileName());
// Sentinel = 'FileName'
(aWriter)->WriteSentinel(221381378);
IPC::WriteParam(aWriter, (aVar).SourceBrowsingContext());
// Sentinel = 'SourceBrowsingContext'
(aWriter)->WriteSentinel(1569720482);
IPC::WriteParam(aWriter, (aVar).TargetBrowsingContext());
// Sentinel = 'TargetBrowsingContext'
(aWriter)->WriteSentinel(1553991832);
IPC::WriteParam(aWriter, (aVar).TriggeringRemoteType());
// Sentinel = 'TriggeringRemoteType'
(aWriter)->WriteSentinel(1421281313);
IPC::WriteParam(aWriter, (aVar).SrcdocData());
// Sentinel = 'SrcdocData'
(aWriter)->WriteSentinel(354616281);
IPC::WriteParam(aWriter, (aVar).OriginalURIString());
// Sentinel = 'OriginalURIString'
(aWriter)->WriteSentinel(992020125);
IPC::WriteParam(aWriter, (aVar).RemoteTypeOverride());
// Sentinel = 'RemoteTypeOverride'
(aWriter)->WriteSentinel(1155467087);
IPC::WriteParam(aWriter, (aVar).loadingSessionHistoryInfo());
// Sentinel = 'loadingSessionHistoryInfo'
(aWriter)->WriteSentinel(2228161089);
IPC::WriteParam(aWriter, (aVar).TriggeringStorageAccess());
// Sentinel = 'TriggeringStorageAccess'
(aWriter)->WriteSentinel(1859782970);
IPC::WriteParam(aWriter, (aVar).CancelContentJSEpoch());
// Sentinel = 'CancelContentJSEpoch'
(aWriter)->WriteSentinel(1340278702);
IPC::WriteParam(aWriter, (aVar).ResultPrincipalURIIsSome());
// Sentinel = 'ResultPrincipalURIIsSome'
(aWriter)->WriteSentinel(2001799522);
IPC::WriteParam(aWriter, (aVar).KeepResultPrincipalURIIfSet());
// Sentinel = 'KeepResultPrincipalURIIfSet'
(aWriter)->WriteSentinel(2486831730);
IPC::WriteParam(aWriter, (aVar).LoadReplace());
// Sentinel = 'LoadReplace'
(aWriter)->WriteSentinel(418907197);
IPC::WriteParam(aWriter, (aVar).InheritPrincipal());
// Sentinel = 'InheritPrincipal'
(aWriter)->WriteSentinel(908723830);
IPC::WriteParam(aWriter, (aVar).PrincipalIsExplicit());
// Sentinel = 'PrincipalIsExplicit'
(aWriter)->WriteSentinel(1265567649);
IPC::WriteParam(aWriter, (aVar).ForceAllowDataURI());
// Sentinel = 'ForceAllowDataURI'
(aWriter)->WriteSentinel(977077849);
IPC::WriteParam(aWriter, (aVar).IsExemptFromHTTPSFirstMode());
// Sentinel = 'IsExemptFromHTTPSFirstMode'
(aWriter)->WriteSentinel(2233272804);
IPC::WriteParam(aWriter, (aVar).OriginalFrameSrc());
// Sentinel = 'OriginalFrameSrc'
(aWriter)->WriteSentinel(896271945);
IPC::WriteParam(aWriter, (aVar).ShouldCheckForRecursion());
// Sentinel = 'ShouldCheckForRecursion'
(aWriter)->WriteSentinel(1812531503);
IPC::WriteParam(aWriter, (aVar).IsFormSubmission());
// Sentinel = 'IsFormSubmission'
(aWriter)->WriteSentinel(893978237);
IPC::WriteParam(aWriter, (aVar).FirstParty());
// Sentinel = 'FirstParty'
(aWriter)->WriteSentinel(363791385);
IPC::WriteParam(aWriter, (aVar).HasValidUserGestureActivation());
// Sentinel = 'HasValidUserGestureActivation'
(aWriter)->WriteSentinel(2853571485);
IPC::WriteParam(aWriter, (aVar).TextDirectiveUserActivation());
// Sentinel = 'TextDirectiveUserActivation'
(aWriter)->WriteSentinel(2543389430);
IPC::WriteParam(aWriter, (aVar).AllowFocusMove());
// Sentinel = 'AllowFocusMove'
(aWriter)->WriteSentinel(688194967);
IPC::WriteParam(aWriter, (aVar).IsFromProcessingFrameAttributes());
// Sentinel = 'IsFromProcessingFrameAttributes'
(aWriter)->WriteSentinel(3294956672);
IPC::WriteParam(aWriter, (aVar).SchemelessInput());
// Sentinel = 'SchemelessInput'
(aWriter)->WriteSentinel(798557725);
IPC::WriteParam(aWriter, (aVar).HttpsUpgradeTelemetry());
// Sentinel = 'HttpsUpgradeTelemetry'
(aWriter)->WriteSentinel(1562249367);
IPC::WriteParam(aWriter, (aVar).ChannelInitialized());
// Sentinel = 'ChannelInitialized'
(aWriter)->WriteSentinel(1118308144);
IPC::WriteParam(aWriter, (aVar).TryToReplaceWithSessionHistoryLoad());
// Sentinel = 'TryToReplaceWithSessionHistoryLoad'
(aWriter)->WriteSentinel(3987606961);
IPC::WriteParam(aWriter, (aVar).IsMetaRefresh());
// Sentinel = 'IsMetaRefresh'
(aWriter)->WriteSentinel(576849171);
(aWriter)->WriteBytes((&((aVar).LoadIdentifier())), 16);
// Sentinel = 'LoadIdentifier | TriggeringWindowId'
(aWriter)->WriteSentinel(4016246135);
(aWriter)->WriteBytes((&((aVar).LoadType())), 16);
// Sentinel = 'LoadType | LoadFlags | InternalLoadFlags | TriggeringSandboxFlags'
(aWriter)->WriteSentinel(236853308);
}
auto ParamTraits<::mozilla::dom::DocShellLoadStateInit>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___URI = IPC::ReadParam<RefPtr<::nsIURI>>(aReader);
if (!maybe___URI) {
aReader->FatalError("Error deserializing 'URI' (nsIURI) member of 'DocShellLoadStateInit'");
return {};
}
auto& _URI = *maybe___URI;
// Sentinel = 'URI'
if ((!((aReader)->ReadSentinel(32440561)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'URI' (nsIURI) member of 'DocShellLoadStateInit'");
return {};
}
auto maybe___OriginalURI = IPC::ReadParam<RefPtr<::nsIURI>>(aReader);
if (!maybe___OriginalURI) {
aReader->FatalError("Error deserializing 'OriginalURI' (nsIURI) member of 'DocShellLoadStateInit'");
return {};
}
auto& _OriginalURI = *maybe___OriginalURI;
// Sentinel = 'OriginalURI'
if ((!((aReader)->ReadSentinel(432079910)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'OriginalURI' (nsIURI) member of 'DocShellLoadStateInit'");
return {};
}
auto maybe___ResultPrincipalURI = IPC::ReadParam<RefPtr<::nsIURI>>(aReader);
if (!maybe___ResultPrincipalURI) {
aReader->FatalError("Error deserializing 'ResultPrincipalURI' (nsIURI) member of 'DocShellLoadStateInit'");
return {};
}
auto& _ResultPrincipalURI = *maybe___ResultPrincipalURI;
// Sentinel = 'ResultPrincipalURI'
if ((!((aReader)->ReadSentinel(1159202578)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ResultPrincipalURI' (nsIURI) member of 'DocShellLoadStateInit'");
return {};
}
auto maybe___TriggeringPrincipal = IPC::ReadParam<RefPtr<::nsIPrincipal>>(aReader);
if (!maybe___TriggeringPrincipal) {
aReader->FatalError("Error deserializing 'TriggeringPrincipal' (nsIPrincipal) member of 'DocShellLoadStateInit'");
return {};
}
auto& _TriggeringPrincipal = *maybe___TriggeringPrincipal;
// Sentinel = 'TriggeringPrincipal'
if ((!((aReader)->ReadSentinel(1285883829)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'TriggeringPrincipal' (nsIPrincipal) member of 'DocShellLoadStateInit'");
return {};
}
auto maybe___ReferrerInfo = IPC::ReadParam<RefPtr<::nsIReferrerInfo>>(aReader);
if (!maybe___ReferrerInfo) {
aReader->FatalError("Error deserializing 'ReferrerInfo' (nsIReferrerInfo) member of 'DocShellLoadStateInit'");
return {};
}
auto& _ReferrerInfo = *maybe___ReferrerInfo;
// Sentinel = 'ReferrerInfo'
if ((!((aReader)->ReadSentinel(515048650)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ReferrerInfo' (nsIReferrerInfo) member of 'DocShellLoadStateInit'");
return {};
}
auto maybe___PrincipalToInherit = IPC::ReadParam<RefPtr<::nsIPrincipal>>(aReader);
if (!maybe___PrincipalToInherit) {
aReader->FatalError("Error deserializing 'PrincipalToInherit' (nsIPrincipal) member of 'DocShellLoadStateInit'");
return {};
}
auto& _PrincipalToInherit = *maybe___PrincipalToInherit;
// Sentinel = 'PrincipalToInherit'
if ((!((aReader)->ReadSentinel(1138689849)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'PrincipalToInherit' (nsIPrincipal) member of 'DocShellLoadStateInit'");
return {};
}
auto maybe___PartitionedPrincipalToInherit = IPC::ReadParam<RefPtr<::nsIPrincipal>>(aReader);
if (!maybe___PartitionedPrincipalToInherit) {
aReader->FatalError("Error deserializing 'PartitionedPrincipalToInherit' (nsIPrincipal) member of 'DocShellLoadStateInit'");
return {};
}
auto& _PartitionedPrincipalToInherit = *maybe___PartitionedPrincipalToInherit;
// Sentinel = 'PartitionedPrincipalToInherit'
if ((!((aReader)->ReadSentinel(2949909436)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'PartitionedPrincipalToInherit' (nsIPrincipal) member of 'DocShellLoadStateInit'");
return {};
}
auto maybe___BaseURI = IPC::ReadParam<RefPtr<::nsIURI>>(aReader);
if (!maybe___BaseURI) {
aReader->FatalError("Error deserializing 'BaseURI' (nsIURI) member of 'DocShellLoadStateInit'");
return {};
}
auto& _BaseURI = *maybe___BaseURI;
// Sentinel = 'BaseURI'
if ((!((aReader)->ReadSentinel(165282412)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'BaseURI' (nsIURI) member of 'DocShellLoadStateInit'");
return {};
}
auto maybe___Csp = IPC::ReadParam<RefPtr<::nsIContentSecurityPolicy>>(aReader);
if (!maybe___Csp) {
aReader->FatalError("Error deserializing 'Csp' (nsIContentSecurityPolicy) member of 'DocShellLoadStateInit'");
return {};
}
auto& _Csp = *maybe___Csp;
// Sentinel = 'Csp'
if ((!((aReader)->ReadSentinel(35782951)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'Csp' (nsIContentSecurityPolicy) member of 'DocShellLoadStateInit'");
return {};
}
auto maybe___PostDataStream = IPC::ReadParam<RefPtr<::nsIInputStream>>(aReader);
if (!maybe___PostDataStream) {
aReader->FatalError("Error deserializing 'PostDataStream' (nsIInputStream) member of 'DocShellLoadStateInit'");
return {};
}
auto& _PostDataStream = *maybe___PostDataStream;
// Sentinel = 'PostDataStream'
if ((!((aReader)->ReadSentinel(690292109)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'PostDataStream' (nsIInputStream) member of 'DocShellLoadStateInit'");
return {};
}
auto maybe___HeadersStream = IPC::ReadParam<RefPtr<::nsIInputStream>>(aReader);
if (!maybe___HeadersStream) {
aReader->FatalError("Error deserializing 'HeadersStream' (nsIInputStream) member of 'DocShellLoadStateInit'");
return {};
}
auto& _HeadersStream = *maybe___HeadersStream;
// Sentinel = 'HeadersStream'
if ((!((aReader)->ReadSentinel(589432105)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'HeadersStream' (nsIInputStream) member of 'DocShellLoadStateInit'");
return {};
}
auto maybe___UnstrippedURI = IPC::ReadParam<RefPtr<::nsIURI>>(aReader);
if (!maybe___UnstrippedURI) {
aReader->FatalError("Error deserializing 'UnstrippedURI' (nsIURI) member of 'DocShellLoadStateInit'");
return {};
}
auto& _UnstrippedURI = *maybe___UnstrippedURI;
// Sentinel = 'UnstrippedURI'
if ((!((aReader)->ReadSentinel(627967263)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'UnstrippedURI' (nsIURI) member of 'DocShellLoadStateInit'");
return {};
}
auto maybe___Target = IPC::ReadParam<::nsString>(aReader);
if (!maybe___Target) {
aReader->FatalError("Error deserializing 'Target' (nsString) member of 'DocShellLoadStateInit'");
return {};
}
auto& _Target = *maybe___Target;
// Sentinel = 'Target'
if ((!((aReader)->ReadSentinel(136184424)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'Target' (nsString) member of 'DocShellLoadStateInit'");
return {};
}
auto maybe___TypeHint = IPC::ReadParam<::nsCString>(aReader);
if (!maybe___TypeHint) {
aReader->FatalError("Error deserializing 'TypeHint' (nsCString) member of 'DocShellLoadStateInit'");
return {};
}
auto& _TypeHint = *maybe___TypeHint;
// Sentinel = 'TypeHint'
if ((!((aReader)->ReadSentinel(238748470)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'TypeHint' (nsCString) member of 'DocShellLoadStateInit'");
return {};
}
auto maybe___FileName = IPC::ReadParam<::nsString>(aReader);
if (!maybe___FileName) {
aReader->FatalError("Error deserializing 'FileName' (nsString) member of 'DocShellLoadStateInit'");
return {};
}
auto& _FileName = *maybe___FileName;
// Sentinel = 'FileName'
if ((!((aReader)->ReadSentinel(221381378)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'FileName' (nsString) member of 'DocShellLoadStateInit'");
return {};
}
auto maybe___SourceBrowsingContext = IPC::ReadParam<::mozilla::dom::MaybeDiscardedBrowsingContext>(aReader);
if (!maybe___SourceBrowsingContext) {
aReader->FatalError("Error deserializing 'SourceBrowsingContext' (MaybeDiscardedBrowsingContext) member of 'DocShellLoadStateInit'");
return {};
}
auto& _SourceBrowsingContext = *maybe___SourceBrowsingContext;
// Sentinel = 'SourceBrowsingContext'
if ((!((aReader)->ReadSentinel(1569720482)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'SourceBrowsingContext' (MaybeDiscardedBrowsingContext) member of 'DocShellLoadStateInit'");
return {};
}
auto maybe___TargetBrowsingContext = IPC::ReadParam<::mozilla::dom::MaybeDiscardedBrowsingContext>(aReader);
if (!maybe___TargetBrowsingContext) {
aReader->FatalError("Error deserializing 'TargetBrowsingContext' (MaybeDiscardedBrowsingContext) member of 'DocShellLoadStateInit'");
return {};
}
auto& _TargetBrowsingContext = *maybe___TargetBrowsingContext;
// Sentinel = 'TargetBrowsingContext'
if ((!((aReader)->ReadSentinel(1553991832)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'TargetBrowsingContext' (MaybeDiscardedBrowsingContext) member of 'DocShellLoadStateInit'");
return {};
}
auto maybe___TriggeringRemoteType = IPC::ReadParam<::nsCString>(aReader);
if (!maybe___TriggeringRemoteType) {
aReader->FatalError("Error deserializing 'TriggeringRemoteType' (nsCString) member of 'DocShellLoadStateInit'");
return {};
}
auto& _TriggeringRemoteType = *maybe___TriggeringRemoteType;
// Sentinel = 'TriggeringRemoteType'
if ((!((aReader)->ReadSentinel(1421281313)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'TriggeringRemoteType' (nsCString) member of 'DocShellLoadStateInit'");
return {};
}
auto maybe___SrcdocData = IPC::ReadParam<::nsString>(aReader);
if (!maybe___SrcdocData) {
aReader->FatalError("Error deserializing 'SrcdocData' (nsString) member of 'DocShellLoadStateInit'");
return {};
}
auto& _SrcdocData = *maybe___SrcdocData;
// Sentinel = 'SrcdocData'
if ((!((aReader)->ReadSentinel(354616281)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'SrcdocData' (nsString) member of 'DocShellLoadStateInit'");
return {};
}
auto maybe___OriginalURIString = IPC::ReadParam<mozilla::Maybe<::nsCString>>(aReader);
if (!maybe___OriginalURIString) {
aReader->FatalError("Error deserializing 'OriginalURIString' (nsCString?) member of 'DocShellLoadStateInit'");
return {};
}
auto& _OriginalURIString = *maybe___OriginalURIString;
// Sentinel = 'OriginalURIString'
if ((!((aReader)->ReadSentinel(992020125)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'OriginalURIString' (nsCString?) member of 'DocShellLoadStateInit'");
return {};
}
auto maybe___RemoteTypeOverride = IPC::ReadParam<mozilla::Maybe<::nsCString>>(aReader);
if (!maybe___RemoteTypeOverride) {
aReader->FatalError("Error deserializing 'RemoteTypeOverride' (nsCString?) member of 'DocShellLoadStateInit'");
return {};
}
auto& _RemoteTypeOverride = *maybe___RemoteTypeOverride;
// Sentinel = 'RemoteTypeOverride'
if ((!((aReader)->ReadSentinel(1155467087)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'RemoteTypeOverride' (nsCString?) member of 'DocShellLoadStateInit'");
return {};
}
auto maybe___loadingSessionHistoryInfo = IPC::ReadParam<mozilla::Maybe<::mozilla::dom::LoadingSessionHistoryInfo>>(aReader);
if (!maybe___loadingSessionHistoryInfo) {
aReader->FatalError("Error deserializing 'loadingSessionHistoryInfo' (LoadingSessionHistoryInfo?) member of 'DocShellLoadStateInit'");
return {};
}
auto& _loadingSessionHistoryInfo = *maybe___loadingSessionHistoryInfo;
// Sentinel = 'loadingSessionHistoryInfo'
if ((!((aReader)->ReadSentinel(2228161089)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'loadingSessionHistoryInfo' (LoadingSessionHistoryInfo?) member of 'DocShellLoadStateInit'");
return {};
}
auto maybe___TriggeringStorageAccess = IPC::ReadParam<bool>(aReader);
if (!maybe___TriggeringStorageAccess) {
aReader->FatalError("Error deserializing 'TriggeringStorageAccess' (bool) member of 'DocShellLoadStateInit'");
return {};
}
auto& _TriggeringStorageAccess = *maybe___TriggeringStorageAccess;
// Sentinel = 'TriggeringStorageAccess'
if ((!((aReader)->ReadSentinel(1859782970)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'TriggeringStorageAccess' (bool) member of 'DocShellLoadStateInit'");
return {};
}
auto maybe___CancelContentJSEpoch = IPC::ReadParam<mozilla::Maybe<::int32_t>>(aReader);
if (!maybe___CancelContentJSEpoch) {
aReader->FatalError("Error deserializing 'CancelContentJSEpoch' (int32_t?) member of 'DocShellLoadStateInit'");
return {};
}
auto& _CancelContentJSEpoch = *maybe___CancelContentJSEpoch;
// Sentinel = 'CancelContentJSEpoch'
if ((!((aReader)->ReadSentinel(1340278702)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'CancelContentJSEpoch' (int32_t?) member of 'DocShellLoadStateInit'");
return {};
}
auto maybe___ResultPrincipalURIIsSome = IPC::ReadParam<bool>(aReader);
if (!maybe___ResultPrincipalURIIsSome) {
aReader->FatalError("Error deserializing 'ResultPrincipalURIIsSome' (bool) member of 'DocShellLoadStateInit'");
return {};
}
auto& _ResultPrincipalURIIsSome = *maybe___ResultPrincipalURIIsSome;
// Sentinel = 'ResultPrincipalURIIsSome'
if ((!((aReader)->ReadSentinel(2001799522)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ResultPrincipalURIIsSome' (bool) member of 'DocShellLoadStateInit'");
return {};
}
auto maybe___KeepResultPrincipalURIIfSet = IPC::ReadParam<bool>(aReader);
if (!maybe___KeepResultPrincipalURIIfSet) {
aReader->FatalError("Error deserializing 'KeepResultPrincipalURIIfSet' (bool) member of 'DocShellLoadStateInit'");
return {};
}
auto& _KeepResultPrincipalURIIfSet = *maybe___KeepResultPrincipalURIIfSet;
// Sentinel = 'KeepResultPrincipalURIIfSet'
if ((!((aReader)->ReadSentinel(2486831730)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'KeepResultPrincipalURIIfSet' (bool) member of 'DocShellLoadStateInit'");
return {};
}
auto maybe___LoadReplace = IPC::ReadParam<bool>(aReader);
if (!maybe___LoadReplace) {
aReader->FatalError("Error deserializing 'LoadReplace' (bool) member of 'DocShellLoadStateInit'");
return {};
}
auto& _LoadReplace = *maybe___LoadReplace;
// Sentinel = 'LoadReplace'
if ((!((aReader)->ReadSentinel(418907197)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'LoadReplace' (bool) member of 'DocShellLoadStateInit'");
return {};
}
auto maybe___InheritPrincipal = IPC::ReadParam<bool>(aReader);
if (!maybe___InheritPrincipal) {
aReader->FatalError("Error deserializing 'InheritPrincipal' (bool) member of 'DocShellLoadStateInit'");
return {};
}
auto& _InheritPrincipal = *maybe___InheritPrincipal;
// Sentinel = 'InheritPrincipal'
if ((!((aReader)->ReadSentinel(908723830)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'InheritPrincipal' (bool) member of 'DocShellLoadStateInit'");
return {};
}
auto maybe___PrincipalIsExplicit = IPC::ReadParam<bool>(aReader);
if (!maybe___PrincipalIsExplicit) {
aReader->FatalError("Error deserializing 'PrincipalIsExplicit' (bool) member of 'DocShellLoadStateInit'");
return {};
}
auto& _PrincipalIsExplicit = *maybe___PrincipalIsExplicit;
// Sentinel = 'PrincipalIsExplicit'
if ((!((aReader)->ReadSentinel(1265567649)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'PrincipalIsExplicit' (bool) member of 'DocShellLoadStateInit'");
return {};
}
auto maybe___ForceAllowDataURI = IPC::ReadParam<bool>(aReader);
if (!maybe___ForceAllowDataURI) {
aReader->FatalError("Error deserializing 'ForceAllowDataURI' (bool) member of 'DocShellLoadStateInit'");
return {};
}
auto& _ForceAllowDataURI = *maybe___ForceAllowDataURI;
// Sentinel = 'ForceAllowDataURI'
if ((!((aReader)->ReadSentinel(977077849)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ForceAllowDataURI' (bool) member of 'DocShellLoadStateInit'");
return {};
}
auto maybe___IsExemptFromHTTPSFirstMode = IPC::ReadParam<bool>(aReader);
if (!maybe___IsExemptFromHTTPSFirstMode) {
aReader->FatalError("Error deserializing 'IsExemptFromHTTPSFirstMode' (bool) member of 'DocShellLoadStateInit'");
return {};
}
auto& _IsExemptFromHTTPSFirstMode = *maybe___IsExemptFromHTTPSFirstMode;
// Sentinel = 'IsExemptFromHTTPSFirstMode'
if ((!((aReader)->ReadSentinel(2233272804)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'IsExemptFromHTTPSFirstMode' (bool) member of 'DocShellLoadStateInit'");
return {};
}
auto maybe___OriginalFrameSrc = IPC::ReadParam<bool>(aReader);
if (!maybe___OriginalFrameSrc) {
aReader->FatalError("Error deserializing 'OriginalFrameSrc' (bool) member of 'DocShellLoadStateInit'");
return {};
}
auto& _OriginalFrameSrc = *maybe___OriginalFrameSrc;
// Sentinel = 'OriginalFrameSrc'
if ((!((aReader)->ReadSentinel(896271945)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'OriginalFrameSrc' (bool) member of 'DocShellLoadStateInit'");
return {};
}
auto maybe___ShouldCheckForRecursion = IPC::ReadParam<bool>(aReader);
if (!maybe___ShouldCheckForRecursion) {
aReader->FatalError("Error deserializing 'ShouldCheckForRecursion' (bool) member of 'DocShellLoadStateInit'");
return {};
}
auto& _ShouldCheckForRecursion = *maybe___ShouldCheckForRecursion;
// Sentinel = 'ShouldCheckForRecursion'
if ((!((aReader)->ReadSentinel(1812531503)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ShouldCheckForRecursion' (bool) member of 'DocShellLoadStateInit'");
return {};
}
auto maybe___IsFormSubmission = IPC::ReadParam<bool>(aReader);
if (!maybe___IsFormSubmission) {
aReader->FatalError("Error deserializing 'IsFormSubmission' (bool) member of 'DocShellLoadStateInit'");
return {};
}
auto& _IsFormSubmission = *maybe___IsFormSubmission;
// Sentinel = 'IsFormSubmission'
if ((!((aReader)->ReadSentinel(893978237)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'IsFormSubmission' (bool) member of 'DocShellLoadStateInit'");
return {};
}
auto maybe___FirstParty = IPC::ReadParam<bool>(aReader);
if (!maybe___FirstParty) {
aReader->FatalError("Error deserializing 'FirstParty' (bool) member of 'DocShellLoadStateInit'");
return {};
}
auto& _FirstParty = *maybe___FirstParty;
// Sentinel = 'FirstParty'
if ((!((aReader)->ReadSentinel(363791385)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'FirstParty' (bool) member of 'DocShellLoadStateInit'");
return {};
}
auto maybe___HasValidUserGestureActivation = IPC::ReadParam<bool>(aReader);
if (!maybe___HasValidUserGestureActivation) {
aReader->FatalError("Error deserializing 'HasValidUserGestureActivation' (bool) member of 'DocShellLoadStateInit'");
return {};
}
auto& _HasValidUserGestureActivation = *maybe___HasValidUserGestureActivation;
// Sentinel = 'HasValidUserGestureActivation'
if ((!((aReader)->ReadSentinel(2853571485)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'HasValidUserGestureActivation' (bool) member of 'DocShellLoadStateInit'");
return {};
}
auto maybe___TextDirectiveUserActivation = IPC::ReadParam<bool>(aReader);
if (!maybe___TextDirectiveUserActivation) {
aReader->FatalError("Error deserializing 'TextDirectiveUserActivation' (bool) member of 'DocShellLoadStateInit'");
return {};
}
auto& _TextDirectiveUserActivation = *maybe___TextDirectiveUserActivation;
// Sentinel = 'TextDirectiveUserActivation'
if ((!((aReader)->ReadSentinel(2543389430)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'TextDirectiveUserActivation' (bool) member of 'DocShellLoadStateInit'");
return {};
}
auto maybe___AllowFocusMove = IPC::ReadParam<bool>(aReader);
if (!maybe___AllowFocusMove) {
aReader->FatalError("Error deserializing 'AllowFocusMove' (bool) member of 'DocShellLoadStateInit'");
return {};
}
auto& _AllowFocusMove = *maybe___AllowFocusMove;
// Sentinel = 'AllowFocusMove'
if ((!((aReader)->ReadSentinel(688194967)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'AllowFocusMove' (bool) member of 'DocShellLoadStateInit'");
return {};
}
auto maybe___IsFromProcessingFrameAttributes = IPC::ReadParam<bool>(aReader);
if (!maybe___IsFromProcessingFrameAttributes) {
aReader->FatalError("Error deserializing 'IsFromProcessingFrameAttributes' (bool) member of 'DocShellLoadStateInit'");
return {};
}
auto& _IsFromProcessingFrameAttributes = *maybe___IsFromProcessingFrameAttributes;
// Sentinel = 'IsFromProcessingFrameAttributes'
if ((!((aReader)->ReadSentinel(3294956672)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'IsFromProcessingFrameAttributes' (bool) member of 'DocShellLoadStateInit'");
return {};
}
auto maybe___SchemelessInput = IPC::ReadParam<::nsILoadInfo::SchemelessInputType>(aReader);
if (!maybe___SchemelessInput) {
aReader->FatalError("Error deserializing 'SchemelessInput' (SchemelessInputType) member of 'DocShellLoadStateInit'");
return {};
}
auto& _SchemelessInput = *maybe___SchemelessInput;
// Sentinel = 'SchemelessInput'
if ((!((aReader)->ReadSentinel(798557725)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'SchemelessInput' (SchemelessInputType) member of 'DocShellLoadStateInit'");
return {};
}
auto maybe___HttpsUpgradeTelemetry = IPC::ReadParam<::nsILoadInfo::HTTPSUpgradeTelemetryType>(aReader);
if (!maybe___HttpsUpgradeTelemetry) {
aReader->FatalError("Error deserializing 'HttpsUpgradeTelemetry' (HTTPSUpgradeTelemetryType) member of 'DocShellLoadStateInit'");
return {};
}
auto& _HttpsUpgradeTelemetry = *maybe___HttpsUpgradeTelemetry;
// Sentinel = 'HttpsUpgradeTelemetry'
if ((!((aReader)->ReadSentinel(1562249367)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'HttpsUpgradeTelemetry' (HTTPSUpgradeTelemetryType) member of 'DocShellLoadStateInit'");
return {};
}
auto maybe___ChannelInitialized = IPC::ReadParam<bool>(aReader);
if (!maybe___ChannelInitialized) {
aReader->FatalError("Error deserializing 'ChannelInitialized' (bool) member of 'DocShellLoadStateInit'");
return {};
}
auto& _ChannelInitialized = *maybe___ChannelInitialized;
// Sentinel = 'ChannelInitialized'
if ((!((aReader)->ReadSentinel(1118308144)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ChannelInitialized' (bool) member of 'DocShellLoadStateInit'");
return {};
}
auto maybe___TryToReplaceWithSessionHistoryLoad = IPC::ReadParam<bool>(aReader);
if (!maybe___TryToReplaceWithSessionHistoryLoad) {
aReader->FatalError("Error deserializing 'TryToReplaceWithSessionHistoryLoad' (bool) member of 'DocShellLoadStateInit'");
return {};
}
auto& _TryToReplaceWithSessionHistoryLoad = *maybe___TryToReplaceWithSessionHistoryLoad;
// Sentinel = 'TryToReplaceWithSessionHistoryLoad'
if ((!((aReader)->ReadSentinel(3987606961)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'TryToReplaceWithSessionHistoryLoad' (bool) member of 'DocShellLoadStateInit'");
return {};
}
auto maybe___IsMetaRefresh = IPC::ReadParam<bool>(aReader);
if (!maybe___IsMetaRefresh) {
aReader->FatalError("Error deserializing 'IsMetaRefresh' (bool) member of 'DocShellLoadStateInit'");
return {};
}
auto& _IsMetaRefresh = *maybe___IsMetaRefresh;
// Sentinel = 'IsMetaRefresh'
if ((!((aReader)->ReadSentinel(576849171)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'IsMetaRefresh' (bool) member of 'DocShellLoadStateInit'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_URI),
std::move(_OriginalURI),
std::move(_ResultPrincipalURI),
std::move(_TriggeringPrincipal),
std::move(_ReferrerInfo),
std::move(_PrincipalToInherit),
std::move(_PartitionedPrincipalToInherit),
std::move(_BaseURI),
std::move(_Csp),
std::move(_PostDataStream),
std::move(_HeadersStream),
std::move(_UnstrippedURI),
::uint64_t{0},
std::move(_Target),
std::move(_TypeHint),
std::move(_FileName),
std::move(_SourceBrowsingContext),
std::move(_TargetBrowsingContext),
std::move(_TriggeringRemoteType),
std::move(_SrcdocData),
std::move(_OriginalURIString),
std::move(_RemoteTypeOverride),
std::move(_loadingSessionHistoryInfo),
::uint32_t{0},
::uint32_t{0},
::uint32_t{0},
::uint32_t{0},
::uint64_t{0},
std::move(_TriggeringStorageAccess),
std::move(_CancelContentJSEpoch),
std::move(_ResultPrincipalURIIsSome),
std::move(_KeepResultPrincipalURIIfSet),
std::move(_LoadReplace),
std::move(_InheritPrincipal),
std::move(_PrincipalIsExplicit),
std::move(_ForceAllowDataURI),
std::move(_IsExemptFromHTTPSFirstMode),
std::move(_OriginalFrameSrc),
std::move(_ShouldCheckForRecursion),
std::move(_IsFormSubmission),
std::move(_FirstParty),
std::move(_HasValidUserGestureActivation),
std::move(_TextDirectiveUserActivation),
std::move(_AllowFocusMove),
std::move(_IsFromProcessingFrameAttributes),
std::move(_SchemelessInput),
std::move(_HttpsUpgradeTelemetry),
std::move(_ChannelInitialized),
std::move(_TryToReplaceWithSessionHistoryLoad),
std::move(_IsMetaRefresh)};
if ((!((aReader)->ReadBytesInto((&((result__)->LoadIdentifier())), 16)))) {
aReader->FatalError("Error bulk reading fields from uint64_t");
return {};
}
// Sentinel = 'LoadIdentifier | TriggeringWindowId'
if ((!((aReader)->ReadSentinel(4016246135)))) {
mozilla::ipc::SentinelReadError("Error bulk reading fields from uint64_t");
return {};
}
if ((!((aReader)->ReadBytesInto((&((result__)->LoadType())), 16)))) {
aReader->FatalError("Error bulk reading fields from uint32_t");
return {};
}
// Sentinel = 'LoadType | LoadFlags | InternalLoadFlags | TriggeringSandboxFlags'
if ((!((aReader)->ReadSentinel(236853308)))) {
mozilla::ipc::SentinelReadError("Error bulk reading fields from uint32_t");
return {};
}
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct TimedChannelInfo|
//
namespace mozilla {
namespace dom {
auto TimedChannelInfo::StaticAssertions() const -> void
{
static_assert(
(offsetof(TimedChannelInfo, internalRedirectCount_) - offsetof(TimedChannelInfo, redirectCount_)) == 1,
"Bad assumptions about field layout!");
}
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::TimedChannelInfo>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).asyncOpen());
// Sentinel = 'asyncOpen'
(aWriter)->WriteSentinel(312476593);
IPC::WriteParam(aWriter, (aVar).channelCreation());
// Sentinel = 'channelCreation'
(aWriter)->WriteSentinel(803800591);
IPC::WriteParam(aWriter, (aVar).redirectStart());
// Sentinel = 'redirectStart'
(aWriter)->WriteSentinel(628753761);
IPC::WriteParam(aWriter, (aVar).redirectEnd());
// Sentinel = 'redirectEnd'
(aWriter)->WriteSentinel(452527210);
IPC::WriteParam(aWriter, (aVar).initiatorType());
// Sentinel = 'initiatorType'
(aWriter)->WriteSentinel(642647414);
IPC::WriteParam(aWriter, (aVar).allRedirectsSameOrigin());
// Sentinel = 'allRedirectsSameOrigin'
(aWriter)->WriteSentinel(1689716941);
IPC::WriteParam(aWriter, (aVar).allRedirectsPassTimingAllowCheck());
// Sentinel = 'allRedirectsPassTimingAllowCheck'
(aWriter)->WriteSentinel(3535342779);
IPC::WriteParam(aWriter, (aVar).timingAllowCheckForPrincipal());
// Sentinel = 'timingAllowCheckForPrincipal'
(aWriter)->WriteSentinel(2723941167);
IPC::WriteParam(aWriter, (aVar).renderBlocking());
// Sentinel = 'renderBlocking'
(aWriter)->WriteSentinel(713688490);
IPC::WriteParam(aWriter, (aVar).launchServiceWorkerStart());
// Sentinel = 'launchServiceWorkerStart'
(aWriter)->WriteSentinel(2052262357);
IPC::WriteParam(aWriter, (aVar).launchServiceWorkerEnd());
// Sentinel = 'launchServiceWorkerEnd'
(aWriter)->WriteSentinel(1726613726);
IPC::WriteParam(aWriter, (aVar).dispatchFetchEventStart());
// Sentinel = 'dispatchFetchEventStart'
(aWriter)->WriteSentinel(1861880139);
IPC::WriteParam(aWriter, (aVar).dispatchFetchEventEnd());
// Sentinel = 'dispatchFetchEventEnd'
(aWriter)->WriteSentinel(1554319444);
IPC::WriteParam(aWriter, (aVar).handleFetchEventStart());
// Sentinel = 'handleFetchEventStart'
(aWriter)->WriteSentinel(1529022567);
IPC::WriteParam(aWriter, (aVar).handleFetchEventEnd());
// Sentinel = 'handleFetchEventEnd'
(aWriter)->WriteSentinel(1251346288);
IPC::WriteParam(aWriter, (aVar).responseStart());
// Sentinel = 'responseStart'
(aWriter)->WriteSentinel(648545662);
IPC::WriteParam(aWriter, (aVar).responseEnd());
// Sentinel = 'responseEnd'
(aWriter)->WriteSentinel(468518023);
(aWriter)->WriteBytes((&((aVar).redirectCount())), 2);
// Sentinel = 'redirectCount | internalRedirectCount'
(aWriter)->WriteSentinel(359534256);
}
auto ParamTraits<::mozilla::dom::TimedChannelInfo>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___asyncOpen = IPC::ReadParam<::mozilla::TimeStamp>(aReader);
if (!maybe___asyncOpen) {
aReader->FatalError("Error deserializing 'asyncOpen' (TimeStamp) member of 'TimedChannelInfo'");
return {};
}
auto& _asyncOpen = *maybe___asyncOpen;
// Sentinel = 'asyncOpen'
if ((!((aReader)->ReadSentinel(312476593)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'asyncOpen' (TimeStamp) member of 'TimedChannelInfo'");
return {};
}
auto maybe___channelCreation = IPC::ReadParam<::mozilla::TimeStamp>(aReader);
if (!maybe___channelCreation) {
aReader->FatalError("Error deserializing 'channelCreation' (TimeStamp) member of 'TimedChannelInfo'");
return {};
}
auto& _channelCreation = *maybe___channelCreation;
// Sentinel = 'channelCreation'
if ((!((aReader)->ReadSentinel(803800591)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'channelCreation' (TimeStamp) member of 'TimedChannelInfo'");
return {};
}
auto maybe___redirectStart = IPC::ReadParam<::mozilla::TimeStamp>(aReader);
if (!maybe___redirectStart) {
aReader->FatalError("Error deserializing 'redirectStart' (TimeStamp) member of 'TimedChannelInfo'");
return {};
}
auto& _redirectStart = *maybe___redirectStart;
// Sentinel = 'redirectStart'
if ((!((aReader)->ReadSentinel(628753761)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'redirectStart' (TimeStamp) member of 'TimedChannelInfo'");
return {};
}
auto maybe___redirectEnd = IPC::ReadParam<::mozilla::TimeStamp>(aReader);
if (!maybe___redirectEnd) {
aReader->FatalError("Error deserializing 'redirectEnd' (TimeStamp) member of 'TimedChannelInfo'");
return {};
}
auto& _redirectEnd = *maybe___redirectEnd;
// Sentinel = 'redirectEnd'
if ((!((aReader)->ReadSentinel(452527210)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'redirectEnd' (TimeStamp) member of 'TimedChannelInfo'");
return {};
}
auto maybe___initiatorType = IPC::ReadParam<::nsString>(aReader);
if (!maybe___initiatorType) {
aReader->FatalError("Error deserializing 'initiatorType' (nsString) member of 'TimedChannelInfo'");
return {};
}
auto& _initiatorType = *maybe___initiatorType;
// Sentinel = 'initiatorType'
if ((!((aReader)->ReadSentinel(642647414)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'initiatorType' (nsString) member of 'TimedChannelInfo'");
return {};
}
auto maybe___allRedirectsSameOrigin = IPC::ReadParam<bool>(aReader);
if (!maybe___allRedirectsSameOrigin) {
aReader->FatalError("Error deserializing 'allRedirectsSameOrigin' (bool) member of 'TimedChannelInfo'");
return {};
}
auto& _allRedirectsSameOrigin = *maybe___allRedirectsSameOrigin;
// Sentinel = 'allRedirectsSameOrigin'
if ((!((aReader)->ReadSentinel(1689716941)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'allRedirectsSameOrigin' (bool) member of 'TimedChannelInfo'");
return {};
}
auto maybe___allRedirectsPassTimingAllowCheck = IPC::ReadParam<bool>(aReader);
if (!maybe___allRedirectsPassTimingAllowCheck) {
aReader->FatalError("Error deserializing 'allRedirectsPassTimingAllowCheck' (bool) member of 'TimedChannelInfo'");
return {};
}
auto& _allRedirectsPassTimingAllowCheck = *maybe___allRedirectsPassTimingAllowCheck;
// Sentinel = 'allRedirectsPassTimingAllowCheck'
if ((!((aReader)->ReadSentinel(3535342779)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'allRedirectsPassTimingAllowCheck' (bool) member of 'TimedChannelInfo'");
return {};
}
auto maybe___timingAllowCheckForPrincipal = IPC::ReadParam<mozilla::Maybe<bool>>(aReader);
if (!maybe___timingAllowCheckForPrincipal) {
aReader->FatalError("Error deserializing 'timingAllowCheckForPrincipal' (bool?) member of 'TimedChannelInfo'");
return {};
}
auto& _timingAllowCheckForPrincipal = *maybe___timingAllowCheckForPrincipal;
// Sentinel = 'timingAllowCheckForPrincipal'
if ((!((aReader)->ReadSentinel(2723941167)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'timingAllowCheckForPrincipal' (bool?) member of 'TimedChannelInfo'");
return {};
}
auto maybe___renderBlocking = IPC::ReadParam<bool>(aReader);
if (!maybe___renderBlocking) {
aReader->FatalError("Error deserializing 'renderBlocking' (bool) member of 'TimedChannelInfo'");
return {};
}
auto& _renderBlocking = *maybe___renderBlocking;
// Sentinel = 'renderBlocking'
if ((!((aReader)->ReadSentinel(713688490)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'renderBlocking' (bool) member of 'TimedChannelInfo'");
return {};
}
auto maybe___launchServiceWorkerStart = IPC::ReadParam<::mozilla::TimeStamp>(aReader);
if (!maybe___launchServiceWorkerStart) {
aReader->FatalError("Error deserializing 'launchServiceWorkerStart' (TimeStamp) member of 'TimedChannelInfo'");
return {};
}
auto& _launchServiceWorkerStart = *maybe___launchServiceWorkerStart;
// Sentinel = 'launchServiceWorkerStart'
if ((!((aReader)->ReadSentinel(2052262357)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'launchServiceWorkerStart' (TimeStamp) member of 'TimedChannelInfo'");
return {};
}
auto maybe___launchServiceWorkerEnd = IPC::ReadParam<::mozilla::TimeStamp>(aReader);
if (!maybe___launchServiceWorkerEnd) {
aReader->FatalError("Error deserializing 'launchServiceWorkerEnd' (TimeStamp) member of 'TimedChannelInfo'");
return {};
}
auto& _launchServiceWorkerEnd = *maybe___launchServiceWorkerEnd;
// Sentinel = 'launchServiceWorkerEnd'
if ((!((aReader)->ReadSentinel(1726613726)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'launchServiceWorkerEnd' (TimeStamp) member of 'TimedChannelInfo'");
return {};
}
auto maybe___dispatchFetchEventStart = IPC::ReadParam<::mozilla::TimeStamp>(aReader);
if (!maybe___dispatchFetchEventStart) {
aReader->FatalError("Error deserializing 'dispatchFetchEventStart' (TimeStamp) member of 'TimedChannelInfo'");
return {};
}
auto& _dispatchFetchEventStart = *maybe___dispatchFetchEventStart;
// Sentinel = 'dispatchFetchEventStart'
if ((!((aReader)->ReadSentinel(1861880139)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'dispatchFetchEventStart' (TimeStamp) member of 'TimedChannelInfo'");
return {};
}
auto maybe___dispatchFetchEventEnd = IPC::ReadParam<::mozilla::TimeStamp>(aReader);
if (!maybe___dispatchFetchEventEnd) {
aReader->FatalError("Error deserializing 'dispatchFetchEventEnd' (TimeStamp) member of 'TimedChannelInfo'");
return {};
}
auto& _dispatchFetchEventEnd = *maybe___dispatchFetchEventEnd;
// Sentinel = 'dispatchFetchEventEnd'
if ((!((aReader)->ReadSentinel(1554319444)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'dispatchFetchEventEnd' (TimeStamp) member of 'TimedChannelInfo'");
return {};
}
auto maybe___handleFetchEventStart = IPC::ReadParam<::mozilla::TimeStamp>(aReader);
if (!maybe___handleFetchEventStart) {
aReader->FatalError("Error deserializing 'handleFetchEventStart' (TimeStamp) member of 'TimedChannelInfo'");
return {};
}
auto& _handleFetchEventStart = *maybe___handleFetchEventStart;
// Sentinel = 'handleFetchEventStart'
if ((!((aReader)->ReadSentinel(1529022567)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'handleFetchEventStart' (TimeStamp) member of 'TimedChannelInfo'");
return {};
}
auto maybe___handleFetchEventEnd = IPC::ReadParam<::mozilla::TimeStamp>(aReader);
if (!maybe___handleFetchEventEnd) {
aReader->FatalError("Error deserializing 'handleFetchEventEnd' (TimeStamp) member of 'TimedChannelInfo'");
return {};
}
auto& _handleFetchEventEnd = *maybe___handleFetchEventEnd;
// Sentinel = 'handleFetchEventEnd'
if ((!((aReader)->ReadSentinel(1251346288)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'handleFetchEventEnd' (TimeStamp) member of 'TimedChannelInfo'");
return {};
}
auto maybe___responseStart = IPC::ReadParam<::mozilla::TimeStamp>(aReader);
if (!maybe___responseStart) {
aReader->FatalError("Error deserializing 'responseStart' (TimeStamp) member of 'TimedChannelInfo'");
return {};
}
auto& _responseStart = *maybe___responseStart;
// Sentinel = 'responseStart'
if ((!((aReader)->ReadSentinel(648545662)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'responseStart' (TimeStamp) member of 'TimedChannelInfo'");
return {};
}
auto maybe___responseEnd = IPC::ReadParam<::mozilla::TimeStamp>(aReader);
if (!maybe___responseEnd) {
aReader->FatalError("Error deserializing 'responseEnd' (TimeStamp) member of 'TimedChannelInfo'");
return {};
}
auto& _responseEnd = *maybe___responseEnd;
// Sentinel = 'responseEnd'
if ((!((aReader)->ReadSentinel(468518023)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'responseEnd' (TimeStamp) member of 'TimedChannelInfo'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
::int8_t{0},
::int8_t{0},
std::move(_asyncOpen),
std::move(_channelCreation),
std::move(_redirectStart),
std::move(_redirectEnd),
std::move(_initiatorType),
std::move(_allRedirectsSameOrigin),
std::move(_allRedirectsPassTimingAllowCheck),
std::move(_timingAllowCheckForPrincipal),
std::move(_renderBlocking),
std::move(_launchServiceWorkerStart),
std::move(_launchServiceWorkerEnd),
std::move(_dispatchFetchEventStart),
std::move(_dispatchFetchEventEnd),
std::move(_handleFetchEventStart),
std::move(_handleFetchEventEnd),
std::move(_responseStart),
std::move(_responseEnd)};
if ((!((aReader)->ReadBytesInto((&((result__)->redirectCount())), 2)))) {
aReader->FatalError("Error bulk reading fields from int8_t");
return {};
}
// Sentinel = 'redirectCount | internalRedirectCount'
if ((!((aReader)->ReadSentinel(359534256)))) {
mozilla::ipc::SentinelReadError("Error bulk reading fields from int8_t");
return {};
}
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct ReplacementChannelConfigInit|
//
namespace mozilla {
namespace dom {
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::ReplacementChannelConfigInit>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).classOfService());
// Sentinel = 'classOfService'
(aWriter)->WriteSentinel(704710045);
IPC::WriteParam(aWriter, (aVar).privateBrowsing());
// Sentinel = 'privateBrowsing'
(aWriter)->WriteSentinel(844957255);
IPC::WriteParam(aWriter, (aVar).method());
// Sentinel = 'method'
(aWriter)->WriteSentinel(148308610);
IPC::WriteParam(aWriter, (aVar).referrerInfo());
// Sentinel = 'referrerInfo'
(aWriter)->WriteSentinel(540214506);
IPC::WriteParam(aWriter, (aVar).timedChannelInfo());
// Sentinel = 'timedChannelInfo'
(aWriter)->WriteSentinel(908920409);
IPC::WriteParam(aWriter, (aVar).uploadStream());
// Sentinel = 'uploadStream'
(aWriter)->WriteSentinel(546768114);
IPC::WriteParam(aWriter, (aVar).uploadStreamHasHeaders());
// Sentinel = 'uploadStreamHasHeaders'
(aWriter)->WriteSentinel(1714227402);
IPC::WriteParam(aWriter, (aVar).contentType());
// Sentinel = 'contentType'
(aWriter)->WriteSentinel(465241246);
IPC::WriteParam(aWriter, (aVar).contentLength());
// Sentinel = 'contentLength'
(aWriter)->WriteSentinel(632358238);
(aWriter)->WriteBytes((&((aVar).uploadStreamLength())), 8);
// Sentinel = 'uploadStreamLength'
(aWriter)->WriteSentinel(1178666836);
(aWriter)->WriteBytes((&((aVar).redirectFlags())), 4);
// Sentinel = 'redirectFlags'
(aWriter)->WriteSentinel(620889408);
}
auto ParamTraits<::mozilla::dom::ReplacementChannelConfigInit>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___classOfService = IPC::ReadParam<::mozilla::net::ClassOfService>(aReader);
if (!maybe___classOfService) {
aReader->FatalError("Error deserializing 'classOfService' (ClassOfService) member of 'ReplacementChannelConfigInit'");
return {};
}
auto& _classOfService = *maybe___classOfService;
// Sentinel = 'classOfService'
if ((!((aReader)->ReadSentinel(704710045)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'classOfService' (ClassOfService) member of 'ReplacementChannelConfigInit'");
return {};
}
auto maybe___privateBrowsing = IPC::ReadParam<mozilla::Maybe<bool>>(aReader);
if (!maybe___privateBrowsing) {
aReader->FatalError("Error deserializing 'privateBrowsing' (bool?) member of 'ReplacementChannelConfigInit'");
return {};
}
auto& _privateBrowsing = *maybe___privateBrowsing;
// Sentinel = 'privateBrowsing'
if ((!((aReader)->ReadSentinel(844957255)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'privateBrowsing' (bool?) member of 'ReplacementChannelConfigInit'");
return {};
}
auto maybe___method = IPC::ReadParam<mozilla::Maybe<::nsCString>>(aReader);
if (!maybe___method) {
aReader->FatalError("Error deserializing 'method' (nsCString?) member of 'ReplacementChannelConfigInit'");
return {};
}
auto& _method = *maybe___method;
// Sentinel = 'method'
if ((!((aReader)->ReadSentinel(148308610)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'method' (nsCString?) member of 'ReplacementChannelConfigInit'");
return {};
}
auto maybe___referrerInfo = IPC::ReadParam<RefPtr<::nsIReferrerInfo>>(aReader);
if (!maybe___referrerInfo) {
aReader->FatalError("Error deserializing 'referrerInfo' (nsIReferrerInfo) member of 'ReplacementChannelConfigInit'");
return {};
}
auto& _referrerInfo = *maybe___referrerInfo;
// Sentinel = 'referrerInfo'
if ((!((aReader)->ReadSentinel(540214506)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'referrerInfo' (nsIReferrerInfo) member of 'ReplacementChannelConfigInit'");
return {};
}
auto maybe___timedChannelInfo = IPC::ReadParam<mozilla::Maybe<::mozilla::dom::TimedChannelInfo>>(aReader);
if (!maybe___timedChannelInfo) {
aReader->FatalError("Error deserializing 'timedChannelInfo' (TimedChannelInfo?) member of 'ReplacementChannelConfigInit'");
return {};
}
auto& _timedChannelInfo = *maybe___timedChannelInfo;
// Sentinel = 'timedChannelInfo'
if ((!((aReader)->ReadSentinel(908920409)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'timedChannelInfo' (TimedChannelInfo?) member of 'ReplacementChannelConfigInit'");
return {};
}
auto maybe___uploadStream = IPC::ReadParam<RefPtr<::mozilla::RemoteLazyInputStream>>(aReader);
if (!maybe___uploadStream) {
aReader->FatalError("Error deserializing 'uploadStream' (RemoteLazyInputStream) member of 'ReplacementChannelConfigInit'");
return {};
}
auto& _uploadStream = *maybe___uploadStream;
// Sentinel = 'uploadStream'
if ((!((aReader)->ReadSentinel(546768114)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uploadStream' (RemoteLazyInputStream) member of 'ReplacementChannelConfigInit'");
return {};
}
auto maybe___uploadStreamHasHeaders = IPC::ReadParam<bool>(aReader);
if (!maybe___uploadStreamHasHeaders) {
aReader->FatalError("Error deserializing 'uploadStreamHasHeaders' (bool) member of 'ReplacementChannelConfigInit'");
return {};
}
auto& _uploadStreamHasHeaders = *maybe___uploadStreamHasHeaders;
// Sentinel = 'uploadStreamHasHeaders'
if ((!((aReader)->ReadSentinel(1714227402)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uploadStreamHasHeaders' (bool) member of 'ReplacementChannelConfigInit'");
return {};
}
auto maybe___contentType = IPC::ReadParam<mozilla::Maybe<::nsCString>>(aReader);
if (!maybe___contentType) {
aReader->FatalError("Error deserializing 'contentType' (nsCString?) member of 'ReplacementChannelConfigInit'");
return {};
}
auto& _contentType = *maybe___contentType;
// Sentinel = 'contentType'
if ((!((aReader)->ReadSentinel(465241246)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'contentType' (nsCString?) member of 'ReplacementChannelConfigInit'");
return {};
}
auto maybe___contentLength = IPC::ReadParam<mozilla::Maybe<::nsCString>>(aReader);
if (!maybe___contentLength) {
aReader->FatalError("Error deserializing 'contentLength' (nsCString?) member of 'ReplacementChannelConfigInit'");
return {};
}
auto& _contentLength = *maybe___contentLength;
// Sentinel = 'contentLength'
if ((!((aReader)->ReadSentinel(632358238)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'contentLength' (nsCString?) member of 'ReplacementChannelConfigInit'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
::uint32_t{0},
std::move(_classOfService),
std::move(_privateBrowsing),
std::move(_method),
std::move(_referrerInfo),
std::move(_timedChannelInfo),
std::move(_uploadStream),
::uint64_t{0},
std::move(_uploadStreamHasHeaders),
std::move(_contentType),
std::move(_contentLength)};
if ((!((aReader)->ReadBytesInto((&((result__)->uploadStreamLength())), 8)))) {
aReader->FatalError("Error bulk reading fields from uint64_t");
return {};
}
// Sentinel = 'uploadStreamLength'
if ((!((aReader)->ReadSentinel(1178666836)))) {
mozilla::ipc::SentinelReadError("Error bulk reading fields from uint64_t");
return {};
}
if ((!((aReader)->ReadBytesInto((&((result__)->redirectFlags())), 4)))) {
aReader->FatalError("Error bulk reading fields from uint32_t");
return {};
}
// Sentinel = 'redirectFlags'
if ((!((aReader)->ReadSentinel(620889408)))) {
mozilla::ipc::SentinelReadError("Error bulk reading fields from uint32_t");
return {};
}
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |union IPDLVariantValue|
//
namespace mozilla {
namespace dom {
auto IPDLVariantValue::MaybeDestroy() -> void
{
if ((mType) == (T__None)) {
return;
}
switch (mType) {
case Tbool:
{
(ptr_bool())->~bool__tdef();
break;
}
case Tuint8_t:
{
(ptr_uint8_t())->~uint8_t__tdef();
break;
}
case Tint16_t:
{
(ptr_int16_t())->~int16_t__tdef();
break;
}
case Tuint16_t:
{
(ptr_uint16_t())->~uint16_t__tdef();
break;
}
case Tint32_t:
{
(ptr_int32_t())->~int32_t__tdef();
break;
}
case Tuint32_t:
{
(ptr_uint32_t())->~uint32_t__tdef();
break;
}
case Tfloat:
{
(ptr_float())->~float__tdef();
break;
}
case Tdouble:
{
(ptr_double())->~double__tdef();
break;
}
case TnsID:
{
(ptr_nsID())->~nsID__tdef();
break;
}
case TnsString:
{
(ptr_nsString())->~nsString__tdef();
break;
}
case TnsCString:
{
(ptr_nsCString())->~nsCString__tdef();
break;
}
case TnsIURI:
{
(ptr_nsIURI())->~nsIURI__tdef();
break;
}
case TnsIPrincipal:
{
(ptr_nsIPrincipal())->~nsIPrincipal__tdef();
break;
}
default:
{
mozilla::ipc::LogicError("not reached");
break;
}
}
}
MOZ_IMPLICIT IPDLVariantValue::IPDLVariantValue(const bool& aOther)
{
new (mozilla::KnownNotNull, ptr_bool()) bool(aOther);
mType = Tbool;
}
MOZ_IMPLICIT IPDLVariantValue::IPDLVariantValue(bool&& aOther)
{
new (mozilla::KnownNotNull, ptr_bool()) bool(std::move(aOther));
mType = Tbool;
}
MOZ_IMPLICIT IPDLVariantValue::IPDLVariantValue(const uint8_t& aOther)
{
new (mozilla::KnownNotNull, ptr_uint8_t()) uint8_t(aOther);
mType = Tuint8_t;
}
MOZ_IMPLICIT IPDLVariantValue::IPDLVariantValue(uint8_t&& aOther)
{
new (mozilla::KnownNotNull, ptr_uint8_t()) uint8_t(std::move(aOther));
mType = Tuint8_t;
}
MOZ_IMPLICIT IPDLVariantValue::IPDLVariantValue(const int16_t& aOther)
{
new (mozilla::KnownNotNull, ptr_int16_t()) int16_t(aOther);
mType = Tint16_t;
}
MOZ_IMPLICIT IPDLVariantValue::IPDLVariantValue(int16_t&& aOther)
{
new (mozilla::KnownNotNull, ptr_int16_t()) int16_t(std::move(aOther));
mType = Tint16_t;
}
MOZ_IMPLICIT IPDLVariantValue::IPDLVariantValue(const uint16_t& aOther)
{
new (mozilla::KnownNotNull, ptr_uint16_t()) uint16_t(aOther);
mType = Tuint16_t;
}
MOZ_IMPLICIT IPDLVariantValue::IPDLVariantValue(uint16_t&& aOther)
{
new (mozilla::KnownNotNull, ptr_uint16_t()) uint16_t(std::move(aOther));
mType = Tuint16_t;
}
MOZ_IMPLICIT IPDLVariantValue::IPDLVariantValue(const int32_t& aOther)
{
new (mozilla::KnownNotNull, ptr_int32_t()) int32_t(aOther);
mType = Tint32_t;
}
MOZ_IMPLICIT IPDLVariantValue::IPDLVariantValue(int32_t&& aOther)
{
new (mozilla::KnownNotNull, ptr_int32_t()) int32_t(std::move(aOther));
mType = Tint32_t;
}
MOZ_IMPLICIT IPDLVariantValue::IPDLVariantValue(const uint32_t& aOther)
{
new (mozilla::KnownNotNull, ptr_uint32_t()) uint32_t(aOther);
mType = Tuint32_t;
}
MOZ_IMPLICIT IPDLVariantValue::IPDLVariantValue(uint32_t&& aOther)
{
new (mozilla::KnownNotNull, ptr_uint32_t()) uint32_t(std::move(aOther));
mType = Tuint32_t;
}
MOZ_IMPLICIT IPDLVariantValue::IPDLVariantValue(const float& aOther)
{
new (mozilla::KnownNotNull, ptr_float()) float(aOther);
mType = Tfloat;
}
MOZ_IMPLICIT IPDLVariantValue::IPDLVariantValue(float&& aOther)
{
new (mozilla::KnownNotNull, ptr_float()) float(std::move(aOther));
mType = Tfloat;
}
MOZ_IMPLICIT IPDLVariantValue::IPDLVariantValue(const double& aOther)
{
new (mozilla::KnownNotNull, ptr_double()) double(aOther);
mType = Tdouble;
}
MOZ_IMPLICIT IPDLVariantValue::IPDLVariantValue(double&& aOther)
{
new (mozilla::KnownNotNull, ptr_double()) double(std::move(aOther));
mType = Tdouble;
}
MOZ_IMPLICIT IPDLVariantValue::IPDLVariantValue(const nsID& aOther)
{
new (mozilla::KnownNotNull, ptr_nsID()) nsID(aOther);
mType = TnsID;
}
MOZ_IMPLICIT IPDLVariantValue::IPDLVariantValue(nsID&& aOther)
{
new (mozilla::KnownNotNull, ptr_nsID()) nsID(std::move(aOther));
mType = TnsID;
}
MOZ_IMPLICIT IPDLVariantValue::IPDLVariantValue(const nsString& aOther)
{
new (mozilla::KnownNotNull, ptr_nsString()) nsString(aOther);
mType = TnsString;
}
MOZ_IMPLICIT IPDLVariantValue::IPDLVariantValue(nsString&& aOther)
{
new (mozilla::KnownNotNull, ptr_nsString()) nsString(std::move(aOther));
mType = TnsString;
}
MOZ_IMPLICIT IPDLVariantValue::IPDLVariantValue(const nsCString& aOther)
{
new (mozilla::KnownNotNull, ptr_nsCString()) nsCString(aOther);
mType = TnsCString;
}
MOZ_IMPLICIT IPDLVariantValue::IPDLVariantValue(nsCString&& aOther)
{
new (mozilla::KnownNotNull, ptr_nsCString()) nsCString(std::move(aOther));
mType = TnsCString;
}
MOZ_IMPLICIT IPDLVariantValue::IPDLVariantValue(nsIURI* aOther)
{
new (mozilla::KnownNotNull, ptr_nsIURI()) RefPtr<nsIURI>(aOther);
mType = TnsIURI;
}
MOZ_IMPLICIT IPDLVariantValue::IPDLVariantValue(RefPtr<nsIURI>&& aOther)
{
new (mozilla::KnownNotNull, ptr_nsIURI()) RefPtr<nsIURI>(std::move(aOther));
mType = TnsIURI;
}
MOZ_IMPLICIT IPDLVariantValue::IPDLVariantValue(nsIPrincipal* aOther)
{
new (mozilla::KnownNotNull, ptr_nsIPrincipal()) RefPtr<nsIPrincipal>(aOther);
mType = TnsIPrincipal;
}
MOZ_IMPLICIT IPDLVariantValue::IPDLVariantValue(RefPtr<nsIPrincipal>&& aOther)
{
new (mozilla::KnownNotNull, ptr_nsIPrincipal()) RefPtr<nsIPrincipal>(std::move(aOther));
mType = TnsIPrincipal;
}
MOZ_IMPLICIT IPDLVariantValue::IPDLVariantValue(const IPDLVariantValue& aOther)
{
(aOther).AssertSanity();
switch ((aOther).type()) {
case Tbool:
{
new (mozilla::KnownNotNull, ptr_bool()) bool((aOther).get_bool());
break;
}
case Tuint8_t:
{
new (mozilla::KnownNotNull, ptr_uint8_t()) uint8_t((aOther).get_uint8_t());
break;
}
case Tint16_t:
{
new (mozilla::KnownNotNull, ptr_int16_t()) int16_t((aOther).get_int16_t());
break;
}
case Tuint16_t:
{
new (mozilla::KnownNotNull, ptr_uint16_t()) uint16_t((aOther).get_uint16_t());
break;
}
case Tint32_t:
{
new (mozilla::KnownNotNull, ptr_int32_t()) int32_t((aOther).get_int32_t());
break;
}
case Tuint32_t:
{
new (mozilla::KnownNotNull, ptr_uint32_t()) uint32_t((aOther).get_uint32_t());
break;
}
case Tfloat:
{
new (mozilla::KnownNotNull, ptr_float()) float((aOther).get_float());
break;
}
case Tdouble:
{
new (mozilla::KnownNotNull, ptr_double()) double((aOther).get_double());
break;
}
case TnsID:
{
new (mozilla::KnownNotNull, ptr_nsID()) nsID((aOther).get_nsID());
break;
}
case TnsString:
{
new (mozilla::KnownNotNull, ptr_nsString()) nsString((aOther).get_nsString());
break;
}
case TnsCString:
{
new (mozilla::KnownNotNull, ptr_nsCString()) nsCString((aOther).get_nsCString());
break;
}
case TnsIURI:
{
new (mozilla::KnownNotNull, ptr_nsIURI()) RefPtr<nsIURI>((aOther).get_nsIURI());
break;
}
case TnsIPrincipal:
{
new (mozilla::KnownNotNull, ptr_nsIPrincipal()) RefPtr<nsIPrincipal>((aOther).get_nsIPrincipal());
break;
}
case T__None:
{
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
return;
}
}
mType = (aOther).type();
}
MOZ_IMPLICIT IPDLVariantValue::IPDLVariantValue(IPDLVariantValue&& aOther)
{
(aOther).AssertSanity();
Type t = (aOther).type();
switch (t) {
case Tbool:
{
new (mozilla::KnownNotNull, ptr_bool()) bool(std::move((aOther).get_bool()));
(aOther).MaybeDestroy();
break;
}
case Tuint8_t:
{
new (mozilla::KnownNotNull, ptr_uint8_t()) uint8_t(std::move((aOther).get_uint8_t()));
(aOther).MaybeDestroy();
break;
}
case Tint16_t:
{
new (mozilla::KnownNotNull, ptr_int16_t()) int16_t(std::move((aOther).get_int16_t()));
(aOther).MaybeDestroy();
break;
}
case Tuint16_t:
{
new (mozilla::KnownNotNull, ptr_uint16_t()) uint16_t(std::move((aOther).get_uint16_t()));
(aOther).MaybeDestroy();
break;
}
case Tint32_t:
{
new (mozilla::KnownNotNull, ptr_int32_t()) int32_t(std::move((aOther).get_int32_t()));
(aOther).MaybeDestroy();
break;
}
case Tuint32_t:
{
new (mozilla::KnownNotNull, ptr_uint32_t()) uint32_t(std::move((aOther).get_uint32_t()));
(aOther).MaybeDestroy();
break;
}
case Tfloat:
{
new (mozilla::KnownNotNull, ptr_float()) float(std::move((aOther).get_float()));
(aOther).MaybeDestroy();
break;
}
case Tdouble:
{
new (mozilla::KnownNotNull, ptr_double()) double(std::move((aOther).get_double()));
(aOther).MaybeDestroy();
break;
}
case TnsID:
{
new (mozilla::KnownNotNull, ptr_nsID()) nsID(std::move((aOther).get_nsID()));
(aOther).MaybeDestroy();
break;
}
case TnsString:
{
new (mozilla::KnownNotNull, ptr_nsString()) nsString(std::move((aOther).get_nsString()));
(aOther).MaybeDestroy();
break;
}
case TnsCString:
{
new (mozilla::KnownNotNull, ptr_nsCString()) nsCString(std::move((aOther).get_nsCString()));
(aOther).MaybeDestroy();
break;
}
case TnsIURI:
{
new (mozilla::KnownNotNull, ptr_nsIURI()) RefPtr<nsIURI>(std::move((aOther).get_nsIURI()));
(aOther).MaybeDestroy();
break;
}
case TnsIPrincipal:
{
new (mozilla::KnownNotNull, ptr_nsIPrincipal()) RefPtr<nsIPrincipal>(std::move((aOther).get_nsIPrincipal()));
(aOther).MaybeDestroy();
break;
}
case T__None:
{
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
return;
}
}
(aOther).mType = T__None;
mType = t;
}
IPDLVariantValue::~IPDLVariantValue()
{
MaybeDestroy();
}
auto IPDLVariantValue::operator=(const bool& aRhs) -> IPDLVariantValue&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_bool()) bool(aRhs);
mType = Tbool;
return (*(this));
}
auto IPDLVariantValue::operator=(bool&& aRhs) -> IPDLVariantValue&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_bool()) bool(std::move(aRhs));
mType = Tbool;
return (*(this));
}
auto IPDLVariantValue::operator=(const uint8_t& aRhs) -> IPDLVariantValue&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_uint8_t()) uint8_t(aRhs);
mType = Tuint8_t;
return (*(this));
}
auto IPDLVariantValue::operator=(uint8_t&& aRhs) -> IPDLVariantValue&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_uint8_t()) uint8_t(std::move(aRhs));
mType = Tuint8_t;
return (*(this));
}
auto IPDLVariantValue::operator=(const int16_t& aRhs) -> IPDLVariantValue&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_int16_t()) int16_t(aRhs);
mType = Tint16_t;
return (*(this));
}
auto IPDLVariantValue::operator=(int16_t&& aRhs) -> IPDLVariantValue&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_int16_t()) int16_t(std::move(aRhs));
mType = Tint16_t;
return (*(this));
}
auto IPDLVariantValue::operator=(const uint16_t& aRhs) -> IPDLVariantValue&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_uint16_t()) uint16_t(aRhs);
mType = Tuint16_t;
return (*(this));
}
auto IPDLVariantValue::operator=(uint16_t&& aRhs) -> IPDLVariantValue&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_uint16_t()) uint16_t(std::move(aRhs));
mType = Tuint16_t;
return (*(this));
}
auto IPDLVariantValue::operator=(const int32_t& aRhs) -> IPDLVariantValue&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_int32_t()) int32_t(aRhs);
mType = Tint32_t;
return (*(this));
}
auto IPDLVariantValue::operator=(int32_t&& aRhs) -> IPDLVariantValue&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_int32_t()) int32_t(std::move(aRhs));
mType = Tint32_t;
return (*(this));
}
auto IPDLVariantValue::operator=(const uint32_t& aRhs) -> IPDLVariantValue&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_uint32_t()) uint32_t(aRhs);
mType = Tuint32_t;
return (*(this));
}
auto IPDLVariantValue::operator=(uint32_t&& aRhs) -> IPDLVariantValue&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_uint32_t()) uint32_t(std::move(aRhs));
mType = Tuint32_t;
return (*(this));
}
auto IPDLVariantValue::operator=(const float& aRhs) -> IPDLVariantValue&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_float()) float(aRhs);
mType = Tfloat;
return (*(this));
}
auto IPDLVariantValue::operator=(float&& aRhs) -> IPDLVariantValue&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_float()) float(std::move(aRhs));
mType = Tfloat;
return (*(this));
}
auto IPDLVariantValue::operator=(const double& aRhs) -> IPDLVariantValue&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_double()) double(aRhs);
mType = Tdouble;
return (*(this));
}
auto IPDLVariantValue::operator=(double&& aRhs) -> IPDLVariantValue&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_double()) double(std::move(aRhs));
mType = Tdouble;
return (*(this));
}
auto IPDLVariantValue::operator=(const nsID& aRhs) -> IPDLVariantValue&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_nsID()) nsID(aRhs);
mType = TnsID;
return (*(this));
}
auto IPDLVariantValue::operator=(nsID&& aRhs) -> IPDLVariantValue&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_nsID()) nsID(std::move(aRhs));
mType = TnsID;
return (*(this));
}
auto IPDLVariantValue::operator=(const nsString& aRhs) -> IPDLVariantValue&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_nsString()) nsString(aRhs);
mType = TnsString;
return (*(this));
}
auto IPDLVariantValue::operator=(nsString&& aRhs) -> IPDLVariantValue&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_nsString()) nsString(std::move(aRhs));
mType = TnsString;
return (*(this));
}
auto IPDLVariantValue::operator=(const nsCString& aRhs) -> IPDLVariantValue&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_nsCString()) nsCString(aRhs);
mType = TnsCString;
return (*(this));
}
auto IPDLVariantValue::operator=(nsCString&& aRhs) -> IPDLVariantValue&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_nsCString()) nsCString(std::move(aRhs));
mType = TnsCString;
return (*(this));
}
auto IPDLVariantValue::operator=(nsIURI* aRhs) -> IPDLVariantValue&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_nsIURI()) RefPtr<nsIURI>(aRhs);
mType = TnsIURI;
return (*(this));
}
auto IPDLVariantValue::operator=(RefPtr<nsIURI>&& aRhs) -> IPDLVariantValue&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_nsIURI()) RefPtr<nsIURI>(std::move(aRhs));
mType = TnsIURI;
return (*(this));
}
auto IPDLVariantValue::operator=(nsIPrincipal* aRhs) -> IPDLVariantValue&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_nsIPrincipal()) RefPtr<nsIPrincipal>(aRhs);
mType = TnsIPrincipal;
return (*(this));
}
auto IPDLVariantValue::operator=(RefPtr<nsIPrincipal>&& aRhs) -> IPDLVariantValue&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_nsIPrincipal()) RefPtr<nsIPrincipal>(std::move(aRhs));
mType = TnsIPrincipal;
return (*(this));
}
auto IPDLVariantValue::operator=(const IPDLVariantValue& aRhs) -> IPDLVariantValue&
{
(aRhs).AssertSanity();
Type t = (aRhs).type();
switch (t) {
case Tbool:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_bool()) bool((aRhs).get_bool());
break;
}
case Tuint8_t:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_uint8_t()) uint8_t((aRhs).get_uint8_t());
break;
}
case Tint16_t:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_int16_t()) int16_t((aRhs).get_int16_t());
break;
}
case Tuint16_t:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_uint16_t()) uint16_t((aRhs).get_uint16_t());
break;
}
case Tint32_t:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_int32_t()) int32_t((aRhs).get_int32_t());
break;
}
case Tuint32_t:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_uint32_t()) uint32_t((aRhs).get_uint32_t());
break;
}
case Tfloat:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_float()) float((aRhs).get_float());
break;
}
case Tdouble:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_double()) double((aRhs).get_double());
break;
}
case TnsID:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_nsID()) nsID((aRhs).get_nsID());
break;
}
case TnsString:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_nsString()) nsString((aRhs).get_nsString());
break;
}
case TnsCString:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_nsCString()) nsCString((aRhs).get_nsCString());
break;
}
case TnsIURI:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_nsIURI()) RefPtr<nsIURI>((aRhs).get_nsIURI());
break;
}
case TnsIPrincipal:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_nsIPrincipal()) RefPtr<nsIPrincipal>((aRhs).get_nsIPrincipal());
break;
}
case T__None:
{
MaybeDestroy();
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
break;
}
}
mType = t;
return (*(this));
}
auto IPDLVariantValue::operator=(IPDLVariantValue&& aRhs) -> IPDLVariantValue&
{
(aRhs).AssertSanity();
Type t = (aRhs).type();
switch (t) {
case Tbool:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_bool()) bool(std::move((aRhs).get_bool()));
(aRhs).MaybeDestroy();
break;
}
case Tuint8_t:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_uint8_t()) uint8_t(std::move((aRhs).get_uint8_t()));
(aRhs).MaybeDestroy();
break;
}
case Tint16_t:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_int16_t()) int16_t(std::move((aRhs).get_int16_t()));
(aRhs).MaybeDestroy();
break;
}
case Tuint16_t:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_uint16_t()) uint16_t(std::move((aRhs).get_uint16_t()));
(aRhs).MaybeDestroy();
break;
}
case Tint32_t:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_int32_t()) int32_t(std::move((aRhs).get_int32_t()));
(aRhs).MaybeDestroy();
break;
}
case Tuint32_t:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_uint32_t()) uint32_t(std::move((aRhs).get_uint32_t()));
(aRhs).MaybeDestroy();
break;
}
case Tfloat:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_float()) float(std::move((aRhs).get_float()));
(aRhs).MaybeDestroy();
break;
}
case Tdouble:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_double()) double(std::move((aRhs).get_double()));
(aRhs).MaybeDestroy();
break;
}
case TnsID:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_nsID()) nsID(std::move((aRhs).get_nsID()));
(aRhs).MaybeDestroy();
break;
}
case TnsString:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_nsString()) nsString(std::move((aRhs).get_nsString()));
(aRhs).MaybeDestroy();
break;
}
case TnsCString:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_nsCString()) nsCString(std::move((aRhs).get_nsCString()));
(aRhs).MaybeDestroy();
break;
}
case TnsIURI:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_nsIURI()) RefPtr<nsIURI>(std::move((aRhs).get_nsIURI()));
(aRhs).MaybeDestroy();
break;
}
case TnsIPrincipal:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_nsIPrincipal()) RefPtr<nsIPrincipal>(std::move((aRhs).get_nsIPrincipal()));
(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::IPDLVariantValue>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
typedef ::mozilla::dom::IPDLVariantValue union__;
int type = (aVar).type();
IPC::WriteParam(aWriter, type);
// Sentinel = 'IPDLVariantValue'
(aWriter)->WriteSentinel(801310204);
switch (type) {
case union__::Tbool:
{
IPC::WriteParam(aWriter, (aVar).get_bool());
// Sentinel = 'Tbool'
(aWriter)->WriteSentinel(96993793);
return;
}
case union__::Tuint8_t:
{
IPC::WriteParam(aWriter, (aVar).get_uint8_t());
// Sentinel = 'Tuint8_t'
(aWriter)->WriteSentinel(237044512);
return;
}
case union__::Tint16_t:
{
IPC::WriteParam(aWriter, (aVar).get_int16_t());
// Sentinel = 'Tint16_t'
(aWriter)->WriteSentinel(217514714);
return;
}
case union__::Tuint16_t:
{
IPC::WriteParam(aWriter, (aVar).get_uint16_t());
// Sentinel = 'Tuint16_t'
(aWriter)->WriteSentinel(284427087);
return;
}
case union__::Tint32_t:
{
IPC::WriteParam(aWriter, (aVar).get_int32_t());
// Sentinel = 'Tint32_t'
(aWriter)->WriteSentinel(217252568);
return;
}
case union__::Tuint32_t:
{
IPC::WriteParam(aWriter, (aVar).get_uint32_t());
// Sentinel = 'Tuint32_t'
(aWriter)->WriteSentinel(284164941);
return;
}
case union__::Tfloat:
{
IPC::WriteParam(aWriter, (aVar).get_float());
// Sentinel = 'Tfloat'
(aWriter)->WriteSentinel(137298539);
return;
}
case union__::Tdouble:
{
IPC::WriteParam(aWriter, (aVar).get_double());
// Sentinel = 'Tdouble'
(aWriter)->WriteSentinel(185402064);
return;
}
case union__::TnsID:
{
IPC::WriteParam(aWriter, (aVar).get_nsID());
// Sentinel = 'TnsID'
(aWriter)->WriteSentinel(93323715);
return;
}
case union__::TnsString:
{
IPC::WriteParam(aWriter, (aVar).get_nsString());
// Sentinel = 'TnsString'
(aWriter)->WriteSentinel(302908333);
return;
}
case union__::TnsCString:
{
IPC::WriteParam(aWriter, (aVar).get_nsCString());
// Sentinel = 'TnsCString'
(aWriter)->WriteSentinel(353960944);
return;
}
case union__::TnsIURI:
{
IPC::WriteParam(aWriter, (aVar).get_nsIURI());
// Sentinel = 'TnsIURI'
(aWriter)->WriteSentinel(171311727);
return;
}
case union__::TnsIPrincipal:
{
IPC::WriteParam(aWriter, (aVar).get_nsIPrincipal());
// Sentinel = 'TnsIPrincipal'
(aWriter)->WriteSentinel(589825313);
return;
}
default:
{
aWriter->FatalError("unknown variant of union IPDLVariantValue");
return;
}
}
}
auto ParamTraits<::mozilla::dom::IPDLVariantValue>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
typedef ::mozilla::dom::IPDLVariantValue union__;
auto maybe__type = IPC::ReadParam<int>(aReader);
if (!maybe__type) {
aReader->FatalError("Error deserializing type of union IPDLVariantValue");
return {};
}
auto& type = *maybe__type;
// Sentinel = 'IPDLVariantValue'
if ((!((aReader)->ReadSentinel(801310204)))) {
mozilla::ipc::SentinelReadError("Error deserializing type of union IPDLVariantValue");
return {};
}
switch (type) {
case union__::Tbool:
{
auto maybe__tmp = IPC::ReadParam<bool>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant Tbool of union IPDLVariantValue");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'Tbool'
if ((!((aReader)->ReadSentinel(96993793)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant Tbool of union IPDLVariantValue");
return {};
}
return std::move(tmp);
}
case union__::Tuint8_t:
{
auto maybe__tmp = IPC::ReadParam<::uint8_t>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant Tuint8_t of union IPDLVariantValue");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'Tuint8_t'
if ((!((aReader)->ReadSentinel(237044512)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant Tuint8_t of union IPDLVariantValue");
return {};
}
return std::move(tmp);
}
case union__::Tint16_t:
{
auto maybe__tmp = IPC::ReadParam<::int16_t>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant Tint16_t of union IPDLVariantValue");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'Tint16_t'
if ((!((aReader)->ReadSentinel(217514714)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant Tint16_t of union IPDLVariantValue");
return {};
}
return std::move(tmp);
}
case union__::Tuint16_t:
{
auto maybe__tmp = IPC::ReadParam<::uint16_t>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant Tuint16_t of union IPDLVariantValue");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'Tuint16_t'
if ((!((aReader)->ReadSentinel(284427087)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant Tuint16_t of union IPDLVariantValue");
return {};
}
return std::move(tmp);
}
case union__::Tint32_t:
{
auto maybe__tmp = IPC::ReadParam<::int32_t>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant Tint32_t of union IPDLVariantValue");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'Tint32_t'
if ((!((aReader)->ReadSentinel(217252568)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant Tint32_t of union IPDLVariantValue");
return {};
}
return std::move(tmp);
}
case union__::Tuint32_t:
{
auto maybe__tmp = IPC::ReadParam<::uint32_t>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant Tuint32_t of union IPDLVariantValue");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'Tuint32_t'
if ((!((aReader)->ReadSentinel(284164941)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant Tuint32_t of union IPDLVariantValue");
return {};
}
return std::move(tmp);
}
case union__::Tfloat:
{
auto maybe__tmp = IPC::ReadParam<float>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant Tfloat of union IPDLVariantValue");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'Tfloat'
if ((!((aReader)->ReadSentinel(137298539)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant Tfloat of union IPDLVariantValue");
return {};
}
return std::move(tmp);
}
case union__::Tdouble:
{
auto maybe__tmp = IPC::ReadParam<double>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant Tdouble of union IPDLVariantValue");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'Tdouble'
if ((!((aReader)->ReadSentinel(185402064)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant Tdouble of union IPDLVariantValue");
return {};
}
return std::move(tmp);
}
case union__::TnsID:
{
auto maybe__tmp = IPC::ReadParam<::nsID>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TnsID of union IPDLVariantValue");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TnsID'
if ((!((aReader)->ReadSentinel(93323715)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TnsID of union IPDLVariantValue");
return {};
}
return std::move(tmp);
}
case union__::TnsString:
{
auto maybe__tmp = IPC::ReadParam<::nsString>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TnsString of union IPDLVariantValue");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TnsString'
if ((!((aReader)->ReadSentinel(302908333)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TnsString of union IPDLVariantValue");
return {};
}
return std::move(tmp);
}
case union__::TnsCString:
{
auto maybe__tmp = IPC::ReadParam<::nsCString>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TnsCString of union IPDLVariantValue");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TnsCString'
if ((!((aReader)->ReadSentinel(353960944)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TnsCString of union IPDLVariantValue");
return {};
}
return std::move(tmp);
}
case union__::TnsIURI:
{
auto maybe__tmp = IPC::ReadParam<RefPtr<::nsIURI>>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TnsIURI of union IPDLVariantValue");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TnsIURI'
if ((!((aReader)->ReadSentinel(171311727)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TnsIURI of union IPDLVariantValue");
return {};
}
return std::move(tmp);
}
case union__::TnsIPrincipal:
{
auto maybe__tmp = IPC::ReadParam<RefPtr<::nsIPrincipal>>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TnsIPrincipal of union IPDLVariantValue");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TnsIPrincipal'
if ((!((aReader)->ReadSentinel(589825313)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TnsIPrincipal of union IPDLVariantValue");
return {};
}
return std::move(tmp);
}
default:
{
aReader->FatalError("unknown variant of union IPDLVariantValue");
return {};
}
}
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct IDPLVariant|
//
namespace mozilla {
namespace dom {
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::IDPLVariant>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).data());
// Sentinel = 'data'
(aWriter)->WriteSentinel(67109275);
(aWriter)->WriteBytes((&((aVar).type())), 4);
// Sentinel = 'type'
(aWriter)->WriteSentinel(75760067);
}
auto ParamTraits<::mozilla::dom::IDPLVariant>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___data = IPC::ReadParam<::mozilla::dom::IPDLVariantValue>(aReader);
if (!maybe___data) {
aReader->FatalError("Error deserializing 'data' (IPDLVariantValue) member of 'IDPLVariant'");
return {};
}
auto& _data = *maybe___data;
// Sentinel = 'data'
if ((!((aReader)->ReadSentinel(67109275)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'data' (IPDLVariantValue) member of 'IDPLVariant'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
::uint32_t{0},
std::move(_data)};
if ((!((aReader)->ReadBytesInto((&((result__)->type())), 4)))) {
aReader->FatalError("Error bulk reading fields from uint32_t");
return {};
}
// Sentinel = 'type'
if ((!((aReader)->ReadSentinel(75760067)))) {
mozilla::ipc::SentinelReadError("Error bulk reading fields from uint32_t");
return {};
}
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct IPDLProperty|
//
namespace mozilla {
namespace dom {
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::IPDLProperty>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).name());
// Sentinel = 'name'
(aWriter)->WriteSentinel(69075362);
IPC::WriteParam(aWriter, (aVar).value());
// Sentinel = 'value'
(aWriter)->WriteSentinel(107610654);
}
auto ParamTraits<::mozilla::dom::IPDLProperty>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___name = IPC::ReadParam<::nsString>(aReader);
if (!maybe___name) {
aReader->FatalError("Error deserializing 'name' (nsString) member of 'IPDLProperty'");
return {};
}
auto& _name = *maybe___name;
// Sentinel = 'name'
if ((!((aReader)->ReadSentinel(69075362)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'name' (nsString) member of 'IPDLProperty'");
return {};
}
auto maybe___value = IPC::ReadParam<RefPtr<::nsIVariant>>(aReader);
if (!maybe___value) {
aReader->FatalError("Error deserializing 'value' (nsIVariant) member of 'IPDLProperty'");
return {};
}
auto& _value = *maybe___value;
// Sentinel = 'value'
if ((!((aReader)->ReadSentinel(107610654)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'value' (nsIVariant) member of 'IPDLProperty'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_name),
std::move(_value)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct ParentShowInfo|
//
namespace mozilla {
namespace dom {
auto ParentShowInfo::StaticAssertions() const -> void
{
static_assert(
(offsetof(ParentShowInfo, widgetRounding_) - offsetof(ParentShowInfo, dpi_)) == 4,
"Bad assumptions about field layout!");
}
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::ParentShowInfo>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).name());
// Sentinel = 'name'
(aWriter)->WriteSentinel(69075362);
IPC::WriteParam(aWriter, (aVar).fakeShowInfo());
// Sentinel = 'fakeShowInfo'
(aWriter)->WriteSentinel(515900613);
IPC::WriteParam(aWriter, (aVar).isTransparent());
// Sentinel = 'isTransparent'
(aWriter)->WriteSentinel(631244143);
(aWriter)->WriteBytes((&((aVar).defaultScale())), 8);
// Sentinel = 'defaultScale'
(aWriter)->WriteSentinel(525796558);
(aWriter)->WriteBytes((&((aVar).dpi())), 8);
// Sentinel = 'dpi | widgetRounding'
(aWriter)->WriteSentinel(1322977220);
}
auto ParamTraits<::mozilla::dom::ParentShowInfo>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___name = IPC::ReadParam<::nsString>(aReader);
if (!maybe___name) {
aReader->FatalError("Error deserializing 'name' (nsString) member of 'ParentShowInfo'");
return {};
}
auto& _name = *maybe___name;
// Sentinel = 'name'
if ((!((aReader)->ReadSentinel(69075362)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'name' (nsString) member of 'ParentShowInfo'");
return {};
}
auto maybe___fakeShowInfo = IPC::ReadParam<bool>(aReader);
if (!maybe___fakeShowInfo) {
aReader->FatalError("Error deserializing 'fakeShowInfo' (bool) member of 'ParentShowInfo'");
return {};
}
auto& _fakeShowInfo = *maybe___fakeShowInfo;
// Sentinel = 'fakeShowInfo'
if ((!((aReader)->ReadSentinel(515900613)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'fakeShowInfo' (bool) member of 'ParentShowInfo'");
return {};
}
auto maybe___isTransparent = IPC::ReadParam<bool>(aReader);
if (!maybe___isTransparent) {
aReader->FatalError("Error deserializing 'isTransparent' (bool) member of 'ParentShowInfo'");
return {};
}
auto& _isTransparent = *maybe___isTransparent;
// Sentinel = 'isTransparent'
if ((!((aReader)->ReadSentinel(631244143)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'isTransparent' (bool) member of 'ParentShowInfo'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_name),
std::move(_fakeShowInfo),
std::move(_isTransparent),
float{0},
::int32_t{0},
double{0}};
if ((!((aReader)->ReadBytesInto((&((result__)->defaultScale())), 8)))) {
aReader->FatalError("Error bulk reading fields from double");
return {};
}
// Sentinel = 'defaultScale'
if ((!((aReader)->ReadSentinel(525796558)))) {
mozilla::ipc::SentinelReadError("Error bulk reading fields from double");
return {};
}
if ((!((aReader)->ReadBytesInto((&((result__)->dpi())), 8)))) {
aReader->FatalError("Error bulk reading fields from float");
return {};
}
// Sentinel = 'dpi | widgetRounding'
if ((!((aReader)->ReadSentinel(1322977220)))) {
mozilla::ipc::SentinelReadError("Error bulk reading fields from float");
return {};
}
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct OwnerShowInfo|
//
namespace mozilla {
namespace dom {
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::OwnerShowInfo>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).size());
// Sentinel = 'size'
(aWriter)->WriteSentinel(73662908);
IPC::WriteParam(aWriter, (aVar).scrollbarPreference());
// Sentinel = 'scrollbarPreference'
(aWriter)->WriteSentinel(1316030404);
IPC::WriteParam(aWriter, (aVar).sizeMode());
// Sentinel = 'sizeMode'
(aWriter)->WriteSentinel(251790145);
}
auto ParamTraits<::mozilla::dom::OwnerShowInfo>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___size = IPC::ReadParam<::mozilla::LayoutDeviceIntSize>(aReader);
if (!maybe___size) {
aReader->FatalError("Error deserializing 'size' (LayoutDeviceIntSize) member of 'OwnerShowInfo'");
return {};
}
auto& _size = *maybe___size;
// Sentinel = 'size'
if ((!((aReader)->ReadSentinel(73662908)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'size' (LayoutDeviceIntSize) member of 'OwnerShowInfo'");
return {};
}
auto maybe___scrollbarPreference = IPC::ReadParam<::mozilla::ScrollbarPreference>(aReader);
if (!maybe___scrollbarPreference) {
aReader->FatalError("Error deserializing 'scrollbarPreference' (ScrollbarPreference) member of 'OwnerShowInfo'");
return {};
}
auto& _scrollbarPreference = *maybe___scrollbarPreference;
// Sentinel = 'scrollbarPreference'
if ((!((aReader)->ReadSentinel(1316030404)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'scrollbarPreference' (ScrollbarPreference) member of 'OwnerShowInfo'");
return {};
}
auto maybe___sizeMode = IPC::ReadParam<::nsSizeMode>(aReader);
if (!maybe___sizeMode) {
aReader->FatalError("Error deserializing 'sizeMode' (nsSizeMode) member of 'OwnerShowInfo'");
return {};
}
auto& _sizeMode = *maybe___sizeMode;
// Sentinel = 'sizeMode'
if ((!((aReader)->ReadSentinel(251790145)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'sizeMode' (nsSizeMode) member of 'OwnerShowInfo'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_size),
std::move(_scrollbarPreference),
std::move(_sizeMode)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct IPCImage|
//
namespace mozilla {
namespace dom {
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::IPCImage>::Write(
IPC::MessageWriter* aWriter,
paramType&& aVar) -> void
{
IPC::WriteParam(aWriter, std::move((aVar).data()));
// Sentinel = 'data'
(aWriter)->WriteSentinel(67109275);
IPC::WriteParam(aWriter, (aVar).format());
// Sentinel = 'format'
(aWriter)->WriteSentinel(148505226);
IPC::WriteParam(aWriter, (aVar).size());
// Sentinel = 'size'
(aWriter)->WriteSentinel(73662908);
(aWriter)->WriteBytes((&((aVar).stride())), 4);
// Sentinel = 'stride'
(aWriter)->WriteSentinel(153879180);
}
auto ParamTraits<::mozilla::dom::IPCImage>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___data = IPC::ReadParam<::mozilla::ipc::BigBuffer>(aReader);
if (!maybe___data) {
aReader->FatalError("Error deserializing 'data' (BigBuffer) member of 'IPCImage'");
return {};
}
auto& _data = *maybe___data;
// Sentinel = 'data'
if ((!((aReader)->ReadSentinel(67109275)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'data' (BigBuffer) member of 'IPCImage'");
return {};
}
auto maybe___format = IPC::ReadParam<::mozilla::gfx::SurfaceFormat>(aReader);
if (!maybe___format) {
aReader->FatalError("Error deserializing 'format' (SurfaceFormat) member of 'IPCImage'");
return {};
}
auto& _format = *maybe___format;
// Sentinel = 'format'
if ((!((aReader)->ReadSentinel(148505226)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'format' (SurfaceFormat) member of 'IPCImage'");
return {};
}
auto maybe___size = IPC::ReadParam<::mozilla::ImageIntSize>(aReader);
if (!maybe___size) {
aReader->FatalError("Error deserializing 'size' (ImageIntSize) member of 'IPCImage'");
return {};
}
auto& _size = *maybe___size;
// Sentinel = 'size'
if ((!((aReader)->ReadSentinel(73662908)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'size' (ImageIntSize) member of 'IPCImage'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_data),
::uint32_t{0},
std::move(_format),
std::move(_size)};
if ((!((aReader)->ReadBytesInto((&((result__)->stride())), 4)))) {
aReader->FatalError("Error bulk reading fields from uint32_t");
return {};
}
// Sentinel = 'stride'
if ((!((aReader)->ReadSentinel(153879180)))) {
mozilla::ipc::SentinelReadError("Error bulk reading fields from uint32_t");
return {};
}
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct IPCNotificationOptions|
//
namespace mozilla {
namespace dom {
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::IPCNotificationOptions>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
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).requireInteraction());
// Sentinel = 'requireInteraction'
(aWriter)->WriteSentinel(1196361598);
IPC::WriteParam(aWriter, (aVar).silent());
// Sentinel = 'silent'
(aWriter)->WriteSentinel(150209168);
IPC::WriteParam(aWriter, (aVar).vibrate());
// Sentinel = 'vibrate'
(aWriter)->WriteSentinel(198771438);
IPC::WriteParam(aWriter, (aVar).dataSerialized());
// Sentinel = 'dataSerialized'
(aWriter)->WriteSentinel(703202727);
IPC::WriteParam(aWriter, (aVar).behavior());
// Sentinel = 'behavior'
(aWriter)->WriteSentinel(244515665);
}
auto ParamTraits<::mozilla::dom::IPCNotificationOptions>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___title = IPC::ReadParam<::nsString>(aReader);
if (!maybe___title) {
aReader->FatalError("Error deserializing 'title' (nsString) member of 'IPCNotificationOptions'");
return {};
}
auto& _title = *maybe___title;
// Sentinel = 'title'
if ((!((aReader)->ReadSentinel(109445667)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'title' (nsString) member of 'IPCNotificationOptions'");
return {};
}
auto maybe___dir = IPC::ReadParam<::mozilla::dom::NotificationDirection>(aReader);
if (!maybe___dir) {
aReader->FatalError("Error deserializing 'dir' (NotificationDirection) member of 'IPCNotificationOptions'");
return {};
}
auto& _dir = *maybe___dir;
// Sentinel = 'dir'
if ((!((aReader)->ReadSentinel(41091392)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'dir' (NotificationDirection) member of 'IPCNotificationOptions'");
return {};
}
auto maybe___lang = IPC::ReadParam<::nsString>(aReader);
if (!maybe___lang) {
aReader->FatalError("Error deserializing 'lang' (nsString) member of 'IPCNotificationOptions'");
return {};
}
auto& _lang = *maybe___lang;
// Sentinel = 'lang'
if ((!((aReader)->ReadSentinel(68813219)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'lang' (nsString) member of 'IPCNotificationOptions'");
return {};
}
auto maybe___body = IPC::ReadParam<::nsString>(aReader);
if (!maybe___body) {
aReader->FatalError("Error deserializing 'body' (nsString) member of 'IPCNotificationOptions'");
return {};
}
auto& _body = *maybe___body;
// Sentinel = 'body'
if ((!((aReader)->ReadSentinel(68813231)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'body' (nsString) member of 'IPCNotificationOptions'");
return {};
}
auto maybe___tag = IPC::ReadParam<::nsString>(aReader);
if (!maybe___tag) {
aReader->FatalError("Error deserializing 'tag' (nsString) member of 'IPCNotificationOptions'");
return {};
}
auto& _tag = *maybe___tag;
// Sentinel = 'tag'
if ((!((aReader)->ReadSentinel(42467645)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'tag' (nsString) member of 'IPCNotificationOptions'");
return {};
}
auto maybe___icon = IPC::ReadParam<::nsString>(aReader);
if (!maybe___icon) {
aReader->FatalError("Error deserializing 'icon' (nsString) member of 'IPCNotificationOptions'");
return {};
}
auto& _icon = *maybe___icon;
// Sentinel = 'icon'
if ((!((aReader)->ReadSentinel(69009834)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'icon' (nsString) member of 'IPCNotificationOptions'");
return {};
}
auto maybe___requireInteraction = IPC::ReadParam<bool>(aReader);
if (!maybe___requireInteraction) {
aReader->FatalError("Error deserializing 'requireInteraction' (bool) member of 'IPCNotificationOptions'");
return {};
}
auto& _requireInteraction = *maybe___requireInteraction;
// Sentinel = 'requireInteraction'
if ((!((aReader)->ReadSentinel(1196361598)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'requireInteraction' (bool) member of 'IPCNotificationOptions'");
return {};
}
auto maybe___silent = IPC::ReadParam<bool>(aReader);
if (!maybe___silent) {
aReader->FatalError("Error deserializing 'silent' (bool) member of 'IPCNotificationOptions'");
return {};
}
auto& _silent = *maybe___silent;
// Sentinel = 'silent'
if ((!((aReader)->ReadSentinel(150209168)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'silent' (bool) member of 'IPCNotificationOptions'");
return {};
}
auto maybe___vibrate = IPC::ReadParam<nsTArray<::uint32_t>>(aReader);
if (!maybe___vibrate) {
aReader->FatalError("Error deserializing 'vibrate' (uint32_t[]) member of 'IPCNotificationOptions'");
return {};
}
auto& _vibrate = *maybe___vibrate;
// Sentinel = 'vibrate'
if ((!((aReader)->ReadSentinel(198771438)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'vibrate' (uint32_t[]) member of 'IPCNotificationOptions'");
return {};
}
auto maybe___dataSerialized = IPC::ReadParam<::nsString>(aReader);
if (!maybe___dataSerialized) {
aReader->FatalError("Error deserializing 'dataSerialized' (nsString) member of 'IPCNotificationOptions'");
return {};
}
auto& _dataSerialized = *maybe___dataSerialized;
// Sentinel = 'dataSerialized'
if ((!((aReader)->ReadSentinel(703202727)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'dataSerialized' (nsString) member of 'IPCNotificationOptions'");
return {};
}
auto maybe___behavior = IPC::ReadParam<::mozilla::dom::NotificationBehavior>(aReader);
if (!maybe___behavior) {
aReader->FatalError("Error deserializing 'behavior' (NotificationBehavior) member of 'IPCNotificationOptions'");
return {};
}
auto& _behavior = *maybe___behavior;
// Sentinel = 'behavior'
if ((!((aReader)->ReadSentinel(244515665)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'behavior' (NotificationBehavior) member of 'IPCNotificationOptions'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_title),
std::move(_dir),
std::move(_lang),
std::move(_body),
std::move(_tag),
std::move(_icon),
std::move(_requireInteraction),
std::move(_silent),
std::move(_vibrate),
std::move(_dataSerialized),
std::move(_behavior)};
return result__;
}
} // namespace IPC