Copy as Markdown
Other Tools
//
// Automatically generated by ipdlc.
// Edit at your own risk
//
#include "mozilla/dom/FetchIPCTypes.h"
#include "mozilla/ipc/TransportSecurityInfoUtils.h"
#include "mozilla/dom/FetchIPCTypes.h"
#include "mozilla/dom/PropertyBagUtils.h"
#include "mozilla/dom/ReferrerInfoUtils.h"
#include "mozilla/ipc/URIUtils.h"
#include "mozilla/net/CacheInfoIPCTypes.h"
#include "mozilla/AntiTrackingIPCUtils.h"
#include "mozilla/net/ClassOfService.h"
#include "mozilla/dom/FetchTypes.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 HeadersEntry|
//
namespace mozilla {
namespace dom {
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::HeadersEntry>::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::HeadersEntry>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___name = IPC::ReadParam<::nsCString>(aReader);
if (!maybe___name) {
aReader->FatalError("Error deserializing 'name' (nsCString) member of 'HeadersEntry'");
return {};
}
auto& _name = *maybe___name;
// Sentinel = 'name'
if ((!((aReader)->ReadSentinel(69075362)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'name' (nsCString) member of 'HeadersEntry'");
return {};
}
auto maybe___value = IPC::ReadParam<::nsCString>(aReader);
if (!maybe___value) {
aReader->FatalError("Error deserializing 'value' (nsCString) member of 'HeadersEntry'");
return {};
}
auto& _value = *maybe___value;
// Sentinel = 'value'
if ((!((aReader)->ReadSentinel(107610654)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'value' (nsCString) member of 'HeadersEntry'");
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 ParentToParentStream|
//
namespace mozilla {
namespace dom {
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::ParentToParentStream>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).uuid());
// Sentinel = 'uuid'
(aWriter)->WriteSentinel(74252728);
}
auto ParamTraits<::mozilla::dom::ParentToParentStream>::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 'ParentToParentStream'");
return {};
}
auto& _uuid = *maybe___uuid;
// Sentinel = 'uuid'
if ((!((aReader)->ReadSentinel(74252728)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uuid' (nsID) member of 'ParentToParentStream'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_uuid)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |union ParentToChildStream|
//
namespace mozilla {
namespace dom {
auto ParentToChildStream::MaybeDestroy() -> void
{
if ((mType) == (T__None)) {
return;
}
switch (mType) {
case TRemoteLazyInputStream:
{
(ptr_RemoteLazyInputStream())->~RemoteLazyInputStream__tdef();
break;
}
case TIPCStream:
{
(ptr_IPCStream())->~IPCStream__tdef();
break;
}
default:
{
mozilla::ipc::LogicError("not reached");
break;
}
}
}
MOZ_IMPLICIT ParentToChildStream::ParentToChildStream(RemoteLazyInputStream* aOther)
{
new (mozilla::KnownNotNull, ptr_RemoteLazyInputStream()) RefPtr<RemoteLazyInputStream>(aOther);
mType = TRemoteLazyInputStream;
}
MOZ_IMPLICIT ParentToChildStream::ParentToChildStream(RefPtr<RemoteLazyInputStream>&& aOther)
{
new (mozilla::KnownNotNull, ptr_RemoteLazyInputStream()) RefPtr<RemoteLazyInputStream>(std::move(aOther));
mType = TRemoteLazyInputStream;
}
MOZ_IMPLICIT ParentToChildStream::ParentToChildStream(const IPCStream& aOther)
{
new (mozilla::KnownNotNull, ptr_IPCStream()) IPCStream(aOther);
mType = TIPCStream;
}
MOZ_IMPLICIT ParentToChildStream::ParentToChildStream(IPCStream&& aOther)
{
new (mozilla::KnownNotNull, ptr_IPCStream()) IPCStream(std::move(aOther));
mType = TIPCStream;
}
MOZ_IMPLICIT ParentToChildStream::ParentToChildStream(const ParentToChildStream& aOther)
{
(aOther).AssertSanity();
switch ((aOther).type()) {
case TRemoteLazyInputStream:
{
new (mozilla::KnownNotNull, ptr_RemoteLazyInputStream()) RefPtr<RemoteLazyInputStream>((aOther).get_RemoteLazyInputStream());
break;
}
case TIPCStream:
{
new (mozilla::KnownNotNull, ptr_IPCStream()) IPCStream((aOther).get_IPCStream());
break;
}
case T__None:
{
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
return;
}
}
mType = (aOther).type();
}
MOZ_IMPLICIT ParentToChildStream::ParentToChildStream(ParentToChildStream&& aOther)
{
(aOther).AssertSanity();
Type t = (aOther).type();
switch (t) {
case TRemoteLazyInputStream:
{
new (mozilla::KnownNotNull, ptr_RemoteLazyInputStream()) RefPtr<RemoteLazyInputStream>(std::move((aOther).get_RemoteLazyInputStream()));
(aOther).MaybeDestroy();
break;
}
case TIPCStream:
{
new (mozilla::KnownNotNull, ptr_IPCStream()) IPCStream(std::move((aOther).get_IPCStream()));
(aOther).MaybeDestroy();
break;
}
case T__None:
{
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
return;
}
}
(aOther).mType = T__None;
mType = t;
}
ParentToChildStream::~ParentToChildStream()
{
MaybeDestroy();
}
auto ParentToChildStream::operator=(RemoteLazyInputStream* aRhs) -> ParentToChildStream&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_RemoteLazyInputStream()) RefPtr<RemoteLazyInputStream>(aRhs);
mType = TRemoteLazyInputStream;
return (*(this));
}
auto ParentToChildStream::operator=(RefPtr<RemoteLazyInputStream>&& aRhs) -> ParentToChildStream&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_RemoteLazyInputStream()) RefPtr<RemoteLazyInputStream>(std::move(aRhs));
mType = TRemoteLazyInputStream;
return (*(this));
}
auto ParentToChildStream::operator=(const IPCStream& aRhs) -> ParentToChildStream&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_IPCStream()) IPCStream(aRhs);
mType = TIPCStream;
return (*(this));
}
auto ParentToChildStream::operator=(IPCStream&& aRhs) -> ParentToChildStream&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_IPCStream()) IPCStream(std::move(aRhs));
mType = TIPCStream;
return (*(this));
}
auto ParentToChildStream::operator=(const ParentToChildStream& aRhs) -> ParentToChildStream&
{
(aRhs).AssertSanity();
Type t = (aRhs).type();
switch (t) {
case TRemoteLazyInputStream:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_RemoteLazyInputStream()) RefPtr<RemoteLazyInputStream>((aRhs).get_RemoteLazyInputStream());
break;
}
case TIPCStream:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_IPCStream()) IPCStream((aRhs).get_IPCStream());
break;
}
case T__None:
{
MaybeDestroy();
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
break;
}
}
mType = t;
return (*(this));
}
auto ParentToChildStream::operator=(ParentToChildStream&& aRhs) -> ParentToChildStream&
{
(aRhs).AssertSanity();
Type t = (aRhs).type();
switch (t) {
case TRemoteLazyInputStream:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_RemoteLazyInputStream()) RefPtr<RemoteLazyInputStream>(std::move((aRhs).get_RemoteLazyInputStream()));
(aRhs).MaybeDestroy();
break;
}
case TIPCStream:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_IPCStream()) IPCStream(std::move((aRhs).get_IPCStream()));
(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::ParentToChildStream>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
typedef ::mozilla::dom::ParentToChildStream union__;
int type = (aVar).type();
IPC::WriteParam(aWriter, type);
// Sentinel = 'ParentToChildStream'
(aWriter)->WriteSentinel(1242761086);
switch (type) {
case union__::TRemoteLazyInputStream:
{
IPC::WriteParam(aWriter, (aVar).get_RemoteLazyInputStream());
// Sentinel = 'TRemoteLazyInputStream'
(aWriter)->WriteSentinel(1677986013);
return;
}
case union__::TIPCStream:
{
IPC::WriteParam(aWriter, (aVar).get_IPCStream());
// Sentinel = 'TIPCStream'
(aWriter)->WriteSentinel(311690141);
return;
}
default:
{
aWriter->FatalError("unknown variant of union ParentToChildStream");
return;
}
}
}
auto ParamTraits<::mozilla::dom::ParentToChildStream>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
typedef ::mozilla::dom::ParentToChildStream union__;
auto maybe__type = IPC::ReadParam<int>(aReader);
if (!maybe__type) {
aReader->FatalError("Error deserializing type of union ParentToChildStream");
return {};
}
auto& type = *maybe__type;
// Sentinel = 'ParentToChildStream'
if ((!((aReader)->ReadSentinel(1242761086)))) {
mozilla::ipc::SentinelReadError("Error deserializing type of union ParentToChildStream");
return {};
}
switch (type) {
case union__::TRemoteLazyInputStream:
{
auto maybe__tmp = IPC::ReadParam<RefPtr<::mozilla::RemoteLazyInputStream>>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TRemoteLazyInputStream of union ParentToChildStream");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TRemoteLazyInputStream'
if ((!((aReader)->ReadSentinel(1677986013)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TRemoteLazyInputStream of union ParentToChildStream");
return {};
}
return std::move(tmp);
}
case union__::TIPCStream:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::ipc::IPCStream>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TIPCStream of union ParentToChildStream");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TIPCStream'
if ((!((aReader)->ReadSentinel(311690141)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TIPCStream of union ParentToChildStream");
return {};
}
return std::move(tmp);
}
default:
{
aReader->FatalError("unknown variant of union ParentToChildStream");
return {};
}
}
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct ChildToParentStream|
//
namespace mozilla {
namespace dom {
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::ChildToParentStream>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).stream());
// Sentinel = 'stream'
(aWriter)->WriteSentinel(153223821);
}
auto ParamTraits<::mozilla::dom::ChildToParentStream>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___stream = IPC::ReadParam<::mozilla::ipc::IPCStream>(aReader);
if (!maybe___stream) {
aReader->FatalError("Error deserializing 'stream' (IPCStream) member of 'ChildToParentStream'");
return {};
}
auto& _stream = *maybe___stream;
// Sentinel = 'stream'
if ((!((aReader)->ReadSentinel(153223821)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'stream' (IPCStream) member of 'ChildToParentStream'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_stream)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |union BodyStreamVariant|
//
namespace mozilla {
namespace dom {
auto BodyStreamVariant::MaybeDestroy() -> void
{
if ((mType) == (T__None)) {
return;
}
switch (mType) {
case TParentToParentStream:
{
(ptr_ParentToParentStream())->~ParentToParentStream__tdef();
break;
}
case TParentToChildStream:
{
(ptr_ParentToChildStream())->~ParentToChildStream__tdef();
break;
}
case TChildToParentStream:
{
(ptr_ChildToParentStream())->~ChildToParentStream__tdef();
break;
}
default:
{
mozilla::ipc::LogicError("not reached");
break;
}
}
}
MOZ_IMPLICIT BodyStreamVariant::BodyStreamVariant(const ParentToParentStream& aOther)
{
new (mozilla::KnownNotNull, ptr_ParentToParentStream()) ParentToParentStream(aOther);
mType = TParentToParentStream;
}
MOZ_IMPLICIT BodyStreamVariant::BodyStreamVariant(ParentToParentStream&& aOther)
{
new (mozilla::KnownNotNull, ptr_ParentToParentStream()) ParentToParentStream(std::move(aOther));
mType = TParentToParentStream;
}
MOZ_IMPLICIT BodyStreamVariant::BodyStreamVariant(const ParentToChildStream& aOther)
{
new (mozilla::KnownNotNull, ptr_ParentToChildStream()) ParentToChildStream(aOther);
mType = TParentToChildStream;
}
MOZ_IMPLICIT BodyStreamVariant::BodyStreamVariant(ParentToChildStream&& aOther)
{
new (mozilla::KnownNotNull, ptr_ParentToChildStream()) ParentToChildStream(std::move(aOther));
mType = TParentToChildStream;
}
MOZ_IMPLICIT BodyStreamVariant::BodyStreamVariant(const ChildToParentStream& aOther)
{
new (mozilla::KnownNotNull, ptr_ChildToParentStream()) ChildToParentStream(aOther);
mType = TChildToParentStream;
}
MOZ_IMPLICIT BodyStreamVariant::BodyStreamVariant(ChildToParentStream&& aOther)
{
new (mozilla::KnownNotNull, ptr_ChildToParentStream()) ChildToParentStream(std::move(aOther));
mType = TChildToParentStream;
}
MOZ_IMPLICIT BodyStreamVariant::BodyStreamVariant(const BodyStreamVariant& aOther)
{
(aOther).AssertSanity();
switch ((aOther).type()) {
case TParentToParentStream:
{
new (mozilla::KnownNotNull, ptr_ParentToParentStream()) ParentToParentStream((aOther).get_ParentToParentStream());
break;
}
case TParentToChildStream:
{
new (mozilla::KnownNotNull, ptr_ParentToChildStream()) ParentToChildStream((aOther).get_ParentToChildStream());
break;
}
case TChildToParentStream:
{
new (mozilla::KnownNotNull, ptr_ChildToParentStream()) ChildToParentStream((aOther).get_ChildToParentStream());
break;
}
case T__None:
{
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
return;
}
}
mType = (aOther).type();
}
MOZ_IMPLICIT BodyStreamVariant::BodyStreamVariant(BodyStreamVariant&& aOther)
{
(aOther).AssertSanity();
Type t = (aOther).type();
switch (t) {
case TParentToParentStream:
{
new (mozilla::KnownNotNull, ptr_ParentToParentStream()) ParentToParentStream(std::move((aOther).get_ParentToParentStream()));
(aOther).MaybeDestroy();
break;
}
case TParentToChildStream:
{
new (mozilla::KnownNotNull, ptr_ParentToChildStream()) ParentToChildStream(std::move((aOther).get_ParentToChildStream()));
(aOther).MaybeDestroy();
break;
}
case TChildToParentStream:
{
new (mozilla::KnownNotNull, ptr_ChildToParentStream()) ChildToParentStream(std::move((aOther).get_ChildToParentStream()));
(aOther).MaybeDestroy();
break;
}
case T__None:
{
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
return;
}
}
(aOther).mType = T__None;
mType = t;
}
BodyStreamVariant::~BodyStreamVariant()
{
MaybeDestroy();
}
auto BodyStreamVariant::operator=(const ParentToParentStream& aRhs) -> BodyStreamVariant&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_ParentToParentStream()) ParentToParentStream(aRhs);
mType = TParentToParentStream;
return (*(this));
}
auto BodyStreamVariant::operator=(ParentToParentStream&& aRhs) -> BodyStreamVariant&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_ParentToParentStream()) ParentToParentStream(std::move(aRhs));
mType = TParentToParentStream;
return (*(this));
}
auto BodyStreamVariant::operator=(const ParentToChildStream& aRhs) -> BodyStreamVariant&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_ParentToChildStream()) ParentToChildStream(aRhs);
mType = TParentToChildStream;
return (*(this));
}
auto BodyStreamVariant::operator=(ParentToChildStream&& aRhs) -> BodyStreamVariant&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_ParentToChildStream()) ParentToChildStream(std::move(aRhs));
mType = TParentToChildStream;
return (*(this));
}
auto BodyStreamVariant::operator=(const ChildToParentStream& aRhs) -> BodyStreamVariant&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_ChildToParentStream()) ChildToParentStream(aRhs);
mType = TChildToParentStream;
return (*(this));
}
auto BodyStreamVariant::operator=(ChildToParentStream&& aRhs) -> BodyStreamVariant&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_ChildToParentStream()) ChildToParentStream(std::move(aRhs));
mType = TChildToParentStream;
return (*(this));
}
auto BodyStreamVariant::operator=(const BodyStreamVariant& aRhs) -> BodyStreamVariant&
{
(aRhs).AssertSanity();
Type t = (aRhs).type();
switch (t) {
case TParentToParentStream:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_ParentToParentStream()) ParentToParentStream((aRhs).get_ParentToParentStream());
break;
}
case TParentToChildStream:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_ParentToChildStream()) ParentToChildStream((aRhs).get_ParentToChildStream());
break;
}
case TChildToParentStream:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_ChildToParentStream()) ChildToParentStream((aRhs).get_ChildToParentStream());
break;
}
case T__None:
{
MaybeDestroy();
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
break;
}
}
mType = t;
return (*(this));
}
auto BodyStreamVariant::operator=(BodyStreamVariant&& aRhs) -> BodyStreamVariant&
{
(aRhs).AssertSanity();
Type t = (aRhs).type();
switch (t) {
case TParentToParentStream:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_ParentToParentStream()) ParentToParentStream(std::move((aRhs).get_ParentToParentStream()));
(aRhs).MaybeDestroy();
break;
}
case TParentToChildStream:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_ParentToChildStream()) ParentToChildStream(std::move((aRhs).get_ParentToChildStream()));
(aRhs).MaybeDestroy();
break;
}
case TChildToParentStream:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_ChildToParentStream()) ChildToParentStream(std::move((aRhs).get_ChildToParentStream()));
(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::BodyStreamVariant>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
typedef ::mozilla::dom::BodyStreamVariant union__;
int type = (aVar).type();
IPC::WriteParam(aWriter, type);
// Sentinel = 'BodyStreamVariant'
(aWriter)->WriteSentinel(1008600784);
switch (type) {
case union__::TParentToParentStream:
{
IPC::WriteParam(aWriter, (aVar).get_ParentToParentStream());
// Sentinel = 'TParentToParentStream'
(aWriter)->WriteSentinel(1508903000);
return;
}
case union__::TParentToChildStream:
{
IPC::WriteParam(aWriter, (aVar).get_ParentToChildStream());
// Sentinel = 'TParentToChildStream'
(aWriter)->WriteSentinel(1352927186);
return;
}
case union__::TChildToParentStream:
{
IPC::WriteParam(aWriter, (aVar).get_ChildToParentStream());
// Sentinel = 'TChildToParentStream'
(aWriter)->WriteSentinel(1335953362);
return;
}
default:
{
aWriter->FatalError("unknown variant of union BodyStreamVariant");
return;
}
}
}
auto ParamTraits<::mozilla::dom::BodyStreamVariant>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
typedef ::mozilla::dom::BodyStreamVariant union__;
auto maybe__type = IPC::ReadParam<int>(aReader);
if (!maybe__type) {
aReader->FatalError("Error deserializing type of union BodyStreamVariant");
return {};
}
auto& type = *maybe__type;
// Sentinel = 'BodyStreamVariant'
if ((!((aReader)->ReadSentinel(1008600784)))) {
mozilla::ipc::SentinelReadError("Error deserializing type of union BodyStreamVariant");
return {};
}
switch (type) {
case union__::TParentToParentStream:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::dom::ParentToParentStream>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TParentToParentStream of union BodyStreamVariant");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TParentToParentStream'
if ((!((aReader)->ReadSentinel(1508903000)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TParentToParentStream of union BodyStreamVariant");
return {};
}
return std::move(tmp);
}
case union__::TParentToChildStream:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::dom::ParentToChildStream>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TParentToChildStream of union BodyStreamVariant");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TParentToChildStream'
if ((!((aReader)->ReadSentinel(1352927186)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TParentToChildStream of union BodyStreamVariant");
return {};
}
return std::move(tmp);
}
case union__::TChildToParentStream:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::dom::ChildToParentStream>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TChildToParentStream of union BodyStreamVariant");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TChildToParentStream'
if ((!((aReader)->ReadSentinel(1335953362)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TChildToParentStream of union BodyStreamVariant");
return {};
}
return std::move(tmp);
}
default:
{
aReader->FatalError("unknown variant of union BodyStreamVariant");
return {};
}
}
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct IPCInternalRequest|
//
namespace mozilla {
namespace dom {
auto IPCInternalRequest::StaticAssertions() const -> void
{
static_assert(
(offsetof(IPCInternalRequest, interceptionContentPolicyType_) - offsetof(IPCInternalRequest, contentPolicyType_)) == 4,
"Bad assumptions about field layout!");
}
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::IPCInternalRequest>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).method());
// Sentinel = 'method'
(aWriter)->WriteSentinel(148308610);
IPC::WriteParam(aWriter, (aVar).urlList());
// Sentinel = 'urlList'
(aWriter)->WriteSentinel(197591792);
IPC::WriteParam(aWriter, (aVar).headersGuard());
// Sentinel = 'headersGuard'
(aWriter)->WriteSentinel(522912976);
IPC::WriteParam(aWriter, (aVar).headers());
// Sentinel = 'headers'
(aWriter)->WriteSentinel(188220125);
IPC::WriteParam(aWriter, (aVar).body());
// Sentinel = 'body'
(aWriter)->WriteSentinel(68813231);
IPC::WriteParam(aWriter, (aVar).preferredAlternativeDataType());
// Sentinel = 'preferredAlternativeDataType'
(aWriter)->WriteSentinel(2781023067);
IPC::WriteParam(aWriter, (aVar).referrer());
// Sentinel = 'referrer'
(aWriter)->WriteSentinel(252838750);
IPC::WriteParam(aWriter, (aVar).referrerPolicy());
// Sentinel = 'referrerPolicy'
(aWriter)->WriteSentinel(729482702);
IPC::WriteParam(aWriter, (aVar).environmentReferrerPolicy());
// Sentinel = 'environmentReferrerPolicy'
(aWriter)->WriteSentinel(2278427235);
IPC::WriteParam(aWriter, (aVar).requestMode());
// Sentinel = 'requestMode'
(aWriter)->WriteSentinel(468386959);
IPC::WriteParam(aWriter, (aVar).requestCredentials());
// Sentinel = 'requestCredentials'
(aWriter)->WriteSentinel(1194461048);
IPC::WriteParam(aWriter, (aVar).cacheMode());
// Sentinel = 'cacheMode'
(aWriter)->WriteSentinel(290980730);
IPC::WriteParam(aWriter, (aVar).requestRedirect());
// Sentinel = 'requestRedirect'
(aWriter)->WriteSentinel(843974204);
IPC::WriteParam(aWriter, (aVar).integrity());
// Sentinel = 'integrity'
(aWriter)->WriteSentinel(320537568);
IPC::WriteParam(aWriter, (aVar).fragment());
// Sentinel = 'fragment'
(aWriter)->WriteSentinel(248644437);
IPC::WriteParam(aWriter, (aVar).principalInfo());
// Sentinel = 'principalInfo'
(aWriter)->WriteSentinel(633472335);
IPC::WriteParam(aWriter, (aVar).interceptionTriggeringPrincipalInfo());
// Sentinel = 'interceptionTriggeringPrincipalInfo'
(aWriter)->WriteSentinel(82710101);
IPC::WriteParam(aWriter, (aVar).interceptionRedirectChain());
// Sentinel = 'interceptionRedirectChain'
(aWriter)->WriteSentinel(2251754026);
IPC::WriteParam(aWriter, (aVar).interceptionFromThirdParty());
// Sentinel = 'interceptionFromThirdParty'
(aWriter)->WriteSentinel(2433813172);
IPC::WriteParam(aWriter, (aVar).embedderPolicy());
// Sentinel = 'embedderPolicy'
(aWriter)->WriteSentinel(703792553);
(aWriter)->WriteBytes((&((aVar).bodySize())), 8);
// Sentinel = 'bodySize'
(aWriter)->WriteSentinel(246809418);
(aWriter)->WriteBytes((&((aVar).contentPolicyType())), 8);
// Sentinel = 'contentPolicyType | interceptionContentPolicyType'
(aWriter)->WriteSentinel(3972731851);
}
auto ParamTraits<::mozilla::dom::IPCInternalRequest>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___method = IPC::ReadParam<::nsCString>(aReader);
if (!maybe___method) {
aReader->FatalError("Error deserializing 'method' (nsCString) member of 'IPCInternalRequest'");
return {};
}
auto& _method = *maybe___method;
// Sentinel = 'method'
if ((!((aReader)->ReadSentinel(148308610)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'method' (nsCString) member of 'IPCInternalRequest'");
return {};
}
auto maybe___urlList = IPC::ReadParam<nsTArray<::nsCString>>(aReader);
if (!maybe___urlList) {
aReader->FatalError("Error deserializing 'urlList' (nsCString[]) member of 'IPCInternalRequest'");
return {};
}
auto& _urlList = *maybe___urlList;
// Sentinel = 'urlList'
if ((!((aReader)->ReadSentinel(197591792)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'urlList' (nsCString[]) member of 'IPCInternalRequest'");
return {};
}
auto maybe___headersGuard = IPC::ReadParam<::mozilla::dom::HeadersGuardEnum>(aReader);
if (!maybe___headersGuard) {
aReader->FatalError("Error deserializing 'headersGuard' (HeadersGuardEnum) member of 'IPCInternalRequest'");
return {};
}
auto& _headersGuard = *maybe___headersGuard;
// Sentinel = 'headersGuard'
if ((!((aReader)->ReadSentinel(522912976)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'headersGuard' (HeadersGuardEnum) member of 'IPCInternalRequest'");
return {};
}
auto maybe___headers = IPC::ReadParam<nsTArray<::mozilla::dom::HeadersEntry>>(aReader);
if (!maybe___headers) {
aReader->FatalError("Error deserializing 'headers' (HeadersEntry[]) member of 'IPCInternalRequest'");
return {};
}
auto& _headers = *maybe___headers;
// Sentinel = 'headers'
if ((!((aReader)->ReadSentinel(188220125)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'headers' (HeadersEntry[]) member of 'IPCInternalRequest'");
return {};
}
auto maybe___body = IPC::ReadParam<mozilla::Maybe<::mozilla::dom::BodyStreamVariant>>(aReader);
if (!maybe___body) {
aReader->FatalError("Error deserializing 'body' (BodyStreamVariant?) member of 'IPCInternalRequest'");
return {};
}
auto& _body = *maybe___body;
// Sentinel = 'body'
if ((!((aReader)->ReadSentinel(68813231)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'body' (BodyStreamVariant?) member of 'IPCInternalRequest'");
return {};
}
auto maybe___preferredAlternativeDataType = IPC::ReadParam<::nsCString>(aReader);
if (!maybe___preferredAlternativeDataType) {
aReader->FatalError("Error deserializing 'preferredAlternativeDataType' (nsCString) member of 'IPCInternalRequest'");
return {};
}
auto& _preferredAlternativeDataType = *maybe___preferredAlternativeDataType;
// Sentinel = 'preferredAlternativeDataType'
if ((!((aReader)->ReadSentinel(2781023067)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'preferredAlternativeDataType' (nsCString) member of 'IPCInternalRequest'");
return {};
}
auto maybe___referrer = IPC::ReadParam<::nsCString>(aReader);
if (!maybe___referrer) {
aReader->FatalError("Error deserializing 'referrer' (nsCString) member of 'IPCInternalRequest'");
return {};
}
auto& _referrer = *maybe___referrer;
// Sentinel = 'referrer'
if ((!((aReader)->ReadSentinel(252838750)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'referrer' (nsCString) member of 'IPCInternalRequest'");
return {};
}
auto maybe___referrerPolicy = IPC::ReadParam<::mozilla::dom::ReferrerPolicy>(aReader);
if (!maybe___referrerPolicy) {
aReader->FatalError("Error deserializing 'referrerPolicy' (ReferrerPolicy) member of 'IPCInternalRequest'");
return {};
}
auto& _referrerPolicy = *maybe___referrerPolicy;
// Sentinel = 'referrerPolicy'
if ((!((aReader)->ReadSentinel(729482702)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'referrerPolicy' (ReferrerPolicy) member of 'IPCInternalRequest'");
return {};
}
auto maybe___environmentReferrerPolicy = IPC::ReadParam<::mozilla::dom::ReferrerPolicy>(aReader);
if (!maybe___environmentReferrerPolicy) {
aReader->FatalError("Error deserializing 'environmentReferrerPolicy' (ReferrerPolicy) member of 'IPCInternalRequest'");
return {};
}
auto& _environmentReferrerPolicy = *maybe___environmentReferrerPolicy;
// Sentinel = 'environmentReferrerPolicy'
if ((!((aReader)->ReadSentinel(2278427235)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'environmentReferrerPolicy' (ReferrerPolicy) member of 'IPCInternalRequest'");
return {};
}
auto maybe___requestMode = IPC::ReadParam<::mozilla::dom::RequestMode>(aReader);
if (!maybe___requestMode) {
aReader->FatalError("Error deserializing 'requestMode' (RequestMode) member of 'IPCInternalRequest'");
return {};
}
auto& _requestMode = *maybe___requestMode;
// Sentinel = 'requestMode'
if ((!((aReader)->ReadSentinel(468386959)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'requestMode' (RequestMode) member of 'IPCInternalRequest'");
return {};
}
auto maybe___requestCredentials = IPC::ReadParam<::mozilla::dom::RequestCredentials>(aReader);
if (!maybe___requestCredentials) {
aReader->FatalError("Error deserializing 'requestCredentials' (RequestCredentials) member of 'IPCInternalRequest'");
return {};
}
auto& _requestCredentials = *maybe___requestCredentials;
// Sentinel = 'requestCredentials'
if ((!((aReader)->ReadSentinel(1194461048)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'requestCredentials' (RequestCredentials) member of 'IPCInternalRequest'");
return {};
}
auto maybe___cacheMode = IPC::ReadParam<::mozilla::dom::RequestCache>(aReader);
if (!maybe___cacheMode) {
aReader->FatalError("Error deserializing 'cacheMode' (RequestCache) member of 'IPCInternalRequest'");
return {};
}
auto& _cacheMode = *maybe___cacheMode;
// Sentinel = 'cacheMode'
if ((!((aReader)->ReadSentinel(290980730)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'cacheMode' (RequestCache) member of 'IPCInternalRequest'");
return {};
}
auto maybe___requestRedirect = IPC::ReadParam<::mozilla::dom::RequestRedirect>(aReader);
if (!maybe___requestRedirect) {
aReader->FatalError("Error deserializing 'requestRedirect' (RequestRedirect) member of 'IPCInternalRequest'");
return {};
}
auto& _requestRedirect = *maybe___requestRedirect;
// Sentinel = 'requestRedirect'
if ((!((aReader)->ReadSentinel(843974204)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'requestRedirect' (RequestRedirect) member of 'IPCInternalRequest'");
return {};
}
auto maybe___integrity = IPC::ReadParam<::nsString>(aReader);
if (!maybe___integrity) {
aReader->FatalError("Error deserializing 'integrity' (nsString) member of 'IPCInternalRequest'");
return {};
}
auto& _integrity = *maybe___integrity;
// Sentinel = 'integrity'
if ((!((aReader)->ReadSentinel(320537568)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'integrity' (nsString) member of 'IPCInternalRequest'");
return {};
}
auto maybe___fragment = IPC::ReadParam<::nsCString>(aReader);
if (!maybe___fragment) {
aReader->FatalError("Error deserializing 'fragment' (nsCString) member of 'IPCInternalRequest'");
return {};
}
auto& _fragment = *maybe___fragment;
// Sentinel = 'fragment'
if ((!((aReader)->ReadSentinel(248644437)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'fragment' (nsCString) member of 'IPCInternalRequest'");
return {};
}
auto maybe___principalInfo = IPC::ReadParam<mozilla::Maybe<::mozilla::ipc::PrincipalInfo>>(aReader);
if (!maybe___principalInfo) {
aReader->FatalError("Error deserializing 'principalInfo' (PrincipalInfo?) member of 'IPCInternalRequest'");
return {};
}
auto& _principalInfo = *maybe___principalInfo;
// Sentinel = 'principalInfo'
if ((!((aReader)->ReadSentinel(633472335)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'principalInfo' (PrincipalInfo?) member of 'IPCInternalRequest'");
return {};
}
auto maybe___interceptionTriggeringPrincipalInfo = IPC::ReadParam<mozilla::Maybe<::mozilla::ipc::PrincipalInfo>>(aReader);
if (!maybe___interceptionTriggeringPrincipalInfo) {
aReader->FatalError("Error deserializing 'interceptionTriggeringPrincipalInfo' (PrincipalInfo?) member of 'IPCInternalRequest'");
return {};
}
auto& _interceptionTriggeringPrincipalInfo = *maybe___interceptionTriggeringPrincipalInfo;
// Sentinel = 'interceptionTriggeringPrincipalInfo'
if ((!((aReader)->ReadSentinel(82710101)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'interceptionTriggeringPrincipalInfo' (PrincipalInfo?) member of 'IPCInternalRequest'");
return {};
}
auto maybe___interceptionRedirectChain = IPC::ReadParam<nsTArray<::mozilla::net::RedirectHistoryEntryInfo>>(aReader);
if (!maybe___interceptionRedirectChain) {
aReader->FatalError("Error deserializing 'interceptionRedirectChain' (RedirectHistoryEntryInfo[]) member of 'IPCInternalRequest'");
return {};
}
auto& _interceptionRedirectChain = *maybe___interceptionRedirectChain;
// Sentinel = 'interceptionRedirectChain'
if ((!((aReader)->ReadSentinel(2251754026)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'interceptionRedirectChain' (RedirectHistoryEntryInfo[]) member of 'IPCInternalRequest'");
return {};
}
auto maybe___interceptionFromThirdParty = IPC::ReadParam<bool>(aReader);
if (!maybe___interceptionFromThirdParty) {
aReader->FatalError("Error deserializing 'interceptionFromThirdParty' (bool) member of 'IPCInternalRequest'");
return {};
}
auto& _interceptionFromThirdParty = *maybe___interceptionFromThirdParty;
// Sentinel = 'interceptionFromThirdParty'
if ((!((aReader)->ReadSentinel(2433813172)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'interceptionFromThirdParty' (bool) member of 'IPCInternalRequest'");
return {};
}
auto maybe___embedderPolicy = IPC::ReadParam<::nsILoadInfo::CrossOriginEmbedderPolicy>(aReader);
if (!maybe___embedderPolicy) {
aReader->FatalError("Error deserializing 'embedderPolicy' (CrossOriginEmbedderPolicy) member of 'IPCInternalRequest'");
return {};
}
auto& _embedderPolicy = *maybe___embedderPolicy;
// Sentinel = 'embedderPolicy'
if ((!((aReader)->ReadSentinel(703792553)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'embedderPolicy' (CrossOriginEmbedderPolicy) member of 'IPCInternalRequest'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_method),
std::move(_urlList),
std::move(_headersGuard),
std::move(_headers),
std::move(_body),
::int64_t{0},
std::move(_preferredAlternativeDataType),
::uint32_t{0},
std::move(_referrer),
std::move(_referrerPolicy),
std::move(_environmentReferrerPolicy),
std::move(_requestMode),
std::move(_requestCredentials),
std::move(_cacheMode),
std::move(_requestRedirect),
std::move(_integrity),
std::move(_fragment),
std::move(_principalInfo),
std::move(_interceptionTriggeringPrincipalInfo),
::uint32_t{0},
std::move(_interceptionRedirectChain),
std::move(_interceptionFromThirdParty),
std::move(_embedderPolicy)};
if ((!((aReader)->ReadBytesInto((&((result__)->bodySize())), 8)))) {
aReader->FatalError("Error bulk reading fields from int64_t");
return {};
}
// Sentinel = 'bodySize'
if ((!((aReader)->ReadSentinel(246809418)))) {
mozilla::ipc::SentinelReadError("Error bulk reading fields from int64_t");
return {};
}
if ((!((aReader)->ReadBytesInto((&((result__)->contentPolicyType())), 8)))) {
aReader->FatalError("Error bulk reading fields from uint32_t");
return {};
}
// Sentinel = 'contentPolicyType | interceptionContentPolicyType'
if ((!((aReader)->ReadSentinel(3972731851)))) {
mozilla::ipc::SentinelReadError("Error bulk reading fields from uint32_t");
return {};
}
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct InternalResponseMetadata|
//
namespace mozilla {
namespace dom {
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::InternalResponseMetadata>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).type());
// Sentinel = 'type'
(aWriter)->WriteSentinel(75760067);
IPC::WriteParam(aWriter, (aVar).urlList());
// Sentinel = 'urlList'
(aWriter)->WriteSentinel(197591792);
IPC::WriteParam(aWriter, (aVar).statusText());
// Sentinel = 'statusText'
(aWriter)->WriteSentinel(397411402);
IPC::WriteParam(aWriter, (aVar).headersGuard());
// Sentinel = 'headersGuard'
(aWriter)->WriteSentinel(522912976);
IPC::WriteParam(aWriter, (aVar).headers());
// Sentinel = 'headers'
(aWriter)->WriteSentinel(188220125);
IPC::WriteParam(aWriter, (aVar).errorCode());
// Sentinel = 'errorCode'
(aWriter)->WriteSentinel(312345510);
IPC::WriteParam(aWriter, (aVar).alternativeDataType());
// Sentinel = 'alternativeDataType'
(aWriter)->WriteSentinel(1308690364);
IPC::WriteParam(aWriter, (aVar).securityInfo());
// Sentinel = 'securityInfo'
(aWriter)->WriteSentinel(552535301);
IPC::WriteParam(aWriter, (aVar).principalInfo());
// Sentinel = 'principalInfo'
(aWriter)->WriteSentinel(633472335);
IPC::WriteParam(aWriter, (aVar).bodyBlobURISpec());
// Sentinel = 'bodyBlobURISpec'
(aWriter)->WriteSentinel(773391785);
IPC::WriteParam(aWriter, (aVar).bodyLocalPath());
// Sentinel = 'bodyLocalPath'
(aWriter)->WriteSentinel(607061287);
IPC::WriteParam(aWriter, (aVar).credentialsMode());
// Sentinel = 'credentialsMode'
(aWriter)->WriteSentinel(822347284);
(aWriter)->WriteBytes((&((aVar).status())), 2);
// Sentinel = 'status'
(aWriter)->WriteSentinel(154731173);
}
auto ParamTraits<::mozilla::dom::InternalResponseMetadata>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___type = IPC::ReadParam<::mozilla::dom::ResponseType>(aReader);
if (!maybe___type) {
aReader->FatalError("Error deserializing 'type' (ResponseType) member of 'InternalResponseMetadata'");
return {};
}
auto& _type = *maybe___type;
// Sentinel = 'type'
if ((!((aReader)->ReadSentinel(75760067)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'type' (ResponseType) member of 'InternalResponseMetadata'");
return {};
}
auto maybe___urlList = IPC::ReadParam<nsTArray<::nsCString>>(aReader);
if (!maybe___urlList) {
aReader->FatalError("Error deserializing 'urlList' (nsCString[]) member of 'InternalResponseMetadata'");
return {};
}
auto& _urlList = *maybe___urlList;
// Sentinel = 'urlList'
if ((!((aReader)->ReadSentinel(197591792)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'urlList' (nsCString[]) member of 'InternalResponseMetadata'");
return {};
}
auto maybe___statusText = IPC::ReadParam<::nsCString>(aReader);
if (!maybe___statusText) {
aReader->FatalError("Error deserializing 'statusText' (nsCString) member of 'InternalResponseMetadata'");
return {};
}
auto& _statusText = *maybe___statusText;
// Sentinel = 'statusText'
if ((!((aReader)->ReadSentinel(397411402)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'statusText' (nsCString) member of 'InternalResponseMetadata'");
return {};
}
auto maybe___headersGuard = IPC::ReadParam<::mozilla::dom::HeadersGuardEnum>(aReader);
if (!maybe___headersGuard) {
aReader->FatalError("Error deserializing 'headersGuard' (HeadersGuardEnum) member of 'InternalResponseMetadata'");
return {};
}
auto& _headersGuard = *maybe___headersGuard;
// Sentinel = 'headersGuard'
if ((!((aReader)->ReadSentinel(522912976)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'headersGuard' (HeadersGuardEnum) member of 'InternalResponseMetadata'");
return {};
}
auto maybe___headers = IPC::ReadParam<nsTArray<::mozilla::dom::HeadersEntry>>(aReader);
if (!maybe___headers) {
aReader->FatalError("Error deserializing 'headers' (HeadersEntry[]) member of 'InternalResponseMetadata'");
return {};
}
auto& _headers = *maybe___headers;
// Sentinel = 'headers'
if ((!((aReader)->ReadSentinel(188220125)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'headers' (HeadersEntry[]) member of 'InternalResponseMetadata'");
return {};
}
auto maybe___errorCode = IPC::ReadParam<::nsresult>(aReader);
if (!maybe___errorCode) {
aReader->FatalError("Error deserializing 'errorCode' (nsresult) member of 'InternalResponseMetadata'");
return {};
}
auto& _errorCode = *maybe___errorCode;
// Sentinel = 'errorCode'
if ((!((aReader)->ReadSentinel(312345510)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'errorCode' (nsresult) member of 'InternalResponseMetadata'");
return {};
}
auto maybe___alternativeDataType = IPC::ReadParam<::nsCString>(aReader);
if (!maybe___alternativeDataType) {
aReader->FatalError("Error deserializing 'alternativeDataType' (nsCString) member of 'InternalResponseMetadata'");
return {};
}
auto& _alternativeDataType = *maybe___alternativeDataType;
// Sentinel = 'alternativeDataType'
if ((!((aReader)->ReadSentinel(1308690364)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'alternativeDataType' (nsCString) member of 'InternalResponseMetadata'");
return {};
}
auto maybe___securityInfo = IPC::ReadParam<RefPtr<::nsITransportSecurityInfo>>(aReader);
if (!maybe___securityInfo) {
aReader->FatalError("Error deserializing 'securityInfo' (nsITransportSecurityInfo) member of 'InternalResponseMetadata'");
return {};
}
auto& _securityInfo = *maybe___securityInfo;
// Sentinel = 'securityInfo'
if ((!((aReader)->ReadSentinel(552535301)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'securityInfo' (nsITransportSecurityInfo) member of 'InternalResponseMetadata'");
return {};
}
auto maybe___principalInfo = IPC::ReadParam<mozilla::Maybe<::mozilla::ipc::PrincipalInfo>>(aReader);
if (!maybe___principalInfo) {
aReader->FatalError("Error deserializing 'principalInfo' (PrincipalInfo?) member of 'InternalResponseMetadata'");
return {};
}
auto& _principalInfo = *maybe___principalInfo;
// Sentinel = 'principalInfo'
if ((!((aReader)->ReadSentinel(633472335)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'principalInfo' (PrincipalInfo?) member of 'InternalResponseMetadata'");
return {};
}
auto maybe___bodyBlobURISpec = IPC::ReadParam<::nsCString>(aReader);
if (!maybe___bodyBlobURISpec) {
aReader->FatalError("Error deserializing 'bodyBlobURISpec' (nsCString) member of 'InternalResponseMetadata'");
return {};
}
auto& _bodyBlobURISpec = *maybe___bodyBlobURISpec;
// Sentinel = 'bodyBlobURISpec'
if ((!((aReader)->ReadSentinel(773391785)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bodyBlobURISpec' (nsCString) member of 'InternalResponseMetadata'");
return {};
}
auto maybe___bodyLocalPath = IPC::ReadParam<::nsString>(aReader);
if (!maybe___bodyLocalPath) {
aReader->FatalError("Error deserializing 'bodyLocalPath' (nsString) member of 'InternalResponseMetadata'");
return {};
}
auto& _bodyLocalPath = *maybe___bodyLocalPath;
// Sentinel = 'bodyLocalPath'
if ((!((aReader)->ReadSentinel(607061287)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bodyLocalPath' (nsString) member of 'InternalResponseMetadata'");
return {};
}
auto maybe___credentialsMode = IPC::ReadParam<::mozilla::dom::RequestCredentials>(aReader);
if (!maybe___credentialsMode) {
aReader->FatalError("Error deserializing 'credentialsMode' (RequestCredentials) member of 'InternalResponseMetadata'");
return {};
}
auto& _credentialsMode = *maybe___credentialsMode;
// Sentinel = 'credentialsMode'
if ((!((aReader)->ReadSentinel(822347284)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'credentialsMode' (RequestCredentials) member of 'InternalResponseMetadata'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_type),
std::move(_urlList),
::uint16_t{0},
std::move(_statusText),
std::move(_headersGuard),
std::move(_headers),
std::move(_errorCode),
std::move(_alternativeDataType),
std::move(_securityInfo),
std::move(_principalInfo),
std::move(_bodyBlobURISpec),
std::move(_bodyLocalPath),
std::move(_credentialsMode)};
if ((!((aReader)->ReadBytesInto((&((result__)->status())), 2)))) {
aReader->FatalError("Error bulk reading fields from uint16_t");
return {};
}
// Sentinel = 'status'
if ((!((aReader)->ReadSentinel(154731173)))) {
mozilla::ipc::SentinelReadError("Error bulk reading fields from uint16_t");
return {};
}
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct ParentToParentInternalResponse|
//
namespace mozilla {
namespace dom {
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::ParentToParentInternalResponse>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).metadata());
// Sentinel = 'metadata'
(aWriter)->WriteSentinel(248251202);
IPC::WriteParam(aWriter, (aVar).body());
// Sentinel = 'body'
(aWriter)->WriteSentinel(68813231);
IPC::WriteParam(aWriter, (aVar).alternativeBody());
// Sentinel = 'alternativeBody'
(aWriter)->WriteSentinel(833816110);
(aWriter)->WriteBytes((&((aVar).bodySize())), 8);
// Sentinel = 'bodySize'
(aWriter)->WriteSentinel(246809418);
}
auto ParamTraits<::mozilla::dom::ParentToParentInternalResponse>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___metadata = IPC::ReadParam<::mozilla::dom::InternalResponseMetadata>(aReader);
if (!maybe___metadata) {
aReader->FatalError("Error deserializing 'metadata' (InternalResponseMetadata) member of 'ParentToParentInternalResponse'");
return {};
}
auto& _metadata = *maybe___metadata;
// Sentinel = 'metadata'
if ((!((aReader)->ReadSentinel(248251202)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'metadata' (InternalResponseMetadata) member of 'ParentToParentInternalResponse'");
return {};
}
auto maybe___body = IPC::ReadParam<mozilla::Maybe<::mozilla::dom::ParentToParentStream>>(aReader);
if (!maybe___body) {
aReader->FatalError("Error deserializing 'body' (ParentToParentStream?) member of 'ParentToParentInternalResponse'");
return {};
}
auto& _body = *maybe___body;
// Sentinel = 'body'
if ((!((aReader)->ReadSentinel(68813231)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'body' (ParentToParentStream?) member of 'ParentToParentInternalResponse'");
return {};
}
auto maybe___alternativeBody = IPC::ReadParam<mozilla::Maybe<::mozilla::dom::ParentToParentStream>>(aReader);
if (!maybe___alternativeBody) {
aReader->FatalError("Error deserializing 'alternativeBody' (ParentToParentStream?) member of 'ParentToParentInternalResponse'");
return {};
}
auto& _alternativeBody = *maybe___alternativeBody;
// Sentinel = 'alternativeBody'
if ((!((aReader)->ReadSentinel(833816110)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'alternativeBody' (ParentToParentStream?) member of 'ParentToParentInternalResponse'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_metadata),
std::move(_body),
::int64_t{0},
std::move(_alternativeBody)};
if ((!((aReader)->ReadBytesInto((&((result__)->bodySize())), 8)))) {
aReader->FatalError("Error bulk reading fields from int64_t");
return {};
}
// Sentinel = 'bodySize'
if ((!((aReader)->ReadSentinel(246809418)))) {
mozilla::ipc::SentinelReadError("Error bulk reading fields from int64_t");
return {};
}
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct ParentToChildInternalResponse|
//
namespace mozilla {
namespace dom {
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::ParentToChildInternalResponse>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).metadata());
// Sentinel = 'metadata'
(aWriter)->WriteSentinel(248251202);
IPC::WriteParam(aWriter, (aVar).body());
// Sentinel = 'body'
(aWriter)->WriteSentinel(68813231);
IPC::WriteParam(aWriter, (aVar).alternativeBody());
// Sentinel = 'alternativeBody'
(aWriter)->WriteSentinel(833816110);
(aWriter)->WriteBytes((&((aVar).bodySize())), 8);
// Sentinel = 'bodySize'
(aWriter)->WriteSentinel(246809418);
}
auto ParamTraits<::mozilla::dom::ParentToChildInternalResponse>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___metadata = IPC::ReadParam<::mozilla::dom::InternalResponseMetadata>(aReader);
if (!maybe___metadata) {
aReader->FatalError("Error deserializing 'metadata' (InternalResponseMetadata) member of 'ParentToChildInternalResponse'");
return {};
}
auto& _metadata = *maybe___metadata;
// Sentinel = 'metadata'
if ((!((aReader)->ReadSentinel(248251202)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'metadata' (InternalResponseMetadata) member of 'ParentToChildInternalResponse'");
return {};
}
auto maybe___body = IPC::ReadParam<mozilla::Maybe<::mozilla::dom::ParentToChildStream>>(aReader);
if (!maybe___body) {
aReader->FatalError("Error deserializing 'body' (ParentToChildStream?) member of 'ParentToChildInternalResponse'");
return {};
}
auto& _body = *maybe___body;
// Sentinel = 'body'
if ((!((aReader)->ReadSentinel(68813231)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'body' (ParentToChildStream?) member of 'ParentToChildInternalResponse'");
return {};
}
auto maybe___alternativeBody = IPC::ReadParam<mozilla::Maybe<::mozilla::dom::ParentToChildStream>>(aReader);
if (!maybe___alternativeBody) {
aReader->FatalError("Error deserializing 'alternativeBody' (ParentToChildStream?) member of 'ParentToChildInternalResponse'");
return {};
}
auto& _alternativeBody = *maybe___alternativeBody;
// Sentinel = 'alternativeBody'
if ((!((aReader)->ReadSentinel(833816110)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'alternativeBody' (ParentToChildStream?) member of 'ParentToChildInternalResponse'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_metadata),
std::move(_body),
::int64_t{0},
std::move(_alternativeBody)};
if ((!((aReader)->ReadBytesInto((&((result__)->bodySize())), 8)))) {
aReader->FatalError("Error bulk reading fields from int64_t");
return {};
}
// Sentinel = 'bodySize'
if ((!((aReader)->ReadSentinel(246809418)))) {
mozilla::ipc::SentinelReadError("Error bulk reading fields from int64_t");
return {};
}
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct ChildToParentInternalResponse|
//
namespace mozilla {
namespace dom {
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::ChildToParentInternalResponse>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).metadata());
// Sentinel = 'metadata'
(aWriter)->WriteSentinel(248251202);
IPC::WriteParam(aWriter, (aVar).body());
// Sentinel = 'body'
(aWriter)->WriteSentinel(68813231);
IPC::WriteParam(aWriter, (aVar).alternativeBody());
// Sentinel = 'alternativeBody'
(aWriter)->WriteSentinel(833816110);
(aWriter)->WriteBytes((&((aVar).bodySize())), 8);
// Sentinel = 'bodySize'
(aWriter)->WriteSentinel(246809418);
}
auto ParamTraits<::mozilla::dom::ChildToParentInternalResponse>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___metadata = IPC::ReadParam<::mozilla::dom::InternalResponseMetadata>(aReader);
if (!maybe___metadata) {
aReader->FatalError("Error deserializing 'metadata' (InternalResponseMetadata) member of 'ChildToParentInternalResponse'");
return {};
}
auto& _metadata = *maybe___metadata;
// Sentinel = 'metadata'
if ((!((aReader)->ReadSentinel(248251202)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'metadata' (InternalResponseMetadata) member of 'ChildToParentInternalResponse'");
return {};
}
auto maybe___body = IPC::ReadParam<mozilla::Maybe<::mozilla::dom::ChildToParentStream>>(aReader);
if (!maybe___body) {
aReader->FatalError("Error deserializing 'body' (ChildToParentStream?) member of 'ChildToParentInternalResponse'");
return {};
}
auto& _body = *maybe___body;
// Sentinel = 'body'
if ((!((aReader)->ReadSentinel(68813231)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'body' (ChildToParentStream?) member of 'ChildToParentInternalResponse'");
return {};
}
auto maybe___alternativeBody = IPC::ReadParam<mozilla::Maybe<::mozilla::dom::ChildToParentStream>>(aReader);
if (!maybe___alternativeBody) {
aReader->FatalError("Error deserializing 'alternativeBody' (ChildToParentStream?) member of 'ChildToParentInternalResponse'");
return {};
}
auto& _alternativeBody = *maybe___alternativeBody;
// Sentinel = 'alternativeBody'
if ((!((aReader)->ReadSentinel(833816110)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'alternativeBody' (ChildToParentStream?) member of 'ChildToParentInternalResponse'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_metadata),
std::move(_body),
::int64_t{0},
std::move(_alternativeBody)};
if ((!((aReader)->ReadBytesInto((&((result__)->bodySize())), 8)))) {
aReader->FatalError("Error bulk reading fields from int64_t");
return {};
}
// Sentinel = 'bodySize'
if ((!((aReader)->ReadSentinel(246809418)))) {
mozilla::ipc::SentinelReadError("Error bulk reading fields from int64_t");
return {};
}
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct ResponseTiming|
//
namespace mozilla {
namespace dom {
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::ResponseTiming>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).timingData());
// Sentinel = 'timingData'
(aWriter)->WriteSentinel(379388931);
IPC::WriteParam(aWriter, (aVar).initiatorType());
// Sentinel = 'initiatorType'
(aWriter)->WriteSentinel(642647414);
IPC::WriteParam(aWriter, (aVar).entryName());
// Sentinel = 'entryName'
(aWriter)->WriteSentinel(315950004);
}
auto ParamTraits<::mozilla::dom::ResponseTiming>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___timingData = IPC::ReadParam<::mozilla::dom::IPCPerformanceTimingData>(aReader);
if (!maybe___timingData) {
aReader->FatalError("Error deserializing 'timingData' (IPCPerformanceTimingData) member of 'ResponseTiming'");
return {};
}
auto& _timingData = *maybe___timingData;
// Sentinel = 'timingData'
if ((!((aReader)->ReadSentinel(379388931)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'timingData' (IPCPerformanceTimingData) member of 'ResponseTiming'");
return {};
}
auto maybe___initiatorType = IPC::ReadParam<::nsString>(aReader);
if (!maybe___initiatorType) {
aReader->FatalError("Error deserializing 'initiatorType' (nsString) member of 'ResponseTiming'");
return {};
}
auto& _initiatorType = *maybe___initiatorType;
// Sentinel = 'initiatorType'
if ((!((aReader)->ReadSentinel(642647414)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'initiatorType' (nsString) member of 'ResponseTiming'");
return {};
}
auto maybe___entryName = IPC::ReadParam<::nsString>(aReader);
if (!maybe___entryName) {
aReader->FatalError("Error deserializing 'entryName' (nsString) member of 'ResponseTiming'");
return {};
}
auto& _entryName = *maybe___entryName;
// Sentinel = 'entryName'
if ((!((aReader)->ReadSentinel(315950004)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'entryName' (nsString) member of 'ResponseTiming'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_timingData),
std::move(_initiatorType),
std::move(_entryName)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct ResponseEndArgs|
//
namespace mozilla {
namespace dom {
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::ResponseEndArgs>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).endReason());
// Sentinel = 'endReason'
(aWriter)->WriteSentinel(298845088);
}
auto ParamTraits<::mozilla::dom::ResponseEndArgs>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___endReason = IPC::ReadParam<::mozilla::dom::FetchDriverObserver::EndReason>(aReader);
if (!maybe___endReason) {
aReader->FatalError("Error deserializing 'endReason' (EndReason) member of 'ResponseEndArgs'");
return {};
}
auto& _endReason = *maybe___endReason;
// Sentinel = 'endReason'
if ((!((aReader)->ReadSentinel(298845088)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'endReason' (EndReason) member of 'ResponseEndArgs'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_endReason)};
return result__;
}
} // namespace IPC