Copy as Markdown
Other Tools
//
// Automatically generated by ipdlc.
// Edit at your own risk
//
#include "mozilla/dom/DomSecurityIPCUtils.h"
#include "mozilla/dom/FetchIPCTypes.h"
#include "mozilla/dom/FeaturePolicyUtils.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/net/PHttpChannelParent.h"
#include "mozilla/net/PHttpChannelChild.h"
#include "mozilla/dom/BindingIPCUtils.h"
#include "mozilla/dom/ClientIPCUtils.h"
#include "ipc/ErrorIPCUtils.h"
#include "mozilla/dom/ServiceWorkerIPCUtils.h"
#include "mozilla/dom/DomSecurityIPCUtils.h"
#include "mozilla/GfxMessageUtils.h"
#include "mozilla/dom/CSPMessageUtils.h"
#include "mozilla/dom/DocShellMessageUtils.h"
#include "mozilla/dom/PermissionMessageUtils.h"
#include "mozilla/dom/PropertyBagUtils.h"
#include "mozilla/dom/ReferrerInfoUtils.h"
#include "mozilla/dom/TabMessageUtils.h"
#include "mozilla/dom/notification/IPCUtils.h"
#include "mozilla/ipc/URIUtils.h"
#include "mozilla/layers/LayersMessageUtils.h"
#include "mozilla/net/NeckoMessageUtils.h"
#include "mozilla/net/NeckoChannelParams.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 CookiePermissionData|
//
namespace mozilla {
namespace net {
} // namespace net
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::net::CookiePermissionData>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).principalInfo());
// Sentinel = 'principalInfo'
(aWriter)->WriteSentinel(633472335);
(aWriter)->WriteBytes((&((aVar).cookiePermission())), 4);
// Sentinel = 'cookiePermission'
(aWriter)->WriteSentinel(935659172);
}
auto ParamTraits<::mozilla::net::CookiePermissionData>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___principalInfo = IPC::ReadParam<::mozilla::ipc::PrincipalInfo>(aReader);
if (!maybe___principalInfo) {
aReader->FatalError("Error deserializing 'principalInfo' (PrincipalInfo) member of 'CookiePermissionData'");
return {};
}
auto& _principalInfo = *maybe___principalInfo;
// Sentinel = 'principalInfo'
if ((!((aReader)->ReadSentinel(633472335)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'principalInfo' (PrincipalInfo) member of 'CookiePermissionData'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_principalInfo),
::uint32_t{0}};
if ((!((aReader)->ReadBytesInto((&((result__)->cookiePermission())), 4)))) {
aReader->FatalError("Error bulk reading fields from uint32_t");
return {};
}
// Sentinel = 'cookiePermission'
if ((!((aReader)->ReadSentinel(935659172)))) {
mozilla::ipc::SentinelReadError("Error bulk reading fields from uint32_t");
return {};
}
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct CookieJarSettingsArgs|
//
namespace mozilla {
namespace net {
} // namespace net
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::net::CookieJarSettingsArgs>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).isFirstPartyIsolated());
// Sentinel = 'isFirstPartyIsolated'
(aWriter)->WriteSentinel(1432815658);
IPC::WriteParam(aWriter, (aVar).shouldResistFingerprinting());
// Sentinel = 'shouldResistFingerprinting'
(aWriter)->WriteSentinel(2441284304);
IPC::WriteParam(aWriter, (aVar).isOnContentBlockingAllowList());
// Sentinel = 'isOnContentBlockingAllowList'
(aWriter)->WriteSentinel(2707622713);
IPC::WriteParam(aWriter, (aVar).cookiePermissions());
// Sentinel = 'cookiePermissions'
(aWriter)->WriteSentinel(1054607127);
IPC::WriteParam(aWriter, (aVar).isFixed());
// Sentinel = 'isFixed'
(aWriter)->WriteSentinel(187695821);
IPC::WriteParam(aWriter, (aVar).partitionKey());
// Sentinel = 'partitionKey'
(aWriter)->WriteSentinel(552600836);
IPC::WriteParam(aWriter, (aVar).hasFingerprintingRandomizationKey());
// Sentinel = 'hasFingerprintingRandomizationKey'
(aWriter)->WriteSentinel(3842968971);
IPC::WriteParam(aWriter, (aVar).fingerprintingRandomizationKey());
// Sentinel = 'fingerprintingRandomizationKey'
(aWriter)->WriteSentinel(3243707503);
(aWriter)->WriteBytes((&((aVar).topLevelWindowContextId())), 8);
// Sentinel = 'topLevelWindowContextId'
(aWriter)->WriteSentinel(1890388310);
(aWriter)->WriteBytes((&((aVar).cookieBehavior())), 4);
// Sentinel = 'cookieBehavior'
(aWriter)->WriteSentinel(706348459);
}
auto ParamTraits<::mozilla::net::CookieJarSettingsArgs>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___isFirstPartyIsolated = IPC::ReadParam<bool>(aReader);
if (!maybe___isFirstPartyIsolated) {
aReader->FatalError("Error deserializing 'isFirstPartyIsolated' (bool) member of 'CookieJarSettingsArgs'");
return {};
}
auto& _isFirstPartyIsolated = *maybe___isFirstPartyIsolated;
// Sentinel = 'isFirstPartyIsolated'
if ((!((aReader)->ReadSentinel(1432815658)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'isFirstPartyIsolated' (bool) member of 'CookieJarSettingsArgs'");
return {};
}
auto maybe___shouldResistFingerprinting = IPC::ReadParam<bool>(aReader);
if (!maybe___shouldResistFingerprinting) {
aReader->FatalError("Error deserializing 'shouldResistFingerprinting' (bool) member of 'CookieJarSettingsArgs'");
return {};
}
auto& _shouldResistFingerprinting = *maybe___shouldResistFingerprinting;
// Sentinel = 'shouldResistFingerprinting'
if ((!((aReader)->ReadSentinel(2441284304)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'shouldResistFingerprinting' (bool) member of 'CookieJarSettingsArgs'");
return {};
}
auto maybe___isOnContentBlockingAllowList = IPC::ReadParam<bool>(aReader);
if (!maybe___isOnContentBlockingAllowList) {
aReader->FatalError("Error deserializing 'isOnContentBlockingAllowList' (bool) member of 'CookieJarSettingsArgs'");
return {};
}
auto& _isOnContentBlockingAllowList = *maybe___isOnContentBlockingAllowList;
// Sentinel = 'isOnContentBlockingAllowList'
if ((!((aReader)->ReadSentinel(2707622713)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'isOnContentBlockingAllowList' (bool) member of 'CookieJarSettingsArgs'");
return {};
}
auto maybe___cookiePermissions = IPC::ReadParam<nsTArray<::mozilla::net::CookiePermissionData>>(aReader);
if (!maybe___cookiePermissions) {
aReader->FatalError("Error deserializing 'cookiePermissions' (CookiePermissionData[]) member of 'CookieJarSettingsArgs'");
return {};
}
auto& _cookiePermissions = *maybe___cookiePermissions;
// Sentinel = 'cookiePermissions'
if ((!((aReader)->ReadSentinel(1054607127)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'cookiePermissions' (CookiePermissionData[]) member of 'CookieJarSettingsArgs'");
return {};
}
auto maybe___isFixed = IPC::ReadParam<bool>(aReader);
if (!maybe___isFixed) {
aReader->FatalError("Error deserializing 'isFixed' (bool) member of 'CookieJarSettingsArgs'");
return {};
}
auto& _isFixed = *maybe___isFixed;
// Sentinel = 'isFixed'
if ((!((aReader)->ReadSentinel(187695821)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'isFixed' (bool) member of 'CookieJarSettingsArgs'");
return {};
}
auto maybe___partitionKey = IPC::ReadParam<::nsString>(aReader);
if (!maybe___partitionKey) {
aReader->FatalError("Error deserializing 'partitionKey' (nsString) member of 'CookieJarSettingsArgs'");
return {};
}
auto& _partitionKey = *maybe___partitionKey;
// Sentinel = 'partitionKey'
if ((!((aReader)->ReadSentinel(552600836)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'partitionKey' (nsString) member of 'CookieJarSettingsArgs'");
return {};
}
auto maybe___hasFingerprintingRandomizationKey = IPC::ReadParam<bool>(aReader);
if (!maybe___hasFingerprintingRandomizationKey) {
aReader->FatalError("Error deserializing 'hasFingerprintingRandomizationKey' (bool) member of 'CookieJarSettingsArgs'");
return {};
}
auto& _hasFingerprintingRandomizationKey = *maybe___hasFingerprintingRandomizationKey;
// Sentinel = 'hasFingerprintingRandomizationKey'
if ((!((aReader)->ReadSentinel(3842968971)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'hasFingerprintingRandomizationKey' (bool) member of 'CookieJarSettingsArgs'");
return {};
}
auto maybe___fingerprintingRandomizationKey = IPC::ReadParam<nsTArray<::uint8_t>>(aReader);
if (!maybe___fingerprintingRandomizationKey) {
aReader->FatalError("Error deserializing 'fingerprintingRandomizationKey' (uint8_t[]) member of 'CookieJarSettingsArgs'");
return {};
}
auto& _fingerprintingRandomizationKey = *maybe___fingerprintingRandomizationKey;
// Sentinel = 'fingerprintingRandomizationKey'
if ((!((aReader)->ReadSentinel(3243707503)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'fingerprintingRandomizationKey' (uint8_t[]) member of 'CookieJarSettingsArgs'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
::uint32_t{0},
std::move(_isFirstPartyIsolated),
std::move(_shouldResistFingerprinting),
std::move(_isOnContentBlockingAllowList),
std::move(_cookiePermissions),
std::move(_isFixed),
std::move(_partitionKey),
std::move(_hasFingerprintingRandomizationKey),
std::move(_fingerprintingRandomizationKey),
::uint64_t{0}};
if ((!((aReader)->ReadBytesInto((&((result__)->topLevelWindowContextId())), 8)))) {
aReader->FatalError("Error bulk reading fields from uint64_t");
return {};
}
// Sentinel = 'topLevelWindowContextId'
if ((!((aReader)->ReadSentinel(1890388310)))) {
mozilla::ipc::SentinelReadError("Error bulk reading fields from uint64_t");
return {};
}
if ((!((aReader)->ReadBytesInto((&((result__)->cookieBehavior())), 4)))) {
aReader->FatalError("Error bulk reading fields from uint32_t");
return {};
}
// Sentinel = 'cookieBehavior'
if ((!((aReader)->ReadSentinel(706348459)))) {
mozilla::ipc::SentinelReadError("Error bulk reading fields from uint32_t");
return {};
}
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct PreferredAlternativeDataTypeParams|
//
namespace mozilla {
namespace net {
} // namespace net
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::net::PreferredAlternativeDataTypeParams>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).type());
// Sentinel = 'type'
(aWriter)->WriteSentinel(75760067);
IPC::WriteParam(aWriter, (aVar).contentType());
// Sentinel = 'contentType'
(aWriter)->WriteSentinel(465241246);
IPC::WriteParam(aWriter, (aVar).deliverAltData());
// Sentinel = 'deliverAltData'
(aWriter)->WriteSentinel(704775559);
}
auto ParamTraits<::mozilla::net::PreferredAlternativeDataTypeParams>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___type = IPC::ReadParam<::nsCString>(aReader);
if (!maybe___type) {
aReader->FatalError("Error deserializing 'type' (nsCString) member of 'PreferredAlternativeDataTypeParams'");
return {};
}
auto& _type = *maybe___type;
// Sentinel = 'type'
if ((!((aReader)->ReadSentinel(75760067)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'type' (nsCString) member of 'PreferredAlternativeDataTypeParams'");
return {};
}
auto maybe___contentType = IPC::ReadParam<::nsCString>(aReader);
if (!maybe___contentType) {
aReader->FatalError("Error deserializing 'contentType' (nsCString) member of 'PreferredAlternativeDataTypeParams'");
return {};
}
auto& _contentType = *maybe___contentType;
// Sentinel = 'contentType'
if ((!((aReader)->ReadSentinel(465241246)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'contentType' (nsCString) member of 'PreferredAlternativeDataTypeParams'");
return {};
}
auto maybe___deliverAltData = IPC::ReadParam<::mozilla::net::PreferredAlternativeDataDeliveryTypeIPC>(aReader);
if (!maybe___deliverAltData) {
aReader->FatalError("Error deserializing 'deliverAltData' (PreferredAlternativeDataDeliveryTypeIPC) member of 'PreferredAlternativeDataTypeParams'");
return {};
}
auto& _deliverAltData = *maybe___deliverAltData;
// Sentinel = 'deliverAltData'
if ((!((aReader)->ReadSentinel(704775559)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'deliverAltData' (PreferredAlternativeDataDeliveryTypeIPC) member of 'PreferredAlternativeDataTypeParams'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_type),
std::move(_contentType),
std::move(_deliverAltData)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct RedirectHistoryEntryInfo|
//
namespace mozilla {
namespace net {
} // namespace net
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::net::RedirectHistoryEntryInfo>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).principalInfo());
// Sentinel = 'principalInfo'
(aWriter)->WriteSentinel(633472335);
IPC::WriteParam(aWriter, (aVar).referrerUri());
// Sentinel = 'referrerUri'
(aWriter)->WriteSentinel(460850318);
IPC::WriteParam(aWriter, (aVar).remoteAddress());
// Sentinel = 'remoteAddress'
(aWriter)->WriteSentinel(624362835);
}
auto ParamTraits<::mozilla::net::RedirectHistoryEntryInfo>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___principalInfo = IPC::ReadParam<::mozilla::ipc::PrincipalInfo>(aReader);
if (!maybe___principalInfo) {
aReader->FatalError("Error deserializing 'principalInfo' (PrincipalInfo) member of 'RedirectHistoryEntryInfo'");
return {};
}
auto& _principalInfo = *maybe___principalInfo;
// Sentinel = 'principalInfo'
if ((!((aReader)->ReadSentinel(633472335)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'principalInfo' (PrincipalInfo) member of 'RedirectHistoryEntryInfo'");
return {};
}
auto maybe___referrerUri = IPC::ReadParam<mozilla::Maybe<::mozilla::ipc::URIParams>>(aReader);
if (!maybe___referrerUri) {
aReader->FatalError("Error deserializing 'referrerUri' (URIParams?) member of 'RedirectHistoryEntryInfo'");
return {};
}
auto& _referrerUri = *maybe___referrerUri;
// Sentinel = 'referrerUri'
if ((!((aReader)->ReadSentinel(460850318)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'referrerUri' (URIParams?) member of 'RedirectHistoryEntryInfo'");
return {};
}
auto maybe___remoteAddress = IPC::ReadParam<::nsCString>(aReader);
if (!maybe___remoteAddress) {
aReader->FatalError("Error deserializing 'remoteAddress' (nsCString) member of 'RedirectHistoryEntryInfo'");
return {};
}
auto& _remoteAddress = *maybe___remoteAddress;
// Sentinel = 'remoteAddress'
if ((!((aReader)->ReadSentinel(624362835)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'remoteAddress' (nsCString) member of 'RedirectHistoryEntryInfo'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_principalInfo),
std::move(_referrerUri),
std::move(_remoteAddress)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct InterceptionInfoArg|
//
namespace mozilla {
namespace net {
} // namespace net
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::net::InterceptionInfoArg>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).triggeringPrincipalInfo());
// Sentinel = 'triggeringPrincipalInfo'
(aWriter)->WriteSentinel(1912736097);
IPC::WriteParam(aWriter, (aVar).contentPolicyType());
// Sentinel = 'contentPolicyType'
(aWriter)->WriteSentinel(1066927886);
IPC::WriteParam(aWriter, (aVar).redirectChain());
// Sentinel = 'redirectChain'
(aWriter)->WriteSentinel(618792246);
IPC::WriteParam(aWriter, (aVar).fromThirdParty());
// Sentinel = 'fromThirdParty'
(aWriter)->WriteSentinel(717751744);
}
auto ParamTraits<::mozilla::net::InterceptionInfoArg>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___triggeringPrincipalInfo = IPC::ReadParam<mozilla::Maybe<::mozilla::ipc::PrincipalInfo>>(aReader);
if (!maybe___triggeringPrincipalInfo) {
aReader->FatalError("Error deserializing 'triggeringPrincipalInfo' (PrincipalInfo?) member of 'InterceptionInfoArg'");
return {};
}
auto& _triggeringPrincipalInfo = *maybe___triggeringPrincipalInfo;
// Sentinel = 'triggeringPrincipalInfo'
if ((!((aReader)->ReadSentinel(1912736097)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'triggeringPrincipalInfo' (PrincipalInfo?) member of 'InterceptionInfoArg'");
return {};
}
auto maybe___contentPolicyType = IPC::ReadParam<::nsContentPolicyType>(aReader);
if (!maybe___contentPolicyType) {
aReader->FatalError("Error deserializing 'contentPolicyType' (nsContentPolicyType) member of 'InterceptionInfoArg'");
return {};
}
auto& _contentPolicyType = *maybe___contentPolicyType;
// Sentinel = 'contentPolicyType'
if ((!((aReader)->ReadSentinel(1066927886)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'contentPolicyType' (nsContentPolicyType) member of 'InterceptionInfoArg'");
return {};
}
auto maybe___redirectChain = IPC::ReadParam<nsTArray<::mozilla::net::RedirectHistoryEntryInfo>>(aReader);
if (!maybe___redirectChain) {
aReader->FatalError("Error deserializing 'redirectChain' (RedirectHistoryEntryInfo[]) member of 'InterceptionInfoArg'");
return {};
}
auto& _redirectChain = *maybe___redirectChain;
// Sentinel = 'redirectChain'
if ((!((aReader)->ReadSentinel(618792246)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'redirectChain' (RedirectHistoryEntryInfo[]) member of 'InterceptionInfoArg'");
return {};
}
auto maybe___fromThirdParty = IPC::ReadParam<bool>(aReader);
if (!maybe___fromThirdParty) {
aReader->FatalError("Error deserializing 'fromThirdParty' (bool) member of 'InterceptionInfoArg'");
return {};
}
auto& _fromThirdParty = *maybe___fromThirdParty;
// Sentinel = 'fromThirdParty'
if ((!((aReader)->ReadSentinel(717751744)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'fromThirdParty' (bool) member of 'InterceptionInfoArg'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_triggeringPrincipalInfo),
std::move(_contentPolicyType),
std::move(_redirectChain),
std::move(_fromThirdParty)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct LoadInfoArgs|
//
namespace mozilla {
namespace net {
auto LoadInfoArgs::StaticAssertions() const -> void
{
static_assert(
(offsetof(LoadInfoArgs, frameBrowsingContextID_) - offsetof(LoadInfoArgs, triggeringWindowId_)) == 24,
"Bad assumptions about field layout!");
static_assert(
(offsetof(LoadInfoArgs, requestBlockingReason_) - offsetof(LoadInfoArgs, securityFlags_)) == 20,
"Bad assumptions about field layout!");
}
} // namespace net
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::net::LoadInfoArgs>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).requestingPrincipalInfo());
// Sentinel = 'requestingPrincipalInfo'
(aWriter)->WriteSentinel(1936591222);
IPC::WriteParam(aWriter, (aVar).triggeringPrincipalInfo());
// Sentinel = 'triggeringPrincipalInfo'
(aWriter)->WriteSentinel(1912736097);
IPC::WriteParam(aWriter, (aVar).principalToInheritInfo());
// Sentinel = 'principalToInheritInfo'
(aWriter)->WriteSentinel(1730939109);
IPC::WriteParam(aWriter, (aVar).topLevelPrincipalInfo());
// Sentinel = 'topLevelPrincipalInfo'
(aWriter)->WriteSentinel(1575618682);
IPC::WriteParam(aWriter, (aVar).resultPrincipalURI());
// Sentinel = 'resultPrincipalURI'
(aWriter)->WriteSentinel(1196951346);
IPC::WriteParam(aWriter, (aVar).triggeringRemoteType());
// Sentinel = 'triggeringRemoteType'
(aWriter)->WriteSentinel(1463224385);
IPC::WriteParam(aWriter, (aVar).sandboxedNullPrincipalID());
// Sentinel = 'sandboxedNullPrincipalID'
(aWriter)->WriteSentinel(2047543683);
IPC::WriteParam(aWriter, (aVar).triggeringStorageAccess());
// Sentinel = 'triggeringStorageAccess'
(aWriter)->WriteSentinel(1908017498);
IPC::WriteParam(aWriter, (aVar).contentPolicyType());
// Sentinel = 'contentPolicyType'
(aWriter)->WriteSentinel(1066927886);
IPC::WriteParam(aWriter, (aVar).blockAllMixedContent());
// Sentinel = 'blockAllMixedContent'
(aWriter)->WriteSentinel(1382287351);
IPC::WriteParam(aWriter, (aVar).upgradeInsecureRequests());
// Sentinel = 'upgradeInsecureRequests'
(aWriter)->WriteSentinel(1898449283);
IPC::WriteParam(aWriter, (aVar).browserUpgradeInsecureRequests());
// Sentinel = 'browserUpgradeInsecureRequests'
(aWriter)->WriteSentinel(3215002727);
IPC::WriteParam(aWriter, (aVar).browserDidUpgradeInsecureRequests());
// Sentinel = 'browserDidUpgradeInsecureRequests'
(aWriter)->WriteSentinel(3812167032);
IPC::WriteParam(aWriter, (aVar).browserWouldUpgradeInsecureRequests());
// Sentinel = 'browserWouldUpgradeInsecureRequests'
(aWriter)->WriteSentinel(63966834);
IPC::WriteParam(aWriter, (aVar).forceAllowDataURI());
// Sentinel = 'forceAllowDataURI'
(aWriter)->WriteSentinel(1012729465);
IPC::WriteParam(aWriter, (aVar).allowInsecureRedirectToDataURI());
// Sentinel = 'allowInsecureRedirectToDataURI'
(aWriter)->WriteSentinel(3146189757);
IPC::WriteParam(aWriter, (aVar).skipContentPolicyCheckForWebRequest());
// Sentinel = 'skipContentPolicyCheckForWebRequest'
(aWriter)->WriteSentinel(4253683215);
IPC::WriteParam(aWriter, (aVar).originalFrameSrcLoad());
// Sentinel = 'originalFrameSrcLoad'
(aWriter)->WriteSentinel(1421019113);
IPC::WriteParam(aWriter, (aVar).forceInheritPrincipalDropped());
// Sentinel = 'forceInheritPrincipalDropped'
(aWriter)->WriteSentinel(2750286675);
IPC::WriteParam(aWriter, (aVar).initialSecurityCheckDone());
// Sentinel = 'initialSecurityCheckDone'
(aWriter)->WriteSentinel(2050099623);
IPC::WriteParam(aWriter, (aVar).isInThirdPartyContext());
// Sentinel = 'isInThirdPartyContext'
(aWriter)->WriteSentinel(1536362628);
IPC::WriteParam(aWriter, (aVar).isThirdPartyContextToTopWindow());
// Sentinel = 'isThirdPartyContextToTopWindow'
(aWriter)->WriteSentinel(3158248507);
IPC::WriteParam(aWriter, (aVar).isFormSubmission());
// Sentinel = 'isFormSubmission'
(aWriter)->WriteSentinel(927532701);
IPC::WriteParam(aWriter, (aVar).isGETRequest());
// Sentinel = 'isGETRequest'
(aWriter)->WriteSentinel(485098662);
IPC::WriteParam(aWriter, (aVar).sendCSPViolationEvents());
// Sentinel = 'sendCSPViolationEvents'
(aWriter)->WriteSentinel(1643907259);
IPC::WriteParam(aWriter, (aVar).originAttributes());
// Sentinel = 'originAttributes'
(aWriter)->WriteSentinel(947259056);
IPC::WriteParam(aWriter, (aVar).redirectChainIncludingInternalRedirects());
// Sentinel = 'redirectChainIncludingInternalRedirects'
(aWriter)->WriteSentinel(945622965);
IPC::WriteParam(aWriter, (aVar).redirectChain());
// Sentinel = 'redirectChain'
(aWriter)->WriteSentinel(618792246);
IPC::WriteParam(aWriter, (aVar).hasInjectedCookieForCookieBannerHandling());
// Sentinel = 'hasInjectedCookieForCookieBannerHandling'
(aWriter)->WriteSentinel(1098977209);
IPC::WriteParam(aWriter, (aVar).schemelessInput());
// Sentinel = 'schemelessInput'
(aWriter)->WriteSentinel(830015037);
IPC::WriteParam(aWriter, (aVar).httpsUpgradeTelemetry());
// Sentinel = 'httpsUpgradeTelemetry'
(aWriter)->WriteSentinel(1606289591);
IPC::WriteParam(aWriter, (aVar).clientInfo());
// Sentinel = 'clientInfo'
(aWriter)->WriteSentinel(373294092);
IPC::WriteParam(aWriter, (aVar).reservedClientInfo());
// Sentinel = 'reservedClientInfo'
(aWriter)->WriteSentinel(1176373068);
IPC::WriteParam(aWriter, (aVar).initialClientInfo());
// Sentinel = 'initialClientInfo'
(aWriter)->WriteSentinel(1038354134);
IPC::WriteParam(aWriter, (aVar).controller());
// Sentinel = 'controller'
(aWriter)->WriteSentinel(393348165);
IPC::WriteParam(aWriter, (aVar).corsUnsafeHeaders());
// Sentinel = 'corsUnsafeHeaders'
(aWriter)->WriteSentinel(1036977878);
IPC::WriteParam(aWriter, (aVar).forcePreflight());
// Sentinel = 'forcePreflight'
(aWriter)->WriteSentinel(714081717);
IPC::WriteParam(aWriter, (aVar).isPreflight());
// Sentinel = 'isPreflight'
(aWriter)->WriteSentinel(449578114);
IPC::WriteParam(aWriter, (aVar).loadTriggeredFromExternal());
// Sentinel = 'loadTriggeredFromExternal'
(aWriter)->WriteSentinel(2186938901);
IPC::WriteParam(aWriter, (aVar).serviceWorkerTaintingSynthesized());
// Sentinel = 'serviceWorkerTaintingSynthesized'
(aWriter)->WriteSentinel(3666152772);
IPC::WriteParam(aWriter, (aVar).documentHasUserInteracted());
// Sentinel = 'documentHasUserInteracted'
(aWriter)->WriteSentinel(2211777054);
IPC::WriteParam(aWriter, (aVar).allowListFutureDocumentsCreatedFromThisRedirectChain());
// Sentinel = 'allowListFutureDocumentsCreatedFromThisRedirectChain'
(aWriter)->WriteSentinel(777917666);
IPC::WriteParam(aWriter, (aVar).needForCheckingAntiTrackingHeuristic());
// Sentinel = 'needForCheckingAntiTrackingHeuristic'
(aWriter)->WriteSentinel(81006159);
IPC::WriteParam(aWriter, (aVar).cspNonce());
// Sentinel = 'cspNonce'
(aWriter)->WriteSentinel(245105466);
IPC::WriteParam(aWriter, (aVar).integrityMetadata());
// Sentinel = 'integrityMetadata'
(aWriter)->WriteSentinel(1071580929);
IPC::WriteParam(aWriter, (aVar).skipContentSniffing());
// Sentinel = 'skipContentSniffing'
(aWriter)->WriteSentinel(1308297159);
IPC::WriteParam(aWriter, (aVar).hstsStatus());
// Sentinel = 'hstsStatus'
(aWriter)->WriteSentinel(391971911);
IPC::WriteParam(aWriter, (aVar).hasValidUserGestureActivation());
// Sentinel = 'hasValidUserGestureActivation'
(aWriter)->WriteSentinel(2914388925);
IPC::WriteParam(aWriter, (aVar).textDirectiveUserActivation());
// Sentinel = 'textDirectiveUserActivation'
(aWriter)->WriteSentinel(2600012566);
IPC::WriteParam(aWriter, (aVar).allowDeprecatedSystemRequests());
// Sentinel = 'allowDeprecatedSystemRequests'
(aWriter)->WriteSentinel(2968456178);
IPC::WriteParam(aWriter, (aVar).isInDevToolsContext());
// Sentinel = 'isInDevToolsContext'
(aWriter)->WriteSentinel(1251215273);
IPC::WriteParam(aWriter, (aVar).parserCreatedScript());
// Sentinel = 'parserCreatedScript'
(aWriter)->WriteSentinel(1294862267);
IPC::WriteParam(aWriter, (aVar).isFromProcessingFrameAttributes());
// Sentinel = 'isFromProcessingFrameAttributes'
(aWriter)->WriteSentinel(3359968416);
IPC::WriteParam(aWriter, (aVar).isMediaRequest());
// Sentinel = 'isMediaRequest'
(aWriter)->WriteSentinel(694486438);
IPC::WriteParam(aWriter, (aVar).isMediaInitialRequest());
// Sentinel = 'isMediaInitialRequest'
(aWriter)->WriteSentinel(1525614704);
IPC::WriteParam(aWriter, (aVar).isFromObjectOrEmbed());
// Sentinel = 'isFromObjectOrEmbed'
(aWriter)->WriteSentinel(1251805030);
IPC::WriteParam(aWriter, (aVar).cookieJarSettings());
// Sentinel = 'cookieJarSettings'
(aWriter)->WriteSentinel(1031800553);
IPC::WriteParam(aWriter, (aVar).cspToInheritInfo());
// Sentinel = 'cspToInheritInfo'
(aWriter)->WriteSentinel(911541865);
IPC::WriteParam(aWriter, (aVar).storagePermission());
// Sentinel = 'storagePermission'
(aWriter)->WriteSentinel(1074333471);
IPC::WriteParam(aWriter, (aVar).overriddenFingerprintingSettings());
// Sentinel = 'overriddenFingerprintingSettings'
(aWriter)->WriteSentinel(3670740298);
IPC::WriteParam(aWriter, (aVar).isMetaRefresh());
// Sentinel = 'isMetaRefresh'
(aWriter)->WriteSentinel(604112179);
IPC::WriteParam(aWriter, (aVar).loadingEmbedderPolicy());
// Sentinel = 'loadingEmbedderPolicy'
(aWriter)->WriteSentinel(1541343335);
IPC::WriteParam(aWriter, (aVar).originTrialCoepCredentiallessEnabledForTopLevel());
// Sentinel = 'originTrialCoepCredentiallessEnabledForTopLevel'
(aWriter)->WriteSentinel(3280868027);
IPC::WriteParam(aWriter, (aVar).unstrippedURI());
// Sentinel = 'unstrippedURI'
(aWriter)->WriteSentinel(655230271);
IPC::WriteParam(aWriter, (aVar).interceptionInfo());
// Sentinel = 'interceptionInfo'
(aWriter)->WriteSentinel(955123361);
IPC::WriteParam(aWriter, (aVar).isNewWindowTarget());
// Sentinel = 'isNewWindowTarget'
(aWriter)->WriteSentinel(1033176806);
(aWriter)->WriteBytes((&((aVar).triggeringWindowId())), 32);
// Sentinel = 'triggeringWindowId | innerWindowID | browsingContextID | frameBrowsingContextID'
(aWriter)->WriteSentinel(3275628114);
(aWriter)->WriteBytes((&((aVar).securityFlags())), 24);
// Sentinel = 'securityFlags | sandboxFlags | triggeringSandboxFlags | tainting | httpsOnlyStatus | requestBlockingReason'
(aWriter)->WriteSentinel(2428512557);
}
auto ParamTraits<::mozilla::net::LoadInfoArgs>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___requestingPrincipalInfo = IPC::ReadParam<mozilla::Maybe<::mozilla::ipc::PrincipalInfo>>(aReader);
if (!maybe___requestingPrincipalInfo) {
aReader->FatalError("Error deserializing 'requestingPrincipalInfo' (PrincipalInfo?) member of 'LoadInfoArgs'");
return {};
}
auto& _requestingPrincipalInfo = *maybe___requestingPrincipalInfo;
// Sentinel = 'requestingPrincipalInfo'
if ((!((aReader)->ReadSentinel(1936591222)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'requestingPrincipalInfo' (PrincipalInfo?) member of 'LoadInfoArgs'");
return {};
}
auto maybe___triggeringPrincipalInfo = IPC::ReadParam<::mozilla::ipc::PrincipalInfo>(aReader);
if (!maybe___triggeringPrincipalInfo) {
aReader->FatalError("Error deserializing 'triggeringPrincipalInfo' (PrincipalInfo) member of 'LoadInfoArgs'");
return {};
}
auto& _triggeringPrincipalInfo = *maybe___triggeringPrincipalInfo;
// Sentinel = 'triggeringPrincipalInfo'
if ((!((aReader)->ReadSentinel(1912736097)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'triggeringPrincipalInfo' (PrincipalInfo) member of 'LoadInfoArgs'");
return {};
}
auto maybe___principalToInheritInfo = IPC::ReadParam<mozilla::Maybe<::mozilla::ipc::PrincipalInfo>>(aReader);
if (!maybe___principalToInheritInfo) {
aReader->FatalError("Error deserializing 'principalToInheritInfo' (PrincipalInfo?) member of 'LoadInfoArgs'");
return {};
}
auto& _principalToInheritInfo = *maybe___principalToInheritInfo;
// Sentinel = 'principalToInheritInfo'
if ((!((aReader)->ReadSentinel(1730939109)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'principalToInheritInfo' (PrincipalInfo?) member of 'LoadInfoArgs'");
return {};
}
auto maybe___topLevelPrincipalInfo = IPC::ReadParam<mozilla::Maybe<::mozilla::ipc::PrincipalInfo>>(aReader);
if (!maybe___topLevelPrincipalInfo) {
aReader->FatalError("Error deserializing 'topLevelPrincipalInfo' (PrincipalInfo?) member of 'LoadInfoArgs'");
return {};
}
auto& _topLevelPrincipalInfo = *maybe___topLevelPrincipalInfo;
// Sentinel = 'topLevelPrincipalInfo'
if ((!((aReader)->ReadSentinel(1575618682)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'topLevelPrincipalInfo' (PrincipalInfo?) member of 'LoadInfoArgs'");
return {};
}
auto maybe___resultPrincipalURI = IPC::ReadParam<mozilla::Maybe<::mozilla::ipc::URIParams>>(aReader);
if (!maybe___resultPrincipalURI) {
aReader->FatalError("Error deserializing 'resultPrincipalURI' (URIParams?) member of 'LoadInfoArgs'");
return {};
}
auto& _resultPrincipalURI = *maybe___resultPrincipalURI;
// Sentinel = 'resultPrincipalURI'
if ((!((aReader)->ReadSentinel(1196951346)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'resultPrincipalURI' (URIParams?) member of 'LoadInfoArgs'");
return {};
}
auto maybe___triggeringRemoteType = IPC::ReadParam<::nsCString>(aReader);
if (!maybe___triggeringRemoteType) {
aReader->FatalError("Error deserializing 'triggeringRemoteType' (nsCString) member of 'LoadInfoArgs'");
return {};
}
auto& _triggeringRemoteType = *maybe___triggeringRemoteType;
// Sentinel = 'triggeringRemoteType'
if ((!((aReader)->ReadSentinel(1463224385)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'triggeringRemoteType' (nsCString) member of 'LoadInfoArgs'");
return {};
}
auto maybe___sandboxedNullPrincipalID = IPC::ReadParam<::nsID>(aReader);
if (!maybe___sandboxedNullPrincipalID) {
aReader->FatalError("Error deserializing 'sandboxedNullPrincipalID' (nsID) member of 'LoadInfoArgs'");
return {};
}
auto& _sandboxedNullPrincipalID = *maybe___sandboxedNullPrincipalID;
// Sentinel = 'sandboxedNullPrincipalID'
if ((!((aReader)->ReadSentinel(2047543683)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'sandboxedNullPrincipalID' (nsID) member of 'LoadInfoArgs'");
return {};
}
auto maybe___triggeringStorageAccess = IPC::ReadParam<bool>(aReader);
if (!maybe___triggeringStorageAccess) {
aReader->FatalError("Error deserializing 'triggeringStorageAccess' (bool) member of 'LoadInfoArgs'");
return {};
}
auto& _triggeringStorageAccess = *maybe___triggeringStorageAccess;
// Sentinel = 'triggeringStorageAccess'
if ((!((aReader)->ReadSentinel(1908017498)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'triggeringStorageAccess' (bool) member of 'LoadInfoArgs'");
return {};
}
auto maybe___contentPolicyType = IPC::ReadParam<::nsContentPolicyType>(aReader);
if (!maybe___contentPolicyType) {
aReader->FatalError("Error deserializing 'contentPolicyType' (nsContentPolicyType) member of 'LoadInfoArgs'");
return {};
}
auto& _contentPolicyType = *maybe___contentPolicyType;
// Sentinel = 'contentPolicyType'
if ((!((aReader)->ReadSentinel(1066927886)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'contentPolicyType' (nsContentPolicyType) member of 'LoadInfoArgs'");
return {};
}
auto maybe___blockAllMixedContent = IPC::ReadParam<bool>(aReader);
if (!maybe___blockAllMixedContent) {
aReader->FatalError("Error deserializing 'blockAllMixedContent' (bool) member of 'LoadInfoArgs'");
return {};
}
auto& _blockAllMixedContent = *maybe___blockAllMixedContent;
// Sentinel = 'blockAllMixedContent'
if ((!((aReader)->ReadSentinel(1382287351)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'blockAllMixedContent' (bool) member of 'LoadInfoArgs'");
return {};
}
auto maybe___upgradeInsecureRequests = IPC::ReadParam<bool>(aReader);
if (!maybe___upgradeInsecureRequests) {
aReader->FatalError("Error deserializing 'upgradeInsecureRequests' (bool) member of 'LoadInfoArgs'");
return {};
}
auto& _upgradeInsecureRequests = *maybe___upgradeInsecureRequests;
// Sentinel = 'upgradeInsecureRequests'
if ((!((aReader)->ReadSentinel(1898449283)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'upgradeInsecureRequests' (bool) member of 'LoadInfoArgs'");
return {};
}
auto maybe___browserUpgradeInsecureRequests = IPC::ReadParam<bool>(aReader);
if (!maybe___browserUpgradeInsecureRequests) {
aReader->FatalError("Error deserializing 'browserUpgradeInsecureRequests' (bool) member of 'LoadInfoArgs'");
return {};
}
auto& _browserUpgradeInsecureRequests = *maybe___browserUpgradeInsecureRequests;
// Sentinel = 'browserUpgradeInsecureRequests'
if ((!((aReader)->ReadSentinel(3215002727)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'browserUpgradeInsecureRequests' (bool) member of 'LoadInfoArgs'");
return {};
}
auto maybe___browserDidUpgradeInsecureRequests = IPC::ReadParam<bool>(aReader);
if (!maybe___browserDidUpgradeInsecureRequests) {
aReader->FatalError("Error deserializing 'browserDidUpgradeInsecureRequests' (bool) member of 'LoadInfoArgs'");
return {};
}
auto& _browserDidUpgradeInsecureRequests = *maybe___browserDidUpgradeInsecureRequests;
// Sentinel = 'browserDidUpgradeInsecureRequests'
if ((!((aReader)->ReadSentinel(3812167032)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'browserDidUpgradeInsecureRequests' (bool) member of 'LoadInfoArgs'");
return {};
}
auto maybe___browserWouldUpgradeInsecureRequests = IPC::ReadParam<bool>(aReader);
if (!maybe___browserWouldUpgradeInsecureRequests) {
aReader->FatalError("Error deserializing 'browserWouldUpgradeInsecureRequests' (bool) member of 'LoadInfoArgs'");
return {};
}
auto& _browserWouldUpgradeInsecureRequests = *maybe___browserWouldUpgradeInsecureRequests;
// Sentinel = 'browserWouldUpgradeInsecureRequests'
if ((!((aReader)->ReadSentinel(63966834)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'browserWouldUpgradeInsecureRequests' (bool) member of 'LoadInfoArgs'");
return {};
}
auto maybe___forceAllowDataURI = IPC::ReadParam<bool>(aReader);
if (!maybe___forceAllowDataURI) {
aReader->FatalError("Error deserializing 'forceAllowDataURI' (bool) member of 'LoadInfoArgs'");
return {};
}
auto& _forceAllowDataURI = *maybe___forceAllowDataURI;
// Sentinel = 'forceAllowDataURI'
if ((!((aReader)->ReadSentinel(1012729465)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'forceAllowDataURI' (bool) member of 'LoadInfoArgs'");
return {};
}
auto maybe___allowInsecureRedirectToDataURI = IPC::ReadParam<bool>(aReader);
if (!maybe___allowInsecureRedirectToDataURI) {
aReader->FatalError("Error deserializing 'allowInsecureRedirectToDataURI' (bool) member of 'LoadInfoArgs'");
return {};
}
auto& _allowInsecureRedirectToDataURI = *maybe___allowInsecureRedirectToDataURI;
// Sentinel = 'allowInsecureRedirectToDataURI'
if ((!((aReader)->ReadSentinel(3146189757)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'allowInsecureRedirectToDataURI' (bool) member of 'LoadInfoArgs'");
return {};
}
auto maybe___skipContentPolicyCheckForWebRequest = IPC::ReadParam<bool>(aReader);
if (!maybe___skipContentPolicyCheckForWebRequest) {
aReader->FatalError("Error deserializing 'skipContentPolicyCheckForWebRequest' (bool) member of 'LoadInfoArgs'");
return {};
}
auto& _skipContentPolicyCheckForWebRequest = *maybe___skipContentPolicyCheckForWebRequest;
// Sentinel = 'skipContentPolicyCheckForWebRequest'
if ((!((aReader)->ReadSentinel(4253683215)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'skipContentPolicyCheckForWebRequest' (bool) member of 'LoadInfoArgs'");
return {};
}
auto maybe___originalFrameSrcLoad = IPC::ReadParam<bool>(aReader);
if (!maybe___originalFrameSrcLoad) {
aReader->FatalError("Error deserializing 'originalFrameSrcLoad' (bool) member of 'LoadInfoArgs'");
return {};
}
auto& _originalFrameSrcLoad = *maybe___originalFrameSrcLoad;
// Sentinel = 'originalFrameSrcLoad'
if ((!((aReader)->ReadSentinel(1421019113)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'originalFrameSrcLoad' (bool) member of 'LoadInfoArgs'");
return {};
}
auto maybe___forceInheritPrincipalDropped = IPC::ReadParam<bool>(aReader);
if (!maybe___forceInheritPrincipalDropped) {
aReader->FatalError("Error deserializing 'forceInheritPrincipalDropped' (bool) member of 'LoadInfoArgs'");
return {};
}
auto& _forceInheritPrincipalDropped = *maybe___forceInheritPrincipalDropped;
// Sentinel = 'forceInheritPrincipalDropped'
if ((!((aReader)->ReadSentinel(2750286675)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'forceInheritPrincipalDropped' (bool) member of 'LoadInfoArgs'");
return {};
}
auto maybe___initialSecurityCheckDone = IPC::ReadParam<bool>(aReader);
if (!maybe___initialSecurityCheckDone) {
aReader->FatalError("Error deserializing 'initialSecurityCheckDone' (bool) member of 'LoadInfoArgs'");
return {};
}
auto& _initialSecurityCheckDone = *maybe___initialSecurityCheckDone;
// Sentinel = 'initialSecurityCheckDone'
if ((!((aReader)->ReadSentinel(2050099623)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'initialSecurityCheckDone' (bool) member of 'LoadInfoArgs'");
return {};
}
auto maybe___isInThirdPartyContext = IPC::ReadParam<bool>(aReader);
if (!maybe___isInThirdPartyContext) {
aReader->FatalError("Error deserializing 'isInThirdPartyContext' (bool) member of 'LoadInfoArgs'");
return {};
}
auto& _isInThirdPartyContext = *maybe___isInThirdPartyContext;
// Sentinel = 'isInThirdPartyContext'
if ((!((aReader)->ReadSentinel(1536362628)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'isInThirdPartyContext' (bool) member of 'LoadInfoArgs'");
return {};
}
auto maybe___isThirdPartyContextToTopWindow = IPC::ReadParam<mozilla::Maybe<bool>>(aReader);
if (!maybe___isThirdPartyContextToTopWindow) {
aReader->FatalError("Error deserializing 'isThirdPartyContextToTopWindow' (bool?) member of 'LoadInfoArgs'");
return {};
}
auto& _isThirdPartyContextToTopWindow = *maybe___isThirdPartyContextToTopWindow;
// Sentinel = 'isThirdPartyContextToTopWindow'
if ((!((aReader)->ReadSentinel(3158248507)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'isThirdPartyContextToTopWindow' (bool?) member of 'LoadInfoArgs'");
return {};
}
auto maybe___isFormSubmission = IPC::ReadParam<bool>(aReader);
if (!maybe___isFormSubmission) {
aReader->FatalError("Error deserializing 'isFormSubmission' (bool) member of 'LoadInfoArgs'");
return {};
}
auto& _isFormSubmission = *maybe___isFormSubmission;
// Sentinel = 'isFormSubmission'
if ((!((aReader)->ReadSentinel(927532701)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'isFormSubmission' (bool) member of 'LoadInfoArgs'");
return {};
}
auto maybe___isGETRequest = IPC::ReadParam<bool>(aReader);
if (!maybe___isGETRequest) {
aReader->FatalError("Error deserializing 'isGETRequest' (bool) member of 'LoadInfoArgs'");
return {};
}
auto& _isGETRequest = *maybe___isGETRequest;
// Sentinel = 'isGETRequest'
if ((!((aReader)->ReadSentinel(485098662)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'isGETRequest' (bool) member of 'LoadInfoArgs'");
return {};
}
auto maybe___sendCSPViolationEvents = IPC::ReadParam<bool>(aReader);
if (!maybe___sendCSPViolationEvents) {
aReader->FatalError("Error deserializing 'sendCSPViolationEvents' (bool) member of 'LoadInfoArgs'");
return {};
}
auto& _sendCSPViolationEvents = *maybe___sendCSPViolationEvents;
// Sentinel = 'sendCSPViolationEvents'
if ((!((aReader)->ReadSentinel(1643907259)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'sendCSPViolationEvents' (bool) member of 'LoadInfoArgs'");
return {};
}
auto maybe___originAttributes = IPC::ReadParam<::mozilla::OriginAttributes>(aReader);
if (!maybe___originAttributes) {
aReader->FatalError("Error deserializing 'originAttributes' (OriginAttributes) member of 'LoadInfoArgs'");
return {};
}
auto& _originAttributes = *maybe___originAttributes;
// Sentinel = 'originAttributes'
if ((!((aReader)->ReadSentinel(947259056)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'originAttributes' (OriginAttributes) member of 'LoadInfoArgs'");
return {};
}
auto maybe___redirectChainIncludingInternalRedirects = IPC::ReadParam<nsTArray<::mozilla::net::RedirectHistoryEntryInfo>>(aReader);
if (!maybe___redirectChainIncludingInternalRedirects) {
aReader->FatalError("Error deserializing 'redirectChainIncludingInternalRedirects' (RedirectHistoryEntryInfo[]) member of 'LoadInfoArgs'");
return {};
}
auto& _redirectChainIncludingInternalRedirects = *maybe___redirectChainIncludingInternalRedirects;
// Sentinel = 'redirectChainIncludingInternalRedirects'
if ((!((aReader)->ReadSentinel(945622965)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'redirectChainIncludingInternalRedirects' (RedirectHistoryEntryInfo[]) member of 'LoadInfoArgs'");
return {};
}
auto maybe___redirectChain = IPC::ReadParam<nsTArray<::mozilla::net::RedirectHistoryEntryInfo>>(aReader);
if (!maybe___redirectChain) {
aReader->FatalError("Error deserializing 'redirectChain' (RedirectHistoryEntryInfo[]) member of 'LoadInfoArgs'");
return {};
}
auto& _redirectChain = *maybe___redirectChain;
// Sentinel = 'redirectChain'
if ((!((aReader)->ReadSentinel(618792246)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'redirectChain' (RedirectHistoryEntryInfo[]) member of 'LoadInfoArgs'");
return {};
}
auto maybe___hasInjectedCookieForCookieBannerHandling = IPC::ReadParam<bool>(aReader);
if (!maybe___hasInjectedCookieForCookieBannerHandling) {
aReader->FatalError("Error deserializing 'hasInjectedCookieForCookieBannerHandling' (bool) member of 'LoadInfoArgs'");
return {};
}
auto& _hasInjectedCookieForCookieBannerHandling = *maybe___hasInjectedCookieForCookieBannerHandling;
// Sentinel = 'hasInjectedCookieForCookieBannerHandling'
if ((!((aReader)->ReadSentinel(1098977209)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'hasInjectedCookieForCookieBannerHandling' (bool) member of 'LoadInfoArgs'");
return {};
}
auto maybe___schemelessInput = IPC::ReadParam<::nsILoadInfo::SchemelessInputType>(aReader);
if (!maybe___schemelessInput) {
aReader->FatalError("Error deserializing 'schemelessInput' (SchemelessInputType) member of 'LoadInfoArgs'");
return {};
}
auto& _schemelessInput = *maybe___schemelessInput;
// Sentinel = 'schemelessInput'
if ((!((aReader)->ReadSentinel(830015037)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'schemelessInput' (SchemelessInputType) member of 'LoadInfoArgs'");
return {};
}
auto maybe___httpsUpgradeTelemetry = IPC::ReadParam<::nsILoadInfo::HTTPSUpgradeTelemetryType>(aReader);
if (!maybe___httpsUpgradeTelemetry) {
aReader->FatalError("Error deserializing 'httpsUpgradeTelemetry' (HTTPSUpgradeTelemetryType) member of 'LoadInfoArgs'");
return {};
}
auto& _httpsUpgradeTelemetry = *maybe___httpsUpgradeTelemetry;
// Sentinel = 'httpsUpgradeTelemetry'
if ((!((aReader)->ReadSentinel(1606289591)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'httpsUpgradeTelemetry' (HTTPSUpgradeTelemetryType) member of 'LoadInfoArgs'");
return {};
}
auto maybe___clientInfo = IPC::ReadParam<mozilla::Maybe<::mozilla::dom::IPCClientInfo>>(aReader);
if (!maybe___clientInfo) {
aReader->FatalError("Error deserializing 'clientInfo' (IPCClientInfo?) member of 'LoadInfoArgs'");
return {};
}
auto& _clientInfo = *maybe___clientInfo;
// Sentinel = 'clientInfo'
if ((!((aReader)->ReadSentinel(373294092)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'clientInfo' (IPCClientInfo?) member of 'LoadInfoArgs'");
return {};
}
auto maybe___reservedClientInfo = IPC::ReadParam<mozilla::Maybe<::mozilla::dom::IPCClientInfo>>(aReader);
if (!maybe___reservedClientInfo) {
aReader->FatalError("Error deserializing 'reservedClientInfo' (IPCClientInfo?) member of 'LoadInfoArgs'");
return {};
}
auto& _reservedClientInfo = *maybe___reservedClientInfo;
// Sentinel = 'reservedClientInfo'
if ((!((aReader)->ReadSentinel(1176373068)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'reservedClientInfo' (IPCClientInfo?) member of 'LoadInfoArgs'");
return {};
}
auto maybe___initialClientInfo = IPC::ReadParam<mozilla::Maybe<::mozilla::dom::IPCClientInfo>>(aReader);
if (!maybe___initialClientInfo) {
aReader->FatalError("Error deserializing 'initialClientInfo' (IPCClientInfo?) member of 'LoadInfoArgs'");
return {};
}
auto& _initialClientInfo = *maybe___initialClientInfo;
// Sentinel = 'initialClientInfo'
if ((!((aReader)->ReadSentinel(1038354134)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'initialClientInfo' (IPCClientInfo?) member of 'LoadInfoArgs'");
return {};
}
auto maybe___controller = IPC::ReadParam<mozilla::Maybe<::mozilla::dom::IPCServiceWorkerDescriptor>>(aReader);
if (!maybe___controller) {
aReader->FatalError("Error deserializing 'controller' (IPCServiceWorkerDescriptor?) member of 'LoadInfoArgs'");
return {};
}
auto& _controller = *maybe___controller;
// Sentinel = 'controller'
if ((!((aReader)->ReadSentinel(393348165)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'controller' (IPCServiceWorkerDescriptor?) member of 'LoadInfoArgs'");
return {};
}
auto maybe___corsUnsafeHeaders = IPC::ReadParam<nsTArray<::nsCString>>(aReader);
if (!maybe___corsUnsafeHeaders) {
aReader->FatalError("Error deserializing 'corsUnsafeHeaders' (nsCString[]) member of 'LoadInfoArgs'");
return {};
}
auto& _corsUnsafeHeaders = *maybe___corsUnsafeHeaders;
// Sentinel = 'corsUnsafeHeaders'
if ((!((aReader)->ReadSentinel(1036977878)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'corsUnsafeHeaders' (nsCString[]) member of 'LoadInfoArgs'");
return {};
}
auto maybe___forcePreflight = IPC::ReadParam<bool>(aReader);
if (!maybe___forcePreflight) {
aReader->FatalError("Error deserializing 'forcePreflight' (bool) member of 'LoadInfoArgs'");
return {};
}
auto& _forcePreflight = *maybe___forcePreflight;
// Sentinel = 'forcePreflight'
if ((!((aReader)->ReadSentinel(714081717)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'forcePreflight' (bool) member of 'LoadInfoArgs'");
return {};
}
auto maybe___isPreflight = IPC::ReadParam<bool>(aReader);
if (!maybe___isPreflight) {
aReader->FatalError("Error deserializing 'isPreflight' (bool) member of 'LoadInfoArgs'");
return {};
}
auto& _isPreflight = *maybe___isPreflight;
// Sentinel = 'isPreflight'
if ((!((aReader)->ReadSentinel(449578114)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'isPreflight' (bool) member of 'LoadInfoArgs'");
return {};
}
auto maybe___loadTriggeredFromExternal = IPC::ReadParam<bool>(aReader);
if (!maybe___loadTriggeredFromExternal) {
aReader->FatalError("Error deserializing 'loadTriggeredFromExternal' (bool) member of 'LoadInfoArgs'");
return {};
}
auto& _loadTriggeredFromExternal = *maybe___loadTriggeredFromExternal;
// Sentinel = 'loadTriggeredFromExternal'
if ((!((aReader)->ReadSentinel(2186938901)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'loadTriggeredFromExternal' (bool) member of 'LoadInfoArgs'");
return {};
}
auto maybe___serviceWorkerTaintingSynthesized = IPC::ReadParam<bool>(aReader);
if (!maybe___serviceWorkerTaintingSynthesized) {
aReader->FatalError("Error deserializing 'serviceWorkerTaintingSynthesized' (bool) member of 'LoadInfoArgs'");
return {};
}
auto& _serviceWorkerTaintingSynthesized = *maybe___serviceWorkerTaintingSynthesized;
// Sentinel = 'serviceWorkerTaintingSynthesized'
if ((!((aReader)->ReadSentinel(3666152772)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'serviceWorkerTaintingSynthesized' (bool) member of 'LoadInfoArgs'");
return {};
}
auto maybe___documentHasUserInteracted = IPC::ReadParam<bool>(aReader);
if (!maybe___documentHasUserInteracted) {
aReader->FatalError("Error deserializing 'documentHasUserInteracted' (bool) member of 'LoadInfoArgs'");
return {};
}
auto& _documentHasUserInteracted = *maybe___documentHasUserInteracted;
// Sentinel = 'documentHasUserInteracted'
if ((!((aReader)->ReadSentinel(2211777054)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'documentHasUserInteracted' (bool) member of 'LoadInfoArgs'");
return {};
}
auto maybe___allowListFutureDocumentsCreatedFromThisRedirectChain = IPC::ReadParam<bool>(aReader);
if (!maybe___allowListFutureDocumentsCreatedFromThisRedirectChain) {
aReader->FatalError("Error deserializing 'allowListFutureDocumentsCreatedFromThisRedirectChain' (bool) member of 'LoadInfoArgs'");
return {};
}
auto& _allowListFutureDocumentsCreatedFromThisRedirectChain = *maybe___allowListFutureDocumentsCreatedFromThisRedirectChain;
// Sentinel = 'allowListFutureDocumentsCreatedFromThisRedirectChain'
if ((!((aReader)->ReadSentinel(777917666)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'allowListFutureDocumentsCreatedFromThisRedirectChain' (bool) member of 'LoadInfoArgs'");
return {};
}
auto maybe___needForCheckingAntiTrackingHeuristic = IPC::ReadParam<bool>(aReader);
if (!maybe___needForCheckingAntiTrackingHeuristic) {
aReader->FatalError("Error deserializing 'needForCheckingAntiTrackingHeuristic' (bool) member of 'LoadInfoArgs'");
return {};
}
auto& _needForCheckingAntiTrackingHeuristic = *maybe___needForCheckingAntiTrackingHeuristic;
// Sentinel = 'needForCheckingAntiTrackingHeuristic'
if ((!((aReader)->ReadSentinel(81006159)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'needForCheckingAntiTrackingHeuristic' (bool) member of 'LoadInfoArgs'");
return {};
}
auto maybe___cspNonce = IPC::ReadParam<::nsString>(aReader);
if (!maybe___cspNonce) {
aReader->FatalError("Error deserializing 'cspNonce' (nsString) member of 'LoadInfoArgs'");
return {};
}
auto& _cspNonce = *maybe___cspNonce;
// Sentinel = 'cspNonce'
if ((!((aReader)->ReadSentinel(245105466)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'cspNonce' (nsString) member of 'LoadInfoArgs'");
return {};
}
auto maybe___integrityMetadata = IPC::ReadParam<::nsString>(aReader);
if (!maybe___integrityMetadata) {
aReader->FatalError("Error deserializing 'integrityMetadata' (nsString) member of 'LoadInfoArgs'");
return {};
}
auto& _integrityMetadata = *maybe___integrityMetadata;
// Sentinel = 'integrityMetadata'
if ((!((aReader)->ReadSentinel(1071580929)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'integrityMetadata' (nsString) member of 'LoadInfoArgs'");
return {};
}
auto maybe___skipContentSniffing = IPC::ReadParam<bool>(aReader);
if (!maybe___skipContentSniffing) {
aReader->FatalError("Error deserializing 'skipContentSniffing' (bool) member of 'LoadInfoArgs'");
return {};
}
auto& _skipContentSniffing = *maybe___skipContentSniffing;
// Sentinel = 'skipContentSniffing'
if ((!((aReader)->ReadSentinel(1308297159)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'skipContentSniffing' (bool) member of 'LoadInfoArgs'");
return {};
}
auto maybe___hstsStatus = IPC::ReadParam<bool>(aReader);
if (!maybe___hstsStatus) {
aReader->FatalError("Error deserializing 'hstsStatus' (bool) member of 'LoadInfoArgs'");
return {};
}
auto& _hstsStatus = *maybe___hstsStatus;
// Sentinel = 'hstsStatus'
if ((!((aReader)->ReadSentinel(391971911)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'hstsStatus' (bool) member of 'LoadInfoArgs'");
return {};
}
auto maybe___hasValidUserGestureActivation = IPC::ReadParam<bool>(aReader);
if (!maybe___hasValidUserGestureActivation) {
aReader->FatalError("Error deserializing 'hasValidUserGestureActivation' (bool) member of 'LoadInfoArgs'");
return {};
}
auto& _hasValidUserGestureActivation = *maybe___hasValidUserGestureActivation;
// Sentinel = 'hasValidUserGestureActivation'
if ((!((aReader)->ReadSentinel(2914388925)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'hasValidUserGestureActivation' (bool) member of 'LoadInfoArgs'");
return {};
}
auto maybe___textDirectiveUserActivation = IPC::ReadParam<bool>(aReader);
if (!maybe___textDirectiveUserActivation) {
aReader->FatalError("Error deserializing 'textDirectiveUserActivation' (bool) member of 'LoadInfoArgs'");
return {};
}
auto& _textDirectiveUserActivation = *maybe___textDirectiveUserActivation;
// Sentinel = 'textDirectiveUserActivation'
if ((!((aReader)->ReadSentinel(2600012566)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'textDirectiveUserActivation' (bool) member of 'LoadInfoArgs'");
return {};
}
auto maybe___allowDeprecatedSystemRequests = IPC::ReadParam<bool>(aReader);
if (!maybe___allowDeprecatedSystemRequests) {
aReader->FatalError("Error deserializing 'allowDeprecatedSystemRequests' (bool) member of 'LoadInfoArgs'");
return {};
}
auto& _allowDeprecatedSystemRequests = *maybe___allowDeprecatedSystemRequests;
// Sentinel = 'allowDeprecatedSystemRequests'
if ((!((aReader)->ReadSentinel(2968456178)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'allowDeprecatedSystemRequests' (bool) member of 'LoadInfoArgs'");
return {};
}
auto maybe___isInDevToolsContext = IPC::ReadParam<bool>(aReader);
if (!maybe___isInDevToolsContext) {
aReader->FatalError("Error deserializing 'isInDevToolsContext' (bool) member of 'LoadInfoArgs'");
return {};
}
auto& _isInDevToolsContext = *maybe___isInDevToolsContext;
// Sentinel = 'isInDevToolsContext'
if ((!((aReader)->ReadSentinel(1251215273)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'isInDevToolsContext' (bool) member of 'LoadInfoArgs'");
return {};
}
auto maybe___parserCreatedScript = IPC::ReadParam<bool>(aReader);
if (!maybe___parserCreatedScript) {
aReader->FatalError("Error deserializing 'parserCreatedScript' (bool) member of 'LoadInfoArgs'");
return {};
}
auto& _parserCreatedScript = *maybe___parserCreatedScript;
// Sentinel = 'parserCreatedScript'
if ((!((aReader)->ReadSentinel(1294862267)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'parserCreatedScript' (bool) member of 'LoadInfoArgs'");
return {};
}
auto maybe___isFromProcessingFrameAttributes = IPC::ReadParam<bool>(aReader);
if (!maybe___isFromProcessingFrameAttributes) {
aReader->FatalError("Error deserializing 'isFromProcessingFrameAttributes' (bool) member of 'LoadInfoArgs'");
return {};
}
auto& _isFromProcessingFrameAttributes = *maybe___isFromProcessingFrameAttributes;
// Sentinel = 'isFromProcessingFrameAttributes'
if ((!((aReader)->ReadSentinel(3359968416)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'isFromProcessingFrameAttributes' (bool) member of 'LoadInfoArgs'");
return {};
}
auto maybe___isMediaRequest = IPC::ReadParam<bool>(aReader);
if (!maybe___isMediaRequest) {
aReader->FatalError("Error deserializing 'isMediaRequest' (bool) member of 'LoadInfoArgs'");
return {};
}
auto& _isMediaRequest = *maybe___isMediaRequest;
// Sentinel = 'isMediaRequest'
if ((!((aReader)->ReadSentinel(694486438)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'isMediaRequest' (bool) member of 'LoadInfoArgs'");
return {};
}
auto maybe___isMediaInitialRequest = IPC::ReadParam<bool>(aReader);
if (!maybe___isMediaInitialRequest) {
aReader->FatalError("Error deserializing 'isMediaInitialRequest' (bool) member of 'LoadInfoArgs'");
return {};
}
auto& _isMediaInitialRequest = *maybe___isMediaInitialRequest;
// Sentinel = 'isMediaInitialRequest'
if ((!((aReader)->ReadSentinel(1525614704)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'isMediaInitialRequest' (bool) member of 'LoadInfoArgs'");
return {};
}
auto maybe___isFromObjectOrEmbed = IPC::ReadParam<bool>(aReader);
if (!maybe___isFromObjectOrEmbed) {
aReader->FatalError("Error deserializing 'isFromObjectOrEmbed' (bool) member of 'LoadInfoArgs'");
return {};
}
auto& _isFromObjectOrEmbed = *maybe___isFromObjectOrEmbed;
// Sentinel = 'isFromObjectOrEmbed'
if ((!((aReader)->ReadSentinel(1251805030)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'isFromObjectOrEmbed' (bool) member of 'LoadInfoArgs'");
return {};
}
auto maybe___cookieJarSettings = IPC::ReadParam<::mozilla::net::CookieJarSettingsArgs>(aReader);
if (!maybe___cookieJarSettings) {
aReader->FatalError("Error deserializing 'cookieJarSettings' (CookieJarSettingsArgs) member of 'LoadInfoArgs'");
return {};
}
auto& _cookieJarSettings = *maybe___cookieJarSettings;
// Sentinel = 'cookieJarSettings'
if ((!((aReader)->ReadSentinel(1031800553)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'cookieJarSettings' (CookieJarSettingsArgs) member of 'LoadInfoArgs'");
return {};
}
auto maybe___cspToInheritInfo = IPC::ReadParam<mozilla::Maybe<::mozilla::ipc::CSPInfo>>(aReader);
if (!maybe___cspToInheritInfo) {
aReader->FatalError("Error deserializing 'cspToInheritInfo' (CSPInfo?) member of 'LoadInfoArgs'");
return {};
}
auto& _cspToInheritInfo = *maybe___cspToInheritInfo;
// Sentinel = 'cspToInheritInfo'
if ((!((aReader)->ReadSentinel(911541865)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'cspToInheritInfo' (CSPInfo?) member of 'LoadInfoArgs'");
return {};
}
auto maybe___storagePermission = IPC::ReadParam<::nsILoadInfo::StoragePermissionState>(aReader);
if (!maybe___storagePermission) {
aReader->FatalError("Error deserializing 'storagePermission' (StoragePermissionState) member of 'LoadInfoArgs'");
return {};
}
auto& _storagePermission = *maybe___storagePermission;
// Sentinel = 'storagePermission'
if ((!((aReader)->ReadSentinel(1074333471)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'storagePermission' (StoragePermissionState) member of 'LoadInfoArgs'");
return {};
}
auto maybe___overriddenFingerprintingSettings = IPC::ReadParam<mozilla::Maybe<::uint64_t>>(aReader);
if (!maybe___overriddenFingerprintingSettings) {
aReader->FatalError("Error deserializing 'overriddenFingerprintingSettings' (uint64_t?) member of 'LoadInfoArgs'");
return {};
}
auto& _overriddenFingerprintingSettings = *maybe___overriddenFingerprintingSettings;
// Sentinel = 'overriddenFingerprintingSettings'
if ((!((aReader)->ReadSentinel(3670740298)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'overriddenFingerprintingSettings' (uint64_t?) member of 'LoadInfoArgs'");
return {};
}
auto maybe___isMetaRefresh = IPC::ReadParam<bool>(aReader);
if (!maybe___isMetaRefresh) {
aReader->FatalError("Error deserializing 'isMetaRefresh' (bool) member of 'LoadInfoArgs'");
return {};
}
auto& _isMetaRefresh = *maybe___isMetaRefresh;
// Sentinel = 'isMetaRefresh'
if ((!((aReader)->ReadSentinel(604112179)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'isMetaRefresh' (bool) member of 'LoadInfoArgs'");
return {};
}
auto maybe___loadingEmbedderPolicy = IPC::ReadParam<::nsILoadInfo::CrossOriginEmbedderPolicy>(aReader);
if (!maybe___loadingEmbedderPolicy) {
aReader->FatalError("Error deserializing 'loadingEmbedderPolicy' (CrossOriginEmbedderPolicy) member of 'LoadInfoArgs'");
return {};
}
auto& _loadingEmbedderPolicy = *maybe___loadingEmbedderPolicy;
// Sentinel = 'loadingEmbedderPolicy'
if ((!((aReader)->ReadSentinel(1541343335)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'loadingEmbedderPolicy' (CrossOriginEmbedderPolicy) member of 'LoadInfoArgs'");
return {};
}
auto maybe___originTrialCoepCredentiallessEnabledForTopLevel = IPC::ReadParam<bool>(aReader);
if (!maybe___originTrialCoepCredentiallessEnabledForTopLevel) {
aReader->FatalError("Error deserializing 'originTrialCoepCredentiallessEnabledForTopLevel' (bool) member of 'LoadInfoArgs'");
return {};
}
auto& _originTrialCoepCredentiallessEnabledForTopLevel = *maybe___originTrialCoepCredentiallessEnabledForTopLevel;
// Sentinel = 'originTrialCoepCredentiallessEnabledForTopLevel'
if ((!((aReader)->ReadSentinel(3280868027)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'originTrialCoepCredentiallessEnabledForTopLevel' (bool) member of 'LoadInfoArgs'");
return {};
}
auto maybe___unstrippedURI = IPC::ReadParam<RefPtr<::nsIURI>>(aReader);
if (!maybe___unstrippedURI) {
aReader->FatalError("Error deserializing 'unstrippedURI' (nsIURI) member of 'LoadInfoArgs'");
return {};
}
auto& _unstrippedURI = *maybe___unstrippedURI;
// Sentinel = 'unstrippedURI'
if ((!((aReader)->ReadSentinel(655230271)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'unstrippedURI' (nsIURI) member of 'LoadInfoArgs'");
return {};
}
auto maybe___interceptionInfo = IPC::ReadParam<mozilla::Maybe<::mozilla::net::InterceptionInfoArg>>(aReader);
if (!maybe___interceptionInfo) {
aReader->FatalError("Error deserializing 'interceptionInfo' (InterceptionInfoArg?) member of 'LoadInfoArgs'");
return {};
}
auto& _interceptionInfo = *maybe___interceptionInfo;
// Sentinel = 'interceptionInfo'
if ((!((aReader)->ReadSentinel(955123361)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'interceptionInfo' (InterceptionInfoArg?) member of 'LoadInfoArgs'");
return {};
}
auto maybe___isNewWindowTarget = IPC::ReadParam<bool>(aReader);
if (!maybe___isNewWindowTarget) {
aReader->FatalError("Error deserializing 'isNewWindowTarget' (bool) member of 'LoadInfoArgs'");
return {};
}
auto& _isNewWindowTarget = *maybe___isNewWindowTarget;
// Sentinel = 'isNewWindowTarget'
if ((!((aReader)->ReadSentinel(1033176806)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'isNewWindowTarget' (bool) member of 'LoadInfoArgs'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_requestingPrincipalInfo),
std::move(_triggeringPrincipalInfo),
std::move(_principalToInheritInfo),
std::move(_topLevelPrincipalInfo),
std::move(_resultPrincipalURI),
std::move(_triggeringRemoteType),
std::move(_sandboxedNullPrincipalID),
::uint32_t{0},
::uint32_t{0},
::uint32_t{0},
::uint64_t{0},
std::move(_triggeringStorageAccess),
std::move(_contentPolicyType),
::uint32_t{0},
std::move(_blockAllMixedContent),
std::move(_upgradeInsecureRequests),
std::move(_browserUpgradeInsecureRequests),
std::move(_browserDidUpgradeInsecureRequests),
std::move(_browserWouldUpgradeInsecureRequests),
std::move(_forceAllowDataURI),
std::move(_allowInsecureRedirectToDataURI),
std::move(_skipContentPolicyCheckForWebRequest),
std::move(_originalFrameSrcLoad),
std::move(_forceInheritPrincipalDropped),
::uint64_t{0},
::uint64_t{0},
::uint64_t{0},
std::move(_initialSecurityCheckDone),
std::move(_isInThirdPartyContext),
std::move(_isThirdPartyContextToTopWindow),
std::move(_isFormSubmission),
std::move(_isGETRequest),
std::move(_sendCSPViolationEvents),
std::move(_originAttributes),
std::move(_redirectChainIncludingInternalRedirects),
std::move(_redirectChain),
std::move(_hasInjectedCookieForCookieBannerHandling),
std::move(_schemelessInput),
std::move(_httpsUpgradeTelemetry),
std::move(_clientInfo),
std::move(_reservedClientInfo),
std::move(_initialClientInfo),
std::move(_controller),
std::move(_corsUnsafeHeaders),
std::move(_forcePreflight),
std::move(_isPreflight),
std::move(_loadTriggeredFromExternal),
std::move(_serviceWorkerTaintingSynthesized),
std::move(_documentHasUserInteracted),
std::move(_allowListFutureDocumentsCreatedFromThisRedirectChain),
std::move(_needForCheckingAntiTrackingHeuristic),
std::move(_cspNonce),
std::move(_integrityMetadata),
std::move(_skipContentSniffing),
::uint32_t{0},
std::move(_hstsStatus),
std::move(_hasValidUserGestureActivation),
std::move(_textDirectiveUserActivation),
std::move(_allowDeprecatedSystemRequests),
std::move(_isInDevToolsContext),
std::move(_parserCreatedScript),
std::move(_isFromProcessingFrameAttributes),
std::move(_isMediaRequest),
std::move(_isMediaInitialRequest),
std::move(_isFromObjectOrEmbed),
std::move(_cookieJarSettings),
::uint32_t{0},
std::move(_cspToInheritInfo),
std::move(_storagePermission),
std::move(_overriddenFingerprintingSettings),
std::move(_isMetaRefresh),
std::move(_loadingEmbedderPolicy),
std::move(_originTrialCoepCredentiallessEnabledForTopLevel),
std::move(_unstrippedURI),
std::move(_interceptionInfo),
std::move(_isNewWindowTarget)};
if ((!((aReader)->ReadBytesInto((&((result__)->triggeringWindowId())), 32)))) {
aReader->FatalError("Error bulk reading fields from uint64_t");
return {};
}
// Sentinel = 'triggeringWindowId | innerWindowID | browsingContextID | frameBrowsingContextID'
if ((!((aReader)->ReadSentinel(3275628114)))) {
mozilla::ipc::SentinelReadError("Error bulk reading fields from uint64_t");
return {};
}
if ((!((aReader)->ReadBytesInto((&((result__)->securityFlags())), 24)))) {
aReader->FatalError("Error bulk reading fields from uint32_t");
return {};
}
// Sentinel = 'securityFlags | sandboxFlags | triggeringSandboxFlags | tainting | httpsOnlyStatus | requestBlockingReason'
if ((!((aReader)->ReadSentinel(2428512557)))) {
mozilla::ipc::SentinelReadError("Error bulk reading fields from uint32_t");
return {};
}
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct ParentLoadInfoForwarderArgs|
//
namespace mozilla {
namespace net {
auto ParentLoadInfoForwarderArgs::StaticAssertions() const -> void
{
static_assert(
(offsetof(ParentLoadInfoForwarderArgs, requestBlockingReason_) - offsetof(ParentLoadInfoForwarderArgs, tainting_)) == 12,
"Bad assumptions about field layout!");
}
} // namespace net
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::net::ParentLoadInfoForwarderArgs>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).allowInsecureRedirectToDataURI());
// Sentinel = 'allowInsecureRedirectToDataURI'
(aWriter)->WriteSentinel(3146189757);
IPC::WriteParam(aWriter, (aVar).controller());
// Sentinel = 'controller'
(aWriter)->WriteSentinel(393348165);
IPC::WriteParam(aWriter, (aVar).skipContentSniffing());
// Sentinel = 'skipContentSniffing'
(aWriter)->WriteSentinel(1308297159);
IPC::WriteParam(aWriter, (aVar).schemelessInput());
// Sentinel = 'schemelessInput'
(aWriter)->WriteSentinel(830015037);
IPC::WriteParam(aWriter, (aVar).httpsUpgradeTelemetry());
// Sentinel = 'httpsUpgradeTelemetry'
(aWriter)->WriteSentinel(1606289591);
IPC::WriteParam(aWriter, (aVar).hstsStatus());
// Sentinel = 'hstsStatus'
(aWriter)->WriteSentinel(391971911);
IPC::WriteParam(aWriter, (aVar).hasValidUserGestureActivation());
// Sentinel = 'hasValidUserGestureActivation'
(aWriter)->WriteSentinel(2914388925);
IPC::WriteParam(aWriter, (aVar).textDirectiveUserActivation());
// Sentinel = 'textDirectiveUserActivation'
(aWriter)->WriteSentinel(2600012566);
IPC::WriteParam(aWriter, (aVar).allowDeprecatedSystemRequests());
// Sentinel = 'allowDeprecatedSystemRequests'
(aWriter)->WriteSentinel(2968456178);
IPC::WriteParam(aWriter, (aVar).isInDevToolsContext());
// Sentinel = 'isInDevToolsContext'
(aWriter)->WriteSentinel(1251215273);
IPC::WriteParam(aWriter, (aVar).parserCreatedScript());
// Sentinel = 'parserCreatedScript'
(aWriter)->WriteSentinel(1294862267);
IPC::WriteParam(aWriter, (aVar).triggeringStorageAccess());
// Sentinel = 'triggeringStorageAccess'
(aWriter)->WriteSentinel(1908017498);
IPC::WriteParam(aWriter, (aVar).serviceWorkerTaintingSynthesized());
// Sentinel = 'serviceWorkerTaintingSynthesized'
(aWriter)->WriteSentinel(3666152772);
IPC::WriteParam(aWriter, (aVar).documentHasUserInteracted());
// Sentinel = 'documentHasUserInteracted'
(aWriter)->WriteSentinel(2211777054);
IPC::WriteParam(aWriter, (aVar).allowListFutureDocumentsCreatedFromThisRedirectChain());
// Sentinel = 'allowListFutureDocumentsCreatedFromThisRedirectChain'
(aWriter)->WriteSentinel(777917666);
IPC::WriteParam(aWriter, (aVar).cookieJarSettings());
// Sentinel = 'cookieJarSettings'
(aWriter)->WriteSentinel(1031800553);
IPC::WriteParam(aWriter, (aVar).containerFeaturePolicyInfo());
// Sentinel = 'containerFeaturePolicyInfo'
(aWriter)->WriteSentinel(2399406732);
IPC::WriteParam(aWriter, (aVar).storagePermission());
// Sentinel = 'storagePermission'
(aWriter)->WriteSentinel(1074333471);
IPC::WriteParam(aWriter, (aVar).overriddenFingerprintingSettings());
// Sentinel = 'overriddenFingerprintingSettings'
(aWriter)->WriteSentinel(3670740298);
IPC::WriteParam(aWriter, (aVar).isMetaRefresh());
// Sentinel = 'isMetaRefresh'
(aWriter)->WriteSentinel(604112179);
IPC::WriteParam(aWriter, (aVar).isThirdPartyContextToTopWindow());
// Sentinel = 'isThirdPartyContextToTopWindow'
(aWriter)->WriteSentinel(3158248507);
IPC::WriteParam(aWriter, (aVar).isInThirdPartyContext());
// Sentinel = 'isInThirdPartyContext'
(aWriter)->WriteSentinel(1536362628);
IPC::WriteParam(aWriter, (aVar).unstrippedURI());
// Sentinel = 'unstrippedURI'
(aWriter)->WriteSentinel(655230271);
(aWriter)->WriteBytes((&((aVar).triggeringWindowId())), 8);
// Sentinel = 'triggeringWindowId'
(aWriter)->WriteSentinel(1193543512);
(aWriter)->WriteBytes((&((aVar).tainting())), 16);
// Sentinel = 'tainting | httpsOnlyStatus | triggeringSandboxFlags | requestBlockingReason'
(aWriter)->WriteSentinel(1560747380);
}
auto ParamTraits<::mozilla::net::ParentLoadInfoForwarderArgs>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___allowInsecureRedirectToDataURI = IPC::ReadParam<bool>(aReader);
if (!maybe___allowInsecureRedirectToDataURI) {
aReader->FatalError("Error deserializing 'allowInsecureRedirectToDataURI' (bool) member of 'ParentLoadInfoForwarderArgs'");
return {};
}
auto& _allowInsecureRedirectToDataURI = *maybe___allowInsecureRedirectToDataURI;
// Sentinel = 'allowInsecureRedirectToDataURI'
if ((!((aReader)->ReadSentinel(3146189757)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'allowInsecureRedirectToDataURI' (bool) member of 'ParentLoadInfoForwarderArgs'");
return {};
}
auto maybe___controller = IPC::ReadParam<mozilla::Maybe<::mozilla::dom::IPCServiceWorkerDescriptor>>(aReader);
if (!maybe___controller) {
aReader->FatalError("Error deserializing 'controller' (IPCServiceWorkerDescriptor?) member of 'ParentLoadInfoForwarderArgs'");
return {};
}
auto& _controller = *maybe___controller;
// Sentinel = 'controller'
if ((!((aReader)->ReadSentinel(393348165)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'controller' (IPCServiceWorkerDescriptor?) member of 'ParentLoadInfoForwarderArgs'");
return {};
}
auto maybe___skipContentSniffing = IPC::ReadParam<bool>(aReader);
if (!maybe___skipContentSniffing) {
aReader->FatalError("Error deserializing 'skipContentSniffing' (bool) member of 'ParentLoadInfoForwarderArgs'");
return {};
}
auto& _skipContentSniffing = *maybe___skipContentSniffing;
// Sentinel = 'skipContentSniffing'
if ((!((aReader)->ReadSentinel(1308297159)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'skipContentSniffing' (bool) member of 'ParentLoadInfoForwarderArgs'");
return {};
}
auto maybe___schemelessInput = IPC::ReadParam<::nsILoadInfo::SchemelessInputType>(aReader);
if (!maybe___schemelessInput) {
aReader->FatalError("Error deserializing 'schemelessInput' (SchemelessInputType) member of 'ParentLoadInfoForwarderArgs'");
return {};
}
auto& _schemelessInput = *maybe___schemelessInput;
// Sentinel = 'schemelessInput'
if ((!((aReader)->ReadSentinel(830015037)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'schemelessInput' (SchemelessInputType) member of 'ParentLoadInfoForwarderArgs'");
return {};
}
auto maybe___httpsUpgradeTelemetry = IPC::ReadParam<::nsILoadInfo::HTTPSUpgradeTelemetryType>(aReader);
if (!maybe___httpsUpgradeTelemetry) {
aReader->FatalError("Error deserializing 'httpsUpgradeTelemetry' (HTTPSUpgradeTelemetryType) member of 'ParentLoadInfoForwarderArgs'");
return {};
}
auto& _httpsUpgradeTelemetry = *maybe___httpsUpgradeTelemetry;
// Sentinel = 'httpsUpgradeTelemetry'
if ((!((aReader)->ReadSentinel(1606289591)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'httpsUpgradeTelemetry' (HTTPSUpgradeTelemetryType) member of 'ParentLoadInfoForwarderArgs'");
return {};
}
auto maybe___hstsStatus = IPC::ReadParam<bool>(aReader);
if (!maybe___hstsStatus) {
aReader->FatalError("Error deserializing 'hstsStatus' (bool) member of 'ParentLoadInfoForwarderArgs'");
return {};
}
auto& _hstsStatus = *maybe___hstsStatus;
// Sentinel = 'hstsStatus'
if ((!((aReader)->ReadSentinel(391971911)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'hstsStatus' (bool) member of 'ParentLoadInfoForwarderArgs'");
return {};
}
auto maybe___hasValidUserGestureActivation = IPC::ReadParam<bool>(aReader);
if (!maybe___hasValidUserGestureActivation) {
aReader->FatalError("Error deserializing 'hasValidUserGestureActivation' (bool) member of 'ParentLoadInfoForwarderArgs'");
return {};
}
auto& _hasValidUserGestureActivation = *maybe___hasValidUserGestureActivation;
// Sentinel = 'hasValidUserGestureActivation'
if ((!((aReader)->ReadSentinel(2914388925)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'hasValidUserGestureActivation' (bool) member of 'ParentLoadInfoForwarderArgs'");
return {};
}
auto maybe___textDirectiveUserActivation = IPC::ReadParam<bool>(aReader);
if (!maybe___textDirectiveUserActivation) {
aReader->FatalError("Error deserializing 'textDirectiveUserActivation' (bool) member of 'ParentLoadInfoForwarderArgs'");
return {};
}
auto& _textDirectiveUserActivation = *maybe___textDirectiveUserActivation;
// Sentinel = 'textDirectiveUserActivation'
if ((!((aReader)->ReadSentinel(2600012566)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'textDirectiveUserActivation' (bool) member of 'ParentLoadInfoForwarderArgs'");
return {};
}
auto maybe___allowDeprecatedSystemRequests = IPC::ReadParam<bool>(aReader);
if (!maybe___allowDeprecatedSystemRequests) {
aReader->FatalError("Error deserializing 'allowDeprecatedSystemRequests' (bool) member of 'ParentLoadInfoForwarderArgs'");
return {};
}
auto& _allowDeprecatedSystemRequests = *maybe___allowDeprecatedSystemRequests;
// Sentinel = 'allowDeprecatedSystemRequests'
if ((!((aReader)->ReadSentinel(2968456178)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'allowDeprecatedSystemRequests' (bool) member of 'ParentLoadInfoForwarderArgs'");
return {};
}
auto maybe___isInDevToolsContext = IPC::ReadParam<bool>(aReader);
if (!maybe___isInDevToolsContext) {
aReader->FatalError("Error deserializing 'isInDevToolsContext' (bool) member of 'ParentLoadInfoForwarderArgs'");
return {};
}
auto& _isInDevToolsContext = *maybe___isInDevToolsContext;
// Sentinel = 'isInDevToolsContext'
if ((!((aReader)->ReadSentinel(1251215273)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'isInDevToolsContext' (bool) member of 'ParentLoadInfoForwarderArgs'");
return {};
}
auto maybe___parserCreatedScript = IPC::ReadParam<bool>(aReader);
if (!maybe___parserCreatedScript) {
aReader->FatalError("Error deserializing 'parserCreatedScript' (bool) member of 'ParentLoadInfoForwarderArgs'");
return {};
}
auto& _parserCreatedScript = *maybe___parserCreatedScript;
// Sentinel = 'parserCreatedScript'
if ((!((aReader)->ReadSentinel(1294862267)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'parserCreatedScript' (bool) member of 'ParentLoadInfoForwarderArgs'");
return {};
}
auto maybe___triggeringStorageAccess = IPC::ReadParam<bool>(aReader);
if (!maybe___triggeringStorageAccess) {
aReader->FatalError("Error deserializing 'triggeringStorageAccess' (bool) member of 'ParentLoadInfoForwarderArgs'");
return {};
}
auto& _triggeringStorageAccess = *maybe___triggeringStorageAccess;
// Sentinel = 'triggeringStorageAccess'
if ((!((aReader)->ReadSentinel(1908017498)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'triggeringStorageAccess' (bool) member of 'ParentLoadInfoForwarderArgs'");
return {};
}
auto maybe___serviceWorkerTaintingSynthesized = IPC::ReadParam<bool>(aReader);
if (!maybe___serviceWorkerTaintingSynthesized) {
aReader->FatalError("Error deserializing 'serviceWorkerTaintingSynthesized' (bool) member of 'ParentLoadInfoForwarderArgs'");
return {};
}
auto& _serviceWorkerTaintingSynthesized = *maybe___serviceWorkerTaintingSynthesized;
// Sentinel = 'serviceWorkerTaintingSynthesized'
if ((!((aReader)->ReadSentinel(3666152772)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'serviceWorkerTaintingSynthesized' (bool) member of 'ParentLoadInfoForwarderArgs'");
return {};
}
auto maybe___documentHasUserInteracted = IPC::ReadParam<bool>(aReader);
if (!maybe___documentHasUserInteracted) {
aReader->FatalError("Error deserializing 'documentHasUserInteracted' (bool) member of 'ParentLoadInfoForwarderArgs'");
return {};
}
auto& _documentHasUserInteracted = *maybe___documentHasUserInteracted;
// Sentinel = 'documentHasUserInteracted'
if ((!((aReader)->ReadSentinel(2211777054)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'documentHasUserInteracted' (bool) member of 'ParentLoadInfoForwarderArgs'");
return {};
}
auto maybe___allowListFutureDocumentsCreatedFromThisRedirectChain = IPC::ReadParam<bool>(aReader);
if (!maybe___allowListFutureDocumentsCreatedFromThisRedirectChain) {
aReader->FatalError("Error deserializing 'allowListFutureDocumentsCreatedFromThisRedirectChain' (bool) member of 'ParentLoadInfoForwarderArgs'");
return {};
}
auto& _allowListFutureDocumentsCreatedFromThisRedirectChain = *maybe___allowListFutureDocumentsCreatedFromThisRedirectChain;
// Sentinel = 'allowListFutureDocumentsCreatedFromThisRedirectChain'
if ((!((aReader)->ReadSentinel(777917666)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'allowListFutureDocumentsCreatedFromThisRedirectChain' (bool) member of 'ParentLoadInfoForwarderArgs'");
return {};
}
auto maybe___cookieJarSettings = IPC::ReadParam<mozilla::Maybe<::mozilla::net::CookieJarSettingsArgs>>(aReader);
if (!maybe___cookieJarSettings) {
aReader->FatalError("Error deserializing 'cookieJarSettings' (CookieJarSettingsArgs?) member of 'ParentLoadInfoForwarderArgs'");
return {};
}
auto& _cookieJarSettings = *maybe___cookieJarSettings;
// Sentinel = 'cookieJarSettings'
if ((!((aReader)->ReadSentinel(1031800553)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'cookieJarSettings' (CookieJarSettingsArgs?) member of 'ParentLoadInfoForwarderArgs'");
return {};
}
auto maybe___containerFeaturePolicyInfo = IPC::ReadParam<mozilla::Maybe<::mozilla::dom::FeaturePolicyInfo>>(aReader);
if (!maybe___containerFeaturePolicyInfo) {
aReader->FatalError("Error deserializing 'containerFeaturePolicyInfo' (FeaturePolicyInfo?) member of 'ParentLoadInfoForwarderArgs'");
return {};
}
auto& _containerFeaturePolicyInfo = *maybe___containerFeaturePolicyInfo;
// Sentinel = 'containerFeaturePolicyInfo'
if ((!((aReader)->ReadSentinel(2399406732)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'containerFeaturePolicyInfo' (FeaturePolicyInfo?) member of 'ParentLoadInfoForwarderArgs'");
return {};
}
auto maybe___storagePermission = IPC::ReadParam<::nsILoadInfo::StoragePermissionState>(aReader);
if (!maybe___storagePermission) {
aReader->FatalError("Error deserializing 'storagePermission' (StoragePermissionState) member of 'ParentLoadInfoForwarderArgs'");
return {};
}
auto& _storagePermission = *maybe___storagePermission;
// Sentinel = 'storagePermission'
if ((!((aReader)->ReadSentinel(1074333471)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'storagePermission' (StoragePermissionState) member of 'ParentLoadInfoForwarderArgs'");
return {};
}
auto maybe___overriddenFingerprintingSettings = IPC::ReadParam<mozilla::Maybe<::uint64_t>>(aReader);
if (!maybe___overriddenFingerprintingSettings) {
aReader->FatalError("Error deserializing 'overriddenFingerprintingSettings' (uint64_t?) member of 'ParentLoadInfoForwarderArgs'");
return {};
}
auto& _overriddenFingerprintingSettings = *maybe___overriddenFingerprintingSettings;
// Sentinel = 'overriddenFingerprintingSettings'
if ((!((aReader)->ReadSentinel(3670740298)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'overriddenFingerprintingSettings' (uint64_t?) member of 'ParentLoadInfoForwarderArgs'");
return {};
}
auto maybe___isMetaRefresh = IPC::ReadParam<bool>(aReader);
if (!maybe___isMetaRefresh) {
aReader->FatalError("Error deserializing 'isMetaRefresh' (bool) member of 'ParentLoadInfoForwarderArgs'");
return {};
}
auto& _isMetaRefresh = *maybe___isMetaRefresh;
// Sentinel = 'isMetaRefresh'
if ((!((aReader)->ReadSentinel(604112179)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'isMetaRefresh' (bool) member of 'ParentLoadInfoForwarderArgs'");
return {};
}
auto maybe___isThirdPartyContextToTopWindow = IPC::ReadParam<mozilla::Maybe<bool>>(aReader);
if (!maybe___isThirdPartyContextToTopWindow) {
aReader->FatalError("Error deserializing 'isThirdPartyContextToTopWindow' (bool?) member of 'ParentLoadInfoForwarderArgs'");
return {};
}
auto& _isThirdPartyContextToTopWindow = *maybe___isThirdPartyContextToTopWindow;
// Sentinel = 'isThirdPartyContextToTopWindow'
if ((!((aReader)->ReadSentinel(3158248507)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'isThirdPartyContextToTopWindow' (bool?) member of 'ParentLoadInfoForwarderArgs'");
return {};
}
auto maybe___isInThirdPartyContext = IPC::ReadParam<bool>(aReader);
if (!maybe___isInThirdPartyContext) {
aReader->FatalError("Error deserializing 'isInThirdPartyContext' (bool) member of 'ParentLoadInfoForwarderArgs'");
return {};
}
auto& _isInThirdPartyContext = *maybe___isInThirdPartyContext;
// Sentinel = 'isInThirdPartyContext'
if ((!((aReader)->ReadSentinel(1536362628)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'isInThirdPartyContext' (bool) member of 'ParentLoadInfoForwarderArgs'");
return {};
}
auto maybe___unstrippedURI = IPC::ReadParam<RefPtr<::nsIURI>>(aReader);
if (!maybe___unstrippedURI) {
aReader->FatalError("Error deserializing 'unstrippedURI' (nsIURI) member of 'ParentLoadInfoForwarderArgs'");
return {};
}
auto& _unstrippedURI = *maybe___unstrippedURI;
// Sentinel = 'unstrippedURI'
if ((!((aReader)->ReadSentinel(655230271)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'unstrippedURI' (nsIURI) member of 'ParentLoadInfoForwarderArgs'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_allowInsecureRedirectToDataURI),
std::move(_controller),
::uint32_t{0},
std::move(_skipContentSniffing),
::uint32_t{0},
std::move(_schemelessInput),
std::move(_httpsUpgradeTelemetry),
std::move(_hstsStatus),
std::move(_hasValidUserGestureActivation),
std::move(_textDirectiveUserActivation),
std::move(_allowDeprecatedSystemRequests),
std::move(_isInDevToolsContext),
std::move(_parserCreatedScript),
::uint32_t{0},
::uint64_t{0},
std::move(_triggeringStorageAccess),
std::move(_serviceWorkerTaintingSynthesized),
std::move(_documentHasUserInteracted),
std::move(_allowListFutureDocumentsCreatedFromThisRedirectChain),
std::move(_cookieJarSettings),
std::move(_containerFeaturePolicyInfo),
::uint32_t{0},
std::move(_storagePermission),
std::move(_overriddenFingerprintingSettings),
std::move(_isMetaRefresh),
std::move(_isThirdPartyContextToTopWindow),
std::move(_isInThirdPartyContext),
std::move(_unstrippedURI)};
if ((!((aReader)->ReadBytesInto((&((result__)->triggeringWindowId())), 8)))) {
aReader->FatalError("Error bulk reading fields from uint64_t");
return {};
}
// Sentinel = 'triggeringWindowId'
if ((!((aReader)->ReadSentinel(1193543512)))) {
mozilla::ipc::SentinelReadError("Error bulk reading fields from uint64_t");
return {};
}
if ((!((aReader)->ReadBytesInto((&((result__)->tainting())), 16)))) {
aReader->FatalError("Error bulk reading fields from uint32_t");
return {};
}
// Sentinel = 'tainting | httpsOnlyStatus | triggeringSandboxFlags | requestBlockingReason'
if ((!((aReader)->ReadSentinel(1560747380)))) {
mozilla::ipc::SentinelReadError("Error bulk reading fields from uint32_t");
return {};
}
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct ChildLoadInfoForwarderArgs|
//
namespace mozilla {
namespace net {
} // namespace net
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::net::ChildLoadInfoForwarderArgs>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).reservedClientInfo());
// Sentinel = 'reservedClientInfo'
(aWriter)->WriteSentinel(1176373068);
IPC::WriteParam(aWriter, (aVar).initialClientInfo());
// Sentinel = 'initialClientInfo'
(aWriter)->WriteSentinel(1038354134);
IPC::WriteParam(aWriter, (aVar).controller());
// Sentinel = 'controller'
(aWriter)->WriteSentinel(393348165);
(aWriter)->WriteBytes((&((aVar).requestBlockingReason())), 4);
// Sentinel = 'requestBlockingReason'
(aWriter)->WriteSentinel(1599867035);
}
auto ParamTraits<::mozilla::net::ChildLoadInfoForwarderArgs>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___reservedClientInfo = IPC::ReadParam<mozilla::Maybe<::mozilla::dom::IPCClientInfo>>(aReader);
if (!maybe___reservedClientInfo) {
aReader->FatalError("Error deserializing 'reservedClientInfo' (IPCClientInfo?) member of 'ChildLoadInfoForwarderArgs'");
return {};
}
auto& _reservedClientInfo = *maybe___reservedClientInfo;
// Sentinel = 'reservedClientInfo'
if ((!((aReader)->ReadSentinel(1176373068)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'reservedClientInfo' (IPCClientInfo?) member of 'ChildLoadInfoForwarderArgs'");
return {};
}
auto maybe___initialClientInfo = IPC::ReadParam<mozilla::Maybe<::mozilla::dom::IPCClientInfo>>(aReader);
if (!maybe___initialClientInfo) {
aReader->FatalError("Error deserializing 'initialClientInfo' (IPCClientInfo?) member of 'ChildLoadInfoForwarderArgs'");
return {};
}
auto& _initialClientInfo = *maybe___initialClientInfo;
// Sentinel = 'initialClientInfo'
if ((!((aReader)->ReadSentinel(1038354134)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'initialClientInfo' (IPCClientInfo?) member of 'ChildLoadInfoForwarderArgs'");
return {};
}
auto maybe___controller = IPC::ReadParam<mozilla::Maybe<::mozilla::dom::IPCServiceWorkerDescriptor>>(aReader);
if (!maybe___controller) {
aReader->FatalError("Error deserializing 'controller' (IPCServiceWorkerDescriptor?) member of 'ChildLoadInfoForwarderArgs'");
return {};
}
auto& _controller = *maybe___controller;
// Sentinel = 'controller'
if ((!((aReader)->ReadSentinel(393348165)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'controller' (IPCServiceWorkerDescriptor?) member of 'ChildLoadInfoForwarderArgs'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_reservedClientInfo),
std::move(_initialClientInfo),
std::move(_controller),
::uint32_t{0}};
if ((!((aReader)->ReadBytesInto((&((result__)->requestBlockingReason())), 4)))) {
aReader->FatalError("Error bulk reading fields from uint32_t");
return {};
}
// Sentinel = 'requestBlockingReason'
if ((!((aReader)->ReadSentinel(1599867035)))) {
mozilla::ipc::SentinelReadError("Error bulk reading fields from uint32_t");
return {};
}
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct CorsPreflightArgs|
//
namespace mozilla {
namespace net {
} // namespace net
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::net::CorsPreflightArgs>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).unsafeHeaders());
// Sentinel = 'unsafeHeaders'
(aWriter)->WriteSentinel(619709759);
}
auto ParamTraits<::mozilla::net::CorsPreflightArgs>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___unsafeHeaders = IPC::ReadParam<nsTArray<::nsCString>>(aReader);
if (!maybe___unsafeHeaders) {
aReader->FatalError("Error deserializing 'unsafeHeaders' (nsCString[]) member of 'CorsPreflightArgs'");
return {};
}
auto& _unsafeHeaders = *maybe___unsafeHeaders;
// Sentinel = 'unsafeHeaders'
if ((!((aReader)->ReadSentinel(619709759)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'unsafeHeaders' (nsCString[]) member of 'CorsPreflightArgs'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_unsafeHeaders)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct HttpChannelOpenArgs|
//
namespace mozilla {
namespace net {
auto HttpChannelOpenArgs::StaticAssertions() const -> void
{
static_assert(
(offsetof(HttpChannelOpenArgs, earlyHintPreloaderId_) - offsetof(HttpChannelOpenArgs, startPos_)) == 40,
"Bad assumptions about field layout!");
static_assert(
(offsetof(HttpChannelOpenArgs, redirectMode_) - offsetof(HttpChannelOpenArgs, loadFlags_)) == 20,
"Bad assumptions about field layout!");
}
} // namespace net
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::net::HttpChannelOpenArgs>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).uri());
// Sentinel = 'uri'
(aWriter)->WriteSentinel(45023569);
IPC::WriteParam(aWriter, (aVar).original());
// Sentinel = 'original'
(aWriter)->WriteSentinel(255001430);
IPC::WriteParam(aWriter, (aVar).doc());
// Sentinel = 'doc'
(aWriter)->WriteSentinel(40894775);
IPC::WriteParam(aWriter, (aVar).referrerInfo());
// Sentinel = 'referrerInfo'
(aWriter)->WriteSentinel(540214506);
IPC::WriteParam(aWriter, (aVar).apiRedirectTo());
// Sentinel = 'apiRedirectTo'
(aWriter)->WriteSentinel(606143792);
IPC::WriteParam(aWriter, (aVar).topWindowURI());
// Sentinel = 'topWindowURI'
(aWriter)->WriteSentinel(541394108);
IPC::WriteParam(aWriter, (aVar).requestHeaders());
// Sentinel = 'requestHeaders'
(aWriter)->WriteSentinel(732693958);
IPC::WriteParam(aWriter, (aVar).preferredAlternativeTypes());
// Sentinel = 'preferredAlternativeTypes'
(aWriter)->WriteSentinel(2243365460);
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).navigationStartTimeStamp());
// Sentinel = 'navigationStartTimeStamp'
(aWriter)->WriteSentinel(2071661011);
IPC::WriteParam(aWriter, (aVar).requestMethod());
// Sentinel = 'requestMethod'
(aWriter)->WriteSentinel(643958123);
IPC::WriteParam(aWriter, (aVar).classOfService());
// Sentinel = 'classOfService'
(aWriter)->WriteSentinel(704710045);
IPC::WriteParam(aWriter, (aVar).entityID());
// Sentinel = 'entityID'
(aWriter)->WriteSentinel(252183339);
IPC::WriteParam(aWriter, (aVar).appCacheClientID());
// Sentinel = 'appCacheClientID'
(aWriter)->WriteSentinel(872809986);
IPC::WriteParam(aWriter, (aVar).preflightArgs());
// Sentinel = 'preflightArgs'
(aWriter)->WriteSentinel(630981971);
IPC::WriteParam(aWriter, (aVar).contentTypeHint());
// Sentinel = 'contentTypeHint'
(aWriter)->WriteSentinel(836634161);
IPC::WriteParam(aWriter, (aVar).integrityMetadata());
// Sentinel = 'integrityMetadata'
(aWriter)->WriteSentinel(1071580929);
IPC::WriteParam(aWriter, (aVar).uploadStream());
// Sentinel = 'uploadStream'
(aWriter)->WriteSentinel(546768114);
IPC::WriteParam(aWriter, (aVar).loadInfo());
// Sentinel = 'loadInfo'
(aWriter)->WriteSentinel(240386861);
IPC::WriteParam(aWriter, (aVar).uploadStreamHasHeaders());
// Sentinel = 'uploadStreamHasHeaders'
(aWriter)->WriteSentinel(1714227402);
IPC::WriteParam(aWriter, (aVar).allowSTS());
// Sentinel = 'allowSTS'
(aWriter)->WriteSentinel(243729178);
IPC::WriteParam(aWriter, (aVar).resumeAt());
// Sentinel = 'resumeAt'
(aWriter)->WriteSentinel(254739271);
IPC::WriteParam(aWriter, (aVar).allowSpdy());
// Sentinel = 'allowSpdy'
(aWriter)->WriteSentinel(311428032);
IPC::WriteParam(aWriter, (aVar).allowHttp3());
// Sentinel = 'allowHttp3'
(aWriter)->WriteSentinel(377095155);
IPC::WriteParam(aWriter, (aVar).allowAltSvc());
// Sentinel = 'allowAltSvc'
(aWriter)->WriteSentinel(447546477);
IPC::WriteParam(aWriter, (aVar).beConservative());
// Sentinel = 'beConservative'
(aWriter)->WriteSentinel(706086337);
IPC::WriteParam(aWriter, (aVar).bypassProxy());
// Sentinel = 'bypassProxy'
(aWriter)->WriteSentinel(467141813);
IPC::WriteParam(aWriter, (aVar).blockAuthPrompt());
// Sentinel = 'blockAuthPrompt'
(aWriter)->WriteSentinel(807732768);
IPC::WriteParam(aWriter, (aVar).allowStaleCacheContent());
// Sentinel = 'allowStaleCacheContent'
(aWriter)->WriteSentinel(1689192648);
IPC::WriteParam(aWriter, (aVar).requestMode());
// Sentinel = 'requestMode'
(aWriter)->WriteSentinel(468386959);
IPC::WriteParam(aWriter, (aVar).forceValidateCacheContent());
// Sentinel = 'forceValidateCacheContent'
(aWriter)->WriteSentinel(2152008169);
IPC::WriteParam(aWriter, (aVar).preferCacheLoadOverBypass());
// Sentinel = 'preferCacheLoadOverBypass'
(aWriter)->WriteSentinel(2144602599);
IPC::WriteParam(aWriter, (aVar).forceMainDocumentChannel());
// Sentinel = 'forceMainDocumentChannel'
(aWriter)->WriteSentinel(1994656141);
IPC::WriteParam(aWriter, (aVar).classicScriptHintCharset());
// Sentinel = 'classicScriptHintCharset'
(aWriter)->WriteSentinel(2030963125);
IPC::WriteParam(aWriter, (aVar).documentCharacterSet());
// Sentinel = 'documentCharacterSet'
(aWriter)->WriteSentinel(1431570457);
IPC::WriteParam(aWriter, (aVar).isUserAgentHeaderModified());
// Sentinel = 'isUserAgentHeaderModified'
(aWriter)->WriteSentinel(2147355093);
IPC::WriteParam(aWriter, (aVar).initiatorType());
// Sentinel = 'initiatorType'
(aWriter)->WriteSentinel(642647414);
(aWriter)->WriteBytes((&((aVar).startPos())), 48);
// Sentinel = 'startPos | requestContextID | channelId | contentWindowId | browserId | earlyHintPreloaderId'
(aWriter)->WriteSentinel(1451041498);
(aWriter)->WriteBytes((&((aVar).loadFlags())), 24);
// Sentinel = 'loadFlags | thirdPartyFlags | tlsFlags | cacheKey | initialRwin | redirectMode'
(aWriter)->WriteSentinel(2034441488);
(aWriter)->WriteBytes((&((aVar).priority())), 2);
// Sentinel = 'priority'
(aWriter)->WriteSentinel(262865795);
(aWriter)->WriteBytes((&((aVar).redirectionLimit())), 1);
// Sentinel = 'redirectionLimit'
(aWriter)->WriteSentinel(941295256);
}
auto ParamTraits<::mozilla::net::HttpChannelOpenArgs>::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 'HttpChannelOpenArgs'");
return {};
}
auto& _uri = *maybe___uri;
// Sentinel = 'uri'
if ((!((aReader)->ReadSentinel(45023569)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uri' (nsIURI) member of 'HttpChannelOpenArgs'");
return {};
}
auto maybe___original = IPC::ReadParam<RefPtr<::nsIURI>>(aReader);
if (!maybe___original) {
aReader->FatalError("Error deserializing 'original' (nsIURI) member of 'HttpChannelOpenArgs'");
return {};
}
auto& _original = *maybe___original;
// Sentinel = 'original'
if ((!((aReader)->ReadSentinel(255001430)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'original' (nsIURI) member of 'HttpChannelOpenArgs'");
return {};
}
auto maybe___doc = IPC::ReadParam<RefPtr<::nsIURI>>(aReader);
if (!maybe___doc) {
aReader->FatalError("Error deserializing 'doc' (nsIURI) member of 'HttpChannelOpenArgs'");
return {};
}
auto& _doc = *maybe___doc;
// Sentinel = 'doc'
if ((!((aReader)->ReadSentinel(40894775)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'doc' (nsIURI) member of 'HttpChannelOpenArgs'");
return {};
}
auto maybe___referrerInfo = IPC::ReadParam<RefPtr<::nsIReferrerInfo>>(aReader);
if (!maybe___referrerInfo) {
aReader->FatalError("Error deserializing 'referrerInfo' (nsIReferrerInfo) member of 'HttpChannelOpenArgs'");
return {};
}
auto& _referrerInfo = *maybe___referrerInfo;
// Sentinel = 'referrerInfo'
if ((!((aReader)->ReadSentinel(540214506)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'referrerInfo' (nsIReferrerInfo) member of 'HttpChannelOpenArgs'");
return {};
}
auto maybe___apiRedirectTo = IPC::ReadParam<RefPtr<::nsIURI>>(aReader);
if (!maybe___apiRedirectTo) {
aReader->FatalError("Error deserializing 'apiRedirectTo' (nsIURI) member of 'HttpChannelOpenArgs'");
return {};
}
auto& _apiRedirectTo = *maybe___apiRedirectTo;
// Sentinel = 'apiRedirectTo'
if ((!((aReader)->ReadSentinel(606143792)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'apiRedirectTo' (nsIURI) member of 'HttpChannelOpenArgs'");
return {};
}
auto maybe___topWindowURI = IPC::ReadParam<RefPtr<::nsIURI>>(aReader);
if (!maybe___topWindowURI) {
aReader->FatalError("Error deserializing 'topWindowURI' (nsIURI) member of 'HttpChannelOpenArgs'");
return {};
}
auto& _topWindowURI = *maybe___topWindowURI;
// Sentinel = 'topWindowURI'
if ((!((aReader)->ReadSentinel(541394108)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'topWindowURI' (nsIURI) member of 'HttpChannelOpenArgs'");
return {};
}
auto maybe___requestHeaders = IPC::ReadParam<::mozilla::net::RequestHeaderTuples>(aReader);
if (!maybe___requestHeaders) {
aReader->FatalError("Error deserializing 'requestHeaders' (RequestHeaderTuples) member of 'HttpChannelOpenArgs'");
return {};
}
auto& _requestHeaders = *maybe___requestHeaders;
// Sentinel = 'requestHeaders'
if ((!((aReader)->ReadSentinel(732693958)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'requestHeaders' (RequestHeaderTuples) member of 'HttpChannelOpenArgs'");
return {};
}
auto maybe___preferredAlternativeTypes = IPC::ReadParam<nsTArray<::mozilla::net::PreferredAlternativeDataTypeParams>>(aReader);
if (!maybe___preferredAlternativeTypes) {
aReader->FatalError("Error deserializing 'preferredAlternativeTypes' (PreferredAlternativeDataTypeParams[]) member of 'HttpChannelOpenArgs'");
return {};
}
auto& _preferredAlternativeTypes = *maybe___preferredAlternativeTypes;
// Sentinel = 'preferredAlternativeTypes'
if ((!((aReader)->ReadSentinel(2243365460)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'preferredAlternativeTypes' (PreferredAlternativeDataTypeParams[]) member of 'HttpChannelOpenArgs'");
return {};
}
auto maybe___launchServiceWorkerStart = IPC::ReadParam<::mozilla::TimeStamp>(aReader);
if (!maybe___launchServiceWorkerStart) {
aReader->FatalError("Error deserializing 'launchServiceWorkerStart' (TimeStamp) member of 'HttpChannelOpenArgs'");
return {};
}
auto& _launchServiceWorkerStart = *maybe___launchServiceWorkerStart;
// Sentinel = 'launchServiceWorkerStart'
if ((!((aReader)->ReadSentinel(2052262357)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'launchServiceWorkerStart' (TimeStamp) member of 'HttpChannelOpenArgs'");
return {};
}
auto maybe___launchServiceWorkerEnd = IPC::ReadParam<::mozilla::TimeStamp>(aReader);
if (!maybe___launchServiceWorkerEnd) {
aReader->FatalError("Error deserializing 'launchServiceWorkerEnd' (TimeStamp) member of 'HttpChannelOpenArgs'");
return {};
}
auto& _launchServiceWorkerEnd = *maybe___launchServiceWorkerEnd;
// Sentinel = 'launchServiceWorkerEnd'
if ((!((aReader)->ReadSentinel(1726613726)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'launchServiceWorkerEnd' (TimeStamp) member of 'HttpChannelOpenArgs'");
return {};
}
auto maybe___dispatchFetchEventStart = IPC::ReadParam<::mozilla::TimeStamp>(aReader);
if (!maybe___dispatchFetchEventStart) {
aReader->FatalError("Error deserializing 'dispatchFetchEventStart' (TimeStamp) member of 'HttpChannelOpenArgs'");
return {};
}
auto& _dispatchFetchEventStart = *maybe___dispatchFetchEventStart;
// Sentinel = 'dispatchFetchEventStart'
if ((!((aReader)->ReadSentinel(1861880139)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'dispatchFetchEventStart' (TimeStamp) member of 'HttpChannelOpenArgs'");
return {};
}
auto maybe___dispatchFetchEventEnd = IPC::ReadParam<::mozilla::TimeStamp>(aReader);
if (!maybe___dispatchFetchEventEnd) {
aReader->FatalError("Error deserializing 'dispatchFetchEventEnd' (TimeStamp) member of 'HttpChannelOpenArgs'");
return {};
}
auto& _dispatchFetchEventEnd = *maybe___dispatchFetchEventEnd;
// Sentinel = 'dispatchFetchEventEnd'
if ((!((aReader)->ReadSentinel(1554319444)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'dispatchFetchEventEnd' (TimeStamp) member of 'HttpChannelOpenArgs'");
return {};
}
auto maybe___handleFetchEventStart = IPC::ReadParam<::mozilla::TimeStamp>(aReader);
if (!maybe___handleFetchEventStart) {
aReader->FatalError("Error deserializing 'handleFetchEventStart' (TimeStamp) member of 'HttpChannelOpenArgs'");
return {};
}
auto& _handleFetchEventStart = *maybe___handleFetchEventStart;
// Sentinel = 'handleFetchEventStart'
if ((!((aReader)->ReadSentinel(1529022567)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'handleFetchEventStart' (TimeStamp) member of 'HttpChannelOpenArgs'");
return {};
}
auto maybe___handleFetchEventEnd = IPC::ReadParam<::mozilla::TimeStamp>(aReader);
if (!maybe___handleFetchEventEnd) {
aReader->FatalError("Error deserializing 'handleFetchEventEnd' (TimeStamp) member of 'HttpChannelOpenArgs'");
return {};
}
auto& _handleFetchEventEnd = *maybe___handleFetchEventEnd;
// Sentinel = 'handleFetchEventEnd'
if ((!((aReader)->ReadSentinel(1251346288)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'handleFetchEventEnd' (TimeStamp) member of 'HttpChannelOpenArgs'");
return {};
}
auto maybe___navigationStartTimeStamp = IPC::ReadParam<::mozilla::TimeStamp>(aReader);
if (!maybe___navigationStartTimeStamp) {
aReader->FatalError("Error deserializing 'navigationStartTimeStamp' (TimeStamp) member of 'HttpChannelOpenArgs'");
return {};
}
auto& _navigationStartTimeStamp = *maybe___navigationStartTimeStamp;
// Sentinel = 'navigationStartTimeStamp'
if ((!((aReader)->ReadSentinel(2071661011)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'navigationStartTimeStamp' (TimeStamp) member of 'HttpChannelOpenArgs'");
return {};
}
auto maybe___requestMethod = IPC::ReadParam<::nsCString>(aReader);
if (!maybe___requestMethod) {
aReader->FatalError("Error deserializing 'requestMethod' (nsCString) member of 'HttpChannelOpenArgs'");
return {};
}
auto& _requestMethod = *maybe___requestMethod;
// Sentinel = 'requestMethod'
if ((!((aReader)->ReadSentinel(643958123)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'requestMethod' (nsCString) member of 'HttpChannelOpenArgs'");
return {};
}
auto maybe___classOfService = IPC::ReadParam<::mozilla::net::ClassOfService>(aReader);
if (!maybe___classOfService) {
aReader->FatalError("Error deserializing 'classOfService' (ClassOfService) member of 'HttpChannelOpenArgs'");
return {};
}
auto& _classOfService = *maybe___classOfService;
// Sentinel = 'classOfService'
if ((!((aReader)->ReadSentinel(704710045)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'classOfService' (ClassOfService) member of 'HttpChannelOpenArgs'");
return {};
}
auto maybe___entityID = IPC::ReadParam<::nsCString>(aReader);
if (!maybe___entityID) {
aReader->FatalError("Error deserializing 'entityID' (nsCString) member of 'HttpChannelOpenArgs'");
return {};
}
auto& _entityID = *maybe___entityID;
// Sentinel = 'entityID'
if ((!((aReader)->ReadSentinel(252183339)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'entityID' (nsCString) member of 'HttpChannelOpenArgs'");
return {};
}
auto maybe___appCacheClientID = IPC::ReadParam<::nsCString>(aReader);
if (!maybe___appCacheClientID) {
aReader->FatalError("Error deserializing 'appCacheClientID' (nsCString) member of 'HttpChannelOpenArgs'");
return {};
}
auto& _appCacheClientID = *maybe___appCacheClientID;
// Sentinel = 'appCacheClientID'
if ((!((aReader)->ReadSentinel(872809986)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'appCacheClientID' (nsCString) member of 'HttpChannelOpenArgs'");
return {};
}
auto maybe___preflightArgs = IPC::ReadParam<mozilla::Maybe<::mozilla::net::CorsPreflightArgs>>(aReader);
if (!maybe___preflightArgs) {
aReader->FatalError("Error deserializing 'preflightArgs' (CorsPreflightArgs?) member of 'HttpChannelOpenArgs'");
return {};
}
auto& _preflightArgs = *maybe___preflightArgs;
// Sentinel = 'preflightArgs'
if ((!((aReader)->ReadSentinel(630981971)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'preflightArgs' (CorsPreflightArgs?) member of 'HttpChannelOpenArgs'");
return {};
}
auto maybe___contentTypeHint = IPC::ReadParam<::nsCString>(aReader);
if (!maybe___contentTypeHint) {
aReader->FatalError("Error deserializing 'contentTypeHint' (nsCString) member of 'HttpChannelOpenArgs'");
return {};
}
auto& _contentTypeHint = *maybe___contentTypeHint;
// Sentinel = 'contentTypeHint'
if ((!((aReader)->ReadSentinel(836634161)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'contentTypeHint' (nsCString) member of 'HttpChannelOpenArgs'");
return {};
}
auto maybe___integrityMetadata = IPC::ReadParam<::nsString>(aReader);
if (!maybe___integrityMetadata) {
aReader->FatalError("Error deserializing 'integrityMetadata' (nsString) member of 'HttpChannelOpenArgs'");
return {};
}
auto& _integrityMetadata = *maybe___integrityMetadata;
// Sentinel = 'integrityMetadata'
if ((!((aReader)->ReadSentinel(1071580929)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'integrityMetadata' (nsString) member of 'HttpChannelOpenArgs'");
return {};
}
auto maybe___uploadStream = IPC::ReadParam<mozilla::Maybe<::mozilla::ipc::IPCStream>>(aReader);
if (!maybe___uploadStream) {
aReader->FatalError("Error deserializing 'uploadStream' (IPCStream?) member of 'HttpChannelOpenArgs'");
return {};
}
auto& _uploadStream = *maybe___uploadStream;
// Sentinel = 'uploadStream'
if ((!((aReader)->ReadSentinel(546768114)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uploadStream' (IPCStream?) member of 'HttpChannelOpenArgs'");
return {};
}
auto maybe___loadInfo = IPC::ReadParam<::mozilla::net::LoadInfoArgs>(aReader);
if (!maybe___loadInfo) {
aReader->FatalError("Error deserializing 'loadInfo' (LoadInfoArgs) member of 'HttpChannelOpenArgs'");
return {};
}
auto& _loadInfo = *maybe___loadInfo;
// Sentinel = 'loadInfo'
if ((!((aReader)->ReadSentinel(240386861)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'loadInfo' (LoadInfoArgs) member of 'HttpChannelOpenArgs'");
return {};
}
auto maybe___uploadStreamHasHeaders = IPC::ReadParam<bool>(aReader);
if (!maybe___uploadStreamHasHeaders) {
aReader->FatalError("Error deserializing 'uploadStreamHasHeaders' (bool) member of 'HttpChannelOpenArgs'");
return {};
}
auto& _uploadStreamHasHeaders = *maybe___uploadStreamHasHeaders;
// Sentinel = 'uploadStreamHasHeaders'
if ((!((aReader)->ReadSentinel(1714227402)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uploadStreamHasHeaders' (bool) member of 'HttpChannelOpenArgs'");
return {};
}
auto maybe___allowSTS = IPC::ReadParam<bool>(aReader);
if (!maybe___allowSTS) {
aReader->FatalError("Error deserializing 'allowSTS' (bool) member of 'HttpChannelOpenArgs'");
return {};
}
auto& _allowSTS = *maybe___allowSTS;
// Sentinel = 'allowSTS'
if ((!((aReader)->ReadSentinel(243729178)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'allowSTS' (bool) member of 'HttpChannelOpenArgs'");
return {};
}
auto maybe___resumeAt = IPC::ReadParam<bool>(aReader);
if (!maybe___resumeAt) {
aReader->FatalError("Error deserializing 'resumeAt' (bool) member of 'HttpChannelOpenArgs'");
return {};
}
auto& _resumeAt = *maybe___resumeAt;
// Sentinel = 'resumeAt'
if ((!((aReader)->ReadSentinel(254739271)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'resumeAt' (bool) member of 'HttpChannelOpenArgs'");
return {};
}
auto maybe___allowSpdy = IPC::ReadParam<bool>(aReader);
if (!maybe___allowSpdy) {
aReader->FatalError("Error deserializing 'allowSpdy' (bool) member of 'HttpChannelOpenArgs'");
return {};
}
auto& _allowSpdy = *maybe___allowSpdy;
// Sentinel = 'allowSpdy'
if ((!((aReader)->ReadSentinel(311428032)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'allowSpdy' (bool) member of 'HttpChannelOpenArgs'");
return {};
}
auto maybe___allowHttp3 = IPC::ReadParam<bool>(aReader);
if (!maybe___allowHttp3) {
aReader->FatalError("Error deserializing 'allowHttp3' (bool) member of 'HttpChannelOpenArgs'");
return {};
}
auto& _allowHttp3 = *maybe___allowHttp3;
// Sentinel = 'allowHttp3'
if ((!((aReader)->ReadSentinel(377095155)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'allowHttp3' (bool) member of 'HttpChannelOpenArgs'");
return {};
}
auto maybe___allowAltSvc = IPC::ReadParam<bool>(aReader);
if (!maybe___allowAltSvc) {
aReader->FatalError("Error deserializing 'allowAltSvc' (bool) member of 'HttpChannelOpenArgs'");
return {};
}
auto& _allowAltSvc = *maybe___allowAltSvc;
// Sentinel = 'allowAltSvc'
if ((!((aReader)->ReadSentinel(447546477)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'allowAltSvc' (bool) member of 'HttpChannelOpenArgs'");
return {};
}
auto maybe___beConservative = IPC::ReadParam<bool>(aReader);
if (!maybe___beConservative) {
aReader->FatalError("Error deserializing 'beConservative' (bool) member of 'HttpChannelOpenArgs'");
return {};
}
auto& _beConservative = *maybe___beConservative;
// Sentinel = 'beConservative'
if ((!((aReader)->ReadSentinel(706086337)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'beConservative' (bool) member of 'HttpChannelOpenArgs'");
return {};
}
auto maybe___bypassProxy = IPC::ReadParam<bool>(aReader);
if (!maybe___bypassProxy) {
aReader->FatalError("Error deserializing 'bypassProxy' (bool) member of 'HttpChannelOpenArgs'");
return {};
}
auto& _bypassProxy = *maybe___bypassProxy;
// Sentinel = 'bypassProxy'
if ((!((aReader)->ReadSentinel(467141813)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bypassProxy' (bool) member of 'HttpChannelOpenArgs'");
return {};
}
auto maybe___blockAuthPrompt = IPC::ReadParam<bool>(aReader);
if (!maybe___blockAuthPrompt) {
aReader->FatalError("Error deserializing 'blockAuthPrompt' (bool) member of 'HttpChannelOpenArgs'");
return {};
}
auto& _blockAuthPrompt = *maybe___blockAuthPrompt;
// Sentinel = 'blockAuthPrompt'
if ((!((aReader)->ReadSentinel(807732768)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'blockAuthPrompt' (bool) member of 'HttpChannelOpenArgs'");
return {};
}
auto maybe___allowStaleCacheContent = IPC::ReadParam<bool>(aReader);
if (!maybe___allowStaleCacheContent) {
aReader->FatalError("Error deserializing 'allowStaleCacheContent' (bool) member of 'HttpChannelOpenArgs'");
return {};
}
auto& _allowStaleCacheContent = *maybe___allowStaleCacheContent;
// Sentinel = 'allowStaleCacheContent'
if ((!((aReader)->ReadSentinel(1689192648)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'allowStaleCacheContent' (bool) member of 'HttpChannelOpenArgs'");
return {};
}
auto maybe___requestMode = IPC::ReadParam<::mozilla::dom::RequestMode>(aReader);
if (!maybe___requestMode) {
aReader->FatalError("Error deserializing 'requestMode' (RequestMode) member of 'HttpChannelOpenArgs'");
return {};
}
auto& _requestMode = *maybe___requestMode;
// Sentinel = 'requestMode'
if ((!((aReader)->ReadSentinel(468386959)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'requestMode' (RequestMode) member of 'HttpChannelOpenArgs'");
return {};
}
auto maybe___forceValidateCacheContent = IPC::ReadParam<bool>(aReader);
if (!maybe___forceValidateCacheContent) {
aReader->FatalError("Error deserializing 'forceValidateCacheContent' (bool) member of 'HttpChannelOpenArgs'");
return {};
}
auto& _forceValidateCacheContent = *maybe___forceValidateCacheContent;
// Sentinel = 'forceValidateCacheContent'
if ((!((aReader)->ReadSentinel(2152008169)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'forceValidateCacheContent' (bool) member of 'HttpChannelOpenArgs'");
return {};
}
auto maybe___preferCacheLoadOverBypass = IPC::ReadParam<bool>(aReader);
if (!maybe___preferCacheLoadOverBypass) {
aReader->FatalError("Error deserializing 'preferCacheLoadOverBypass' (bool) member of 'HttpChannelOpenArgs'");
return {};
}
auto& _preferCacheLoadOverBypass = *maybe___preferCacheLoadOverBypass;
// Sentinel = 'preferCacheLoadOverBypass'
if ((!((aReader)->ReadSentinel(2144602599)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'preferCacheLoadOverBypass' (bool) member of 'HttpChannelOpenArgs'");
return {};
}
auto maybe___forceMainDocumentChannel = IPC::ReadParam<bool>(aReader);
if (!maybe___forceMainDocumentChannel) {
aReader->FatalError("Error deserializing 'forceMainDocumentChannel' (bool) member of 'HttpChannelOpenArgs'");
return {};
}
auto& _forceMainDocumentChannel = *maybe___forceMainDocumentChannel;
// Sentinel = 'forceMainDocumentChannel'
if ((!((aReader)->ReadSentinel(1994656141)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'forceMainDocumentChannel' (bool) member of 'HttpChannelOpenArgs'");
return {};
}
auto maybe___classicScriptHintCharset = IPC::ReadParam<::nsString>(aReader);
if (!maybe___classicScriptHintCharset) {
aReader->FatalError("Error deserializing 'classicScriptHintCharset' (nsString) member of 'HttpChannelOpenArgs'");
return {};
}
auto& _classicScriptHintCharset = *maybe___classicScriptHintCharset;
// Sentinel = 'classicScriptHintCharset'
if ((!((aReader)->ReadSentinel(2030963125)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'classicScriptHintCharset' (nsString) member of 'HttpChannelOpenArgs'");
return {};
}
auto maybe___documentCharacterSet = IPC::ReadParam<::nsString>(aReader);
if (!maybe___documentCharacterSet) {
aReader->FatalError("Error deserializing 'documentCharacterSet' (nsString) member of 'HttpChannelOpenArgs'");
return {};
}
auto& _documentCharacterSet = *maybe___documentCharacterSet;
// Sentinel = 'documentCharacterSet'
if ((!((aReader)->ReadSentinel(1431570457)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'documentCharacterSet' (nsString) member of 'HttpChannelOpenArgs'");
return {};
}
auto maybe___isUserAgentHeaderModified = IPC::ReadParam<bool>(aReader);
if (!maybe___isUserAgentHeaderModified) {
aReader->FatalError("Error deserializing 'isUserAgentHeaderModified' (bool) member of 'HttpChannelOpenArgs'");
return {};
}
auto& _isUserAgentHeaderModified = *maybe___isUserAgentHeaderModified;
// Sentinel = 'isUserAgentHeaderModified'
if ((!((aReader)->ReadSentinel(2147355093)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'isUserAgentHeaderModified' (bool) member of 'HttpChannelOpenArgs'");
return {};
}
auto maybe___initiatorType = IPC::ReadParam<::nsString>(aReader);
if (!maybe___initiatorType) {
aReader->FatalError("Error deserializing 'initiatorType' (nsString) member of 'HttpChannelOpenArgs'");
return {};
}
auto& _initiatorType = *maybe___initiatorType;
// Sentinel = 'initiatorType'
if ((!((aReader)->ReadSentinel(642647414)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'initiatorType' (nsString) member of 'HttpChannelOpenArgs'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_uri),
std::move(_original),
std::move(_doc),
std::move(_referrerInfo),
std::move(_apiRedirectTo),
std::move(_topWindowURI),
std::move(_requestHeaders),
std::move(_preferredAlternativeTypes),
std::move(_launchServiceWorkerStart),
std::move(_launchServiceWorkerEnd),
std::move(_dispatchFetchEventStart),
std::move(_dispatchFetchEventEnd),
std::move(_handleFetchEventStart),
std::move(_handleFetchEventEnd),
std::move(_navigationStartTimeStamp),
::uint64_t{0},
::uint64_t{0},
::uint64_t{0},
::uint64_t{0},
::uint64_t{0},
::uint64_t{0},
std::move(_requestMethod),
std::move(_classOfService),
std::move(_entityID),
std::move(_appCacheClientID),
std::move(_preflightArgs),
std::move(_contentTypeHint),
std::move(_integrityMetadata),
std::move(_uploadStream),
std::move(_loadInfo),
::uint32_t{0},
::uint32_t{0},
::uint32_t{0},
::uint32_t{0},
::uint32_t{0},
::uint32_t{0},
::int16_t{0},
std::move(_uploadStreamHasHeaders),
std::move(_allowSTS),
std::move(_resumeAt),
std::move(_allowSpdy),
std::move(_allowHttp3),
std::move(_allowAltSvc),
std::move(_beConservative),
std::move(_bypassProxy),
std::move(_blockAuthPrompt),
std::move(_allowStaleCacheContent),
std::move(_requestMode),
std::move(_forceValidateCacheContent),
std::move(_preferCacheLoadOverBypass),
std::move(_forceMainDocumentChannel),
::uint8_t{0},
std::move(_classicScriptHintCharset),
std::move(_documentCharacterSet),
std::move(_isUserAgentHeaderModified),
std::move(_initiatorType)};
if ((!((aReader)->ReadBytesInto((&((result__)->startPos())), 48)))) {
aReader->FatalError("Error bulk reading fields from uint64_t");
return {};
}
// Sentinel = 'startPos | requestContextID | channelId | contentWindowId | browserId | earlyHintPreloaderId'
if ((!((aReader)->ReadSentinel(1451041498)))) {
mozilla::ipc::SentinelReadError("Error bulk reading fields from uint64_t");
return {};
}
if ((!((aReader)->ReadBytesInto((&((result__)->loadFlags())), 24)))) {
aReader->FatalError("Error bulk reading fields from uint32_t");
return {};
}
// Sentinel = 'loadFlags | thirdPartyFlags | tlsFlags | cacheKey | initialRwin | redirectMode'
if ((!((aReader)->ReadSentinel(2034441488)))) {
mozilla::ipc::SentinelReadError("Error bulk reading fields from uint32_t");
return {};
}
if ((!((aReader)->ReadBytesInto((&((result__)->priority())), 2)))) {
aReader->FatalError("Error bulk reading fields from int16_t");
return {};
}
// Sentinel = 'priority'
if ((!((aReader)->ReadSentinel(262865795)))) {
mozilla::ipc::SentinelReadError("Error bulk reading fields from int16_t");
return {};
}
if ((!((aReader)->ReadBytesInto((&((result__)->redirectionLimit())), 1)))) {
aReader->FatalError("Error bulk reading fields from uint8_t");
return {};
}
// Sentinel = 'redirectionLimit'
if ((!((aReader)->ReadSentinel(941295256)))) {
mozilla::ipc::SentinelReadError("Error bulk reading fields from uint8_t");
return {};
}
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct HttpChannelConnectArgs|
//
namespace mozilla {
namespace net {
} // namespace net
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::net::HttpChannelConnectArgs>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
(aWriter)->WriteBytes((&((aVar).registrarId())), 4);
// Sentinel = 'registrarId'
(aWriter)->WriteSentinel(464585857);
}
auto ParamTraits<::mozilla::net::HttpChannelConnectArgs>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
IPC::ReadResult<paramType> result__{
std::in_place,
::uint32_t{0}};
if ((!((aReader)->ReadBytesInto((&((result__)->registrarId())), 4)))) {
aReader->FatalError("Error bulk reading fields from uint32_t");
return {};
}
// Sentinel = 'registrarId'
if ((!((aReader)->ReadSentinel(464585857)))) {
mozilla::ipc::SentinelReadError("Error bulk reading fields from uint32_t");
return {};
}
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |union HttpChannelCreationArgs|
//
namespace mozilla {
namespace net {
auto HttpChannelCreationArgs::MaybeDestroy() -> void
{
if ((mType) == (T__None)) {
return;
}
switch (mType) {
case THttpChannelOpenArgs:
{
(ptr_HttpChannelOpenArgs())->~HttpChannelOpenArgs__tdef();
break;
}
case THttpChannelConnectArgs:
{
(ptr_HttpChannelConnectArgs())->~HttpChannelConnectArgs__tdef();
break;
}
default:
{
mozilla::ipc::LogicError("not reached");
break;
}
}
}
MOZ_IMPLICIT HttpChannelCreationArgs::HttpChannelCreationArgs(const HttpChannelOpenArgs& aOther)
{
new (mozilla::KnownNotNull, ptr_HttpChannelOpenArgs()) HttpChannelOpenArgs(aOther);
mType = THttpChannelOpenArgs;
}
MOZ_IMPLICIT HttpChannelCreationArgs::HttpChannelCreationArgs(HttpChannelOpenArgs&& aOther)
{
new (mozilla::KnownNotNull, ptr_HttpChannelOpenArgs()) HttpChannelOpenArgs(std::move(aOther));
mType = THttpChannelOpenArgs;
}
MOZ_IMPLICIT HttpChannelCreationArgs::HttpChannelCreationArgs(const HttpChannelConnectArgs& aOther)
{
new (mozilla::KnownNotNull, ptr_HttpChannelConnectArgs()) HttpChannelConnectArgs(aOther);
mType = THttpChannelConnectArgs;
}
MOZ_IMPLICIT HttpChannelCreationArgs::HttpChannelCreationArgs(HttpChannelConnectArgs&& aOther)
{
new (mozilla::KnownNotNull, ptr_HttpChannelConnectArgs()) HttpChannelConnectArgs(std::move(aOther));
mType = THttpChannelConnectArgs;
}
MOZ_IMPLICIT HttpChannelCreationArgs::HttpChannelCreationArgs(const HttpChannelCreationArgs& aOther)
{
(aOther).AssertSanity();
switch ((aOther).type()) {
case THttpChannelOpenArgs:
{
new (mozilla::KnownNotNull, ptr_HttpChannelOpenArgs()) HttpChannelOpenArgs((aOther).get_HttpChannelOpenArgs());
break;
}
case THttpChannelConnectArgs:
{
new (mozilla::KnownNotNull, ptr_HttpChannelConnectArgs()) HttpChannelConnectArgs((aOther).get_HttpChannelConnectArgs());
break;
}
case T__None:
{
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
return;
}
}
mType = (aOther).type();
}
MOZ_IMPLICIT HttpChannelCreationArgs::HttpChannelCreationArgs(HttpChannelCreationArgs&& aOther)
{
(aOther).AssertSanity();
Type t = (aOther).type();
switch (t) {
case THttpChannelOpenArgs:
{
new (mozilla::KnownNotNull, ptr_HttpChannelOpenArgs()) HttpChannelOpenArgs(std::move((aOther).get_HttpChannelOpenArgs()));
(aOther).MaybeDestroy();
break;
}
case THttpChannelConnectArgs:
{
new (mozilla::KnownNotNull, ptr_HttpChannelConnectArgs()) HttpChannelConnectArgs(std::move((aOther).get_HttpChannelConnectArgs()));
(aOther).MaybeDestroy();
break;
}
case T__None:
{
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
return;
}
}
(aOther).mType = T__None;
mType = t;
}
HttpChannelCreationArgs::~HttpChannelCreationArgs()
{
MaybeDestroy();
}
auto HttpChannelCreationArgs::operator=(const HttpChannelOpenArgs& aRhs) -> HttpChannelCreationArgs&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_HttpChannelOpenArgs()) HttpChannelOpenArgs(aRhs);
mType = THttpChannelOpenArgs;
return (*(this));
}
auto HttpChannelCreationArgs::operator=(HttpChannelOpenArgs&& aRhs) -> HttpChannelCreationArgs&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_HttpChannelOpenArgs()) HttpChannelOpenArgs(std::move(aRhs));
mType = THttpChannelOpenArgs;
return (*(this));
}
auto HttpChannelCreationArgs::operator=(const HttpChannelConnectArgs& aRhs) -> HttpChannelCreationArgs&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_HttpChannelConnectArgs()) HttpChannelConnectArgs(aRhs);
mType = THttpChannelConnectArgs;
return (*(this));
}
auto HttpChannelCreationArgs::operator=(HttpChannelConnectArgs&& aRhs) -> HttpChannelCreationArgs&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_HttpChannelConnectArgs()) HttpChannelConnectArgs(std::move(aRhs));
mType = THttpChannelConnectArgs;
return (*(this));
}
auto HttpChannelCreationArgs::operator=(const HttpChannelCreationArgs& aRhs) -> HttpChannelCreationArgs&
{
(aRhs).AssertSanity();
Type t = (aRhs).type();
switch (t) {
case THttpChannelOpenArgs:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_HttpChannelOpenArgs()) HttpChannelOpenArgs((aRhs).get_HttpChannelOpenArgs());
break;
}
case THttpChannelConnectArgs:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_HttpChannelConnectArgs()) HttpChannelConnectArgs((aRhs).get_HttpChannelConnectArgs());
break;
}
case T__None:
{
MaybeDestroy();
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
break;
}
}
mType = t;
return (*(this));
}
auto HttpChannelCreationArgs::operator=(HttpChannelCreationArgs&& aRhs) -> HttpChannelCreationArgs&
{
(aRhs).AssertSanity();
Type t = (aRhs).type();
switch (t) {
case THttpChannelOpenArgs:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_HttpChannelOpenArgs()) HttpChannelOpenArgs(std::move((aRhs).get_HttpChannelOpenArgs()));
(aRhs).MaybeDestroy();
break;
}
case THttpChannelConnectArgs:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_HttpChannelConnectArgs()) HttpChannelConnectArgs(std::move((aRhs).get_HttpChannelConnectArgs()));
(aRhs).MaybeDestroy();
break;
}
case T__None:
{
MaybeDestroy();
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
break;
}
}
(aRhs).mType = T__None;
mType = t;
return (*(this));
}
} // namespace net
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::net::HttpChannelCreationArgs>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
typedef ::mozilla::net::HttpChannelCreationArgs union__;
int type = (aVar).type();
IPC::WriteParam(aWriter, type);
// Sentinel = 'HttpChannelCreationArgs'
(aWriter)->WriteSentinel(1813514524);
switch (type) {
case union__::THttpChannelOpenArgs:
{
IPC::WriteParam(aWriter, (aVar).get_HttpChannelOpenArgs());
// Sentinel = 'THttpChannelOpenArgs'
(aWriter)->WriteSentinel(1353254861);
return;
}
case union__::THttpChannelConnectArgs:
{
IPC::WriteParam(aWriter, (aVar).get_HttpChannelConnectArgs());
// Sentinel = 'THttpChannelConnectArgs'
(aWriter)->WriteSentinel(1787103493);
return;
}
default:
{
aWriter->FatalError("unknown variant of union HttpChannelCreationArgs");
return;
}
}
}
auto ParamTraits<::mozilla::net::HttpChannelCreationArgs>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
typedef ::mozilla::net::HttpChannelCreationArgs union__;
auto maybe__type = IPC::ReadParam<int>(aReader);
if (!maybe__type) {
aReader->FatalError("Error deserializing type of union HttpChannelCreationArgs");
return {};
}
auto& type = *maybe__type;
// Sentinel = 'HttpChannelCreationArgs'
if ((!((aReader)->ReadSentinel(1813514524)))) {
mozilla::ipc::SentinelReadError("Error deserializing type of union HttpChannelCreationArgs");
return {};
}
switch (type) {
case union__::THttpChannelOpenArgs:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::net::HttpChannelOpenArgs>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant THttpChannelOpenArgs of union HttpChannelCreationArgs");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'THttpChannelOpenArgs'
if ((!((aReader)->ReadSentinel(1353254861)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant THttpChannelOpenArgs of union HttpChannelCreationArgs");
return {};
}
return std::move(tmp);
}
case union__::THttpChannelConnectArgs:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::net::HttpChannelConnectArgs>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant THttpChannelConnectArgs of union HttpChannelCreationArgs");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'THttpChannelConnectArgs'
if ((!((aReader)->ReadSentinel(1787103493)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant THttpChannelConnectArgs of union HttpChannelCreationArgs");
return {};
}
return std::move(tmp);
}
default:
{
aReader->FatalError("unknown variant of union HttpChannelCreationArgs");
return {};
}
}
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct ProxyInfoCloneArgs|
//
namespace mozilla {
namespace net {
auto ProxyInfoCloneArgs::StaticAssertions() const -> void
{
static_assert(
(offsetof(ProxyInfoCloneArgs, resolveFlags_) - offsetof(ProxyInfoCloneArgs, port_)) == 12,
"Bad assumptions about field layout!");
}
} // namespace net
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::net::ProxyInfoCloneArgs>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).type());
// Sentinel = 'type'
(aWriter)->WriteSentinel(75760067);
IPC::WriteParam(aWriter, (aVar).host());
// Sentinel = 'host'
(aWriter)->WriteSentinel(72024511);
IPC::WriteParam(aWriter, (aVar).username());
// Sentinel = 'username'
(aWriter)->WriteSentinel(260506465);
IPC::WriteParam(aWriter, (aVar).password());
// Sentinel = 'password'
(aWriter)->WriteSentinel(261161844);
IPC::WriteParam(aWriter, (aVar).proxyAuthorizationHeader());
// Sentinel = 'proxyAuthorizationHeader'
(aWriter)->WriteSentinel(2133461501);
IPC::WriteParam(aWriter, (aVar).connectionIsolationKey());
// Sentinel = 'connectionIsolationKey'
(aWriter)->WriteSentinel(1751189772);
(aWriter)->WriteBytes((&((aVar).port())), 16);
// Sentinel = 'port | flags | timeout | resolveFlags'
(aWriter)->WriteSentinel(94768635);
}
auto ParamTraits<::mozilla::net::ProxyInfoCloneArgs>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___type = IPC::ReadParam<::nsCString>(aReader);
if (!maybe___type) {
aReader->FatalError("Error deserializing 'type' (nsCString) member of 'ProxyInfoCloneArgs'");
return {};
}
auto& _type = *maybe___type;
// Sentinel = 'type'
if ((!((aReader)->ReadSentinel(75760067)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'type' (nsCString) member of 'ProxyInfoCloneArgs'");
return {};
}
auto maybe___host = IPC::ReadParam<::nsCString>(aReader);
if (!maybe___host) {
aReader->FatalError("Error deserializing 'host' (nsCString) member of 'ProxyInfoCloneArgs'");
return {};
}
auto& _host = *maybe___host;
// Sentinel = 'host'
if ((!((aReader)->ReadSentinel(72024511)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'host' (nsCString) member of 'ProxyInfoCloneArgs'");
return {};
}
auto maybe___username = IPC::ReadParam<::nsCString>(aReader);
if (!maybe___username) {
aReader->FatalError("Error deserializing 'username' (nsCString) member of 'ProxyInfoCloneArgs'");
return {};
}
auto& _username = *maybe___username;
// Sentinel = 'username'
if ((!((aReader)->ReadSentinel(260506465)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'username' (nsCString) member of 'ProxyInfoCloneArgs'");
return {};
}
auto maybe___password = IPC::ReadParam<::nsCString>(aReader);
if (!maybe___password) {
aReader->FatalError("Error deserializing 'password' (nsCString) member of 'ProxyInfoCloneArgs'");
return {};
}
auto& _password = *maybe___password;
// Sentinel = 'password'
if ((!((aReader)->ReadSentinel(261161844)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'password' (nsCString) member of 'ProxyInfoCloneArgs'");
return {};
}
auto maybe___proxyAuthorizationHeader = IPC::ReadParam<::nsCString>(aReader);
if (!maybe___proxyAuthorizationHeader) {
aReader->FatalError("Error deserializing 'proxyAuthorizationHeader' (nsCString) member of 'ProxyInfoCloneArgs'");
return {};
}
auto& _proxyAuthorizationHeader = *maybe___proxyAuthorizationHeader;
// Sentinel = 'proxyAuthorizationHeader'
if ((!((aReader)->ReadSentinel(2133461501)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'proxyAuthorizationHeader' (nsCString) member of 'ProxyInfoCloneArgs'");
return {};
}
auto maybe___connectionIsolationKey = IPC::ReadParam<::nsCString>(aReader);
if (!maybe___connectionIsolationKey) {
aReader->FatalError("Error deserializing 'connectionIsolationKey' (nsCString) member of 'ProxyInfoCloneArgs'");
return {};
}
auto& _connectionIsolationKey = *maybe___connectionIsolationKey;
// Sentinel = 'connectionIsolationKey'
if ((!((aReader)->ReadSentinel(1751189772)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'connectionIsolationKey' (nsCString) member of 'ProxyInfoCloneArgs'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_type),
std::move(_host),
::int32_t{0},
std::move(_username),
std::move(_password),
::uint32_t{0},
::uint32_t{0},
::uint32_t{0},
std::move(_proxyAuthorizationHeader),
std::move(_connectionIsolationKey)};
if ((!((aReader)->ReadBytesInto((&((result__)->port())), 16)))) {
aReader->FatalError("Error bulk reading fields from int32_t");
return {};
}
// Sentinel = 'port | flags | timeout | resolveFlags'
if ((!((aReader)->ReadSentinel(94768635)))) {
mozilla::ipc::SentinelReadError("Error bulk reading fields from int32_t");
return {};
}
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct HttpConnectionInfoCloneArgs|
//
namespace mozilla {
namespace net {
auto HttpConnectionInfoCloneArgs::StaticAssertions() const -> void
{
static_assert(
(offsetof(HttpConnectionInfoCloneArgs, tlsFlags_) - offsetof(HttpConnectionInfoCloneArgs, port_)) == 8,
"Bad assumptions about field layout!");
}
} // namespace net
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::net::HttpConnectionInfoCloneArgs>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).host());
// Sentinel = 'host'
(aWriter)->WriteSentinel(72024511);
IPC::WriteParam(aWriter, (aVar).npnToken());
// Sentinel = 'npnToken'
(aWriter)->WriteSentinel(250938190);
IPC::WriteParam(aWriter, (aVar).username());
// Sentinel = 'username'
(aWriter)->WriteSentinel(260506465);
IPC::WriteParam(aWriter, (aVar).originAttributes());
// Sentinel = 'originAttributes'
(aWriter)->WriteSentinel(947259056);
IPC::WriteParam(aWriter, (aVar).endToEndSSL());
// Sentinel = 'endToEndSSL'
(aWriter)->WriteSentinel(421135364);
IPC::WriteParam(aWriter, (aVar).routedHost());
// Sentinel = 'routedHost'
(aWriter)->WriteSentinel(391250994);
IPC::WriteParam(aWriter, (aVar).anonymous());
// Sentinel = 'anonymous'
(aWriter)->WriteSentinel(322569194);
IPC::WriteParam(aWriter, (aVar).aPrivate());
// Sentinel = 'aPrivate'
(aWriter)->WriteSentinel(239141693);
IPC::WriteParam(aWriter, (aVar).insecureScheme());
// Sentinel = 'insecureScheme'
(aWriter)->WriteSentinel(727319988);
IPC::WriteParam(aWriter, (aVar).noSpdy());
// Sentinel = 'noSpdy'
(aWriter)->WriteSentinel(144835198);
IPC::WriteParam(aWriter, (aVar).beConservative());
// Sentinel = 'beConservative'
(aWriter)->WriteSentinel(706086337);
IPC::WriteParam(aWriter, (aVar).bypassProxy());
// Sentinel = 'bypassProxy'
(aWriter)->WriteSentinel(467141813);
IPC::WriteParam(aWriter, (aVar).anonymousAllowClientCert());
// Sentinel = 'anonymousAllowClientCert'
(aWriter)->WriteSentinel(2085882326);
IPC::WriteParam(aWriter, (aVar).fallbackConnection());
// Sentinel = 'fallbackConnection'
(aWriter)->WriteSentinel(1139017537);
IPC::WriteParam(aWriter, (aVar).isolated());
// Sentinel = 'isolated'
(aWriter)->WriteSentinel(255394646);
IPC::WriteParam(aWriter, (aVar).isTrrServiceChannel());
// Sentinel = 'isTrrServiceChannel'
(aWriter)->WriteSentinel(1284114335);
IPC::WriteParam(aWriter, (aVar).isIPv4Disabled());
// Sentinel = 'isIPv4Disabled'
(aWriter)->WriteSentinel(645858616);
IPC::WriteParam(aWriter, (aVar).isIPv6Disabled());
// Sentinel = 'isIPv6Disabled'
(aWriter)->WriteSentinel(647038266);
IPC::WriteParam(aWriter, (aVar).topWindowOrigin());
// Sentinel = 'topWindowOrigin'
(aWriter)->WriteSentinel(837420596);
IPC::WriteParam(aWriter, (aVar).isHttp3());
// Sentinel = 'isHttp3'
(aWriter)->WriteSentinel(188678832);
IPC::WriteParam(aWriter, (aVar).webTransport());
// Sentinel = 'webTransport'
(aWriter)->WriteSentinel(539886860);
IPC::WriteParam(aWriter, (aVar).hasIPHintAddress());
// Sentinel = 'hasIPHintAddress'
(aWriter)->WriteSentinel(856753711);
IPC::WriteParam(aWriter, (aVar).echConfig());
// Sentinel = 'echConfig'
(aWriter)->WriteSentinel(291898247);
IPC::WriteParam(aWriter, (aVar).proxyInfo());
// Sentinel = 'proxyInfo'
(aWriter)->WriteSentinel(325583823);
(aWriter)->WriteBytes((&((aVar).webTransportId())), 8);
// Sentinel = 'webTransportId'
(aWriter)->WriteSentinel(725353913);
(aWriter)->WriteBytes((&((aVar).port())), 12);
// Sentinel = 'port | routedPort | tlsFlags'
(aWriter)->WriteSentinel(2612726454);
(aWriter)->WriteBytes((&((aVar).trrMode())), 1);
// Sentinel = 'trrMode'
(aWriter)->WriteSentinel(197591774);
}
auto ParamTraits<::mozilla::net::HttpConnectionInfoCloneArgs>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___host = IPC::ReadParam<::nsCString>(aReader);
if (!maybe___host) {
aReader->FatalError("Error deserializing 'host' (nsCString) member of 'HttpConnectionInfoCloneArgs'");
return {};
}
auto& _host = *maybe___host;
// Sentinel = 'host'
if ((!((aReader)->ReadSentinel(72024511)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'host' (nsCString) member of 'HttpConnectionInfoCloneArgs'");
return {};
}
auto maybe___npnToken = IPC::ReadParam<::nsCString>(aReader);
if (!maybe___npnToken) {
aReader->FatalError("Error deserializing 'npnToken' (nsCString) member of 'HttpConnectionInfoCloneArgs'");
return {};
}
auto& _npnToken = *maybe___npnToken;
// Sentinel = 'npnToken'
if ((!((aReader)->ReadSentinel(250938190)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'npnToken' (nsCString) member of 'HttpConnectionInfoCloneArgs'");
return {};
}
auto maybe___username = IPC::ReadParam<::nsCString>(aReader);
if (!maybe___username) {
aReader->FatalError("Error deserializing 'username' (nsCString) member of 'HttpConnectionInfoCloneArgs'");
return {};
}
auto& _username = *maybe___username;
// Sentinel = 'username'
if ((!((aReader)->ReadSentinel(260506465)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'username' (nsCString) member of 'HttpConnectionInfoCloneArgs'");
return {};
}
auto maybe___originAttributes = IPC::ReadParam<::mozilla::OriginAttributes>(aReader);
if (!maybe___originAttributes) {
aReader->FatalError("Error deserializing 'originAttributes' (OriginAttributes) member of 'HttpConnectionInfoCloneArgs'");
return {};
}
auto& _originAttributes = *maybe___originAttributes;
// Sentinel = 'originAttributes'
if ((!((aReader)->ReadSentinel(947259056)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'originAttributes' (OriginAttributes) member of 'HttpConnectionInfoCloneArgs'");
return {};
}
auto maybe___endToEndSSL = IPC::ReadParam<bool>(aReader);
if (!maybe___endToEndSSL) {
aReader->FatalError("Error deserializing 'endToEndSSL' (bool) member of 'HttpConnectionInfoCloneArgs'");
return {};
}
auto& _endToEndSSL = *maybe___endToEndSSL;
// Sentinel = 'endToEndSSL'
if ((!((aReader)->ReadSentinel(421135364)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'endToEndSSL' (bool) member of 'HttpConnectionInfoCloneArgs'");
return {};
}
auto maybe___routedHost = IPC::ReadParam<::nsCString>(aReader);
if (!maybe___routedHost) {
aReader->FatalError("Error deserializing 'routedHost' (nsCString) member of 'HttpConnectionInfoCloneArgs'");
return {};
}
auto& _routedHost = *maybe___routedHost;
// Sentinel = 'routedHost'
if ((!((aReader)->ReadSentinel(391250994)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'routedHost' (nsCString) member of 'HttpConnectionInfoCloneArgs'");
return {};
}
auto maybe___anonymous = IPC::ReadParam<bool>(aReader);
if (!maybe___anonymous) {
aReader->FatalError("Error deserializing 'anonymous' (bool) member of 'HttpConnectionInfoCloneArgs'");
return {};
}
auto& _anonymous = *maybe___anonymous;
// Sentinel = 'anonymous'
if ((!((aReader)->ReadSentinel(322569194)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'anonymous' (bool) member of 'HttpConnectionInfoCloneArgs'");
return {};
}
auto maybe___aPrivate = IPC::ReadParam<bool>(aReader);
if (!maybe___aPrivate) {
aReader->FatalError("Error deserializing 'aPrivate' (bool) member of 'HttpConnectionInfoCloneArgs'");
return {};
}
auto& _aPrivate = *maybe___aPrivate;
// Sentinel = 'aPrivate'
if ((!((aReader)->ReadSentinel(239141693)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'aPrivate' (bool) member of 'HttpConnectionInfoCloneArgs'");
return {};
}
auto maybe___insecureScheme = IPC::ReadParam<bool>(aReader);
if (!maybe___insecureScheme) {
aReader->FatalError("Error deserializing 'insecureScheme' (bool) member of 'HttpConnectionInfoCloneArgs'");
return {};
}
auto& _insecureScheme = *maybe___insecureScheme;
// Sentinel = 'insecureScheme'
if ((!((aReader)->ReadSentinel(727319988)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'insecureScheme' (bool) member of 'HttpConnectionInfoCloneArgs'");
return {};
}
auto maybe___noSpdy = IPC::ReadParam<bool>(aReader);
if (!maybe___noSpdy) {
aReader->FatalError("Error deserializing 'noSpdy' (bool) member of 'HttpConnectionInfoCloneArgs'");
return {};
}
auto& _noSpdy = *maybe___noSpdy;
// Sentinel = 'noSpdy'
if ((!((aReader)->ReadSentinel(144835198)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'noSpdy' (bool) member of 'HttpConnectionInfoCloneArgs'");
return {};
}
auto maybe___beConservative = IPC::ReadParam<bool>(aReader);
if (!maybe___beConservative) {
aReader->FatalError("Error deserializing 'beConservative' (bool) member of 'HttpConnectionInfoCloneArgs'");
return {};
}
auto& _beConservative = *maybe___beConservative;
// Sentinel = 'beConservative'
if ((!((aReader)->ReadSentinel(706086337)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'beConservative' (bool) member of 'HttpConnectionInfoCloneArgs'");
return {};
}
auto maybe___bypassProxy = IPC::ReadParam<bool>(aReader);
if (!maybe___bypassProxy) {
aReader->FatalError("Error deserializing 'bypassProxy' (bool) member of 'HttpConnectionInfoCloneArgs'");
return {};
}
auto& _bypassProxy = *maybe___bypassProxy;
// Sentinel = 'bypassProxy'
if ((!((aReader)->ReadSentinel(467141813)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bypassProxy' (bool) member of 'HttpConnectionInfoCloneArgs'");
return {};
}
auto maybe___anonymousAllowClientCert = IPC::ReadParam<bool>(aReader);
if (!maybe___anonymousAllowClientCert) {
aReader->FatalError("Error deserializing 'anonymousAllowClientCert' (bool) member of 'HttpConnectionInfoCloneArgs'");
return {};
}
auto& _anonymousAllowClientCert = *maybe___anonymousAllowClientCert;
// Sentinel = 'anonymousAllowClientCert'
if ((!((aReader)->ReadSentinel(2085882326)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'anonymousAllowClientCert' (bool) member of 'HttpConnectionInfoCloneArgs'");
return {};
}
auto maybe___fallbackConnection = IPC::ReadParam<bool>(aReader);
if (!maybe___fallbackConnection) {
aReader->FatalError("Error deserializing 'fallbackConnection' (bool) member of 'HttpConnectionInfoCloneArgs'");
return {};
}
auto& _fallbackConnection = *maybe___fallbackConnection;
// Sentinel = 'fallbackConnection'
if ((!((aReader)->ReadSentinel(1139017537)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'fallbackConnection' (bool) member of 'HttpConnectionInfoCloneArgs'");
return {};
}
auto maybe___isolated = IPC::ReadParam<bool>(aReader);
if (!maybe___isolated) {
aReader->FatalError("Error deserializing 'isolated' (bool) member of 'HttpConnectionInfoCloneArgs'");
return {};
}
auto& _isolated = *maybe___isolated;
// Sentinel = 'isolated'
if ((!((aReader)->ReadSentinel(255394646)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'isolated' (bool) member of 'HttpConnectionInfoCloneArgs'");
return {};
}
auto maybe___isTrrServiceChannel = IPC::ReadParam<bool>(aReader);
if (!maybe___isTrrServiceChannel) {
aReader->FatalError("Error deserializing 'isTrrServiceChannel' (bool) member of 'HttpConnectionInfoCloneArgs'");
return {};
}
auto& _isTrrServiceChannel = *maybe___isTrrServiceChannel;
// Sentinel = 'isTrrServiceChannel'
if ((!((aReader)->ReadSentinel(1284114335)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'isTrrServiceChannel' (bool) member of 'HttpConnectionInfoCloneArgs'");
return {};
}
auto maybe___isIPv4Disabled = IPC::ReadParam<bool>(aReader);
if (!maybe___isIPv4Disabled) {
aReader->FatalError("Error deserializing 'isIPv4Disabled' (bool) member of 'HttpConnectionInfoCloneArgs'");
return {};
}
auto& _isIPv4Disabled = *maybe___isIPv4Disabled;
// Sentinel = 'isIPv4Disabled'
if ((!((aReader)->ReadSentinel(645858616)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'isIPv4Disabled' (bool) member of 'HttpConnectionInfoCloneArgs'");
return {};
}
auto maybe___isIPv6Disabled = IPC::ReadParam<bool>(aReader);
if (!maybe___isIPv6Disabled) {
aReader->FatalError("Error deserializing 'isIPv6Disabled' (bool) member of 'HttpConnectionInfoCloneArgs'");
return {};
}
auto& _isIPv6Disabled = *maybe___isIPv6Disabled;
// Sentinel = 'isIPv6Disabled'
if ((!((aReader)->ReadSentinel(647038266)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'isIPv6Disabled' (bool) member of 'HttpConnectionInfoCloneArgs'");
return {};
}
auto maybe___topWindowOrigin = IPC::ReadParam<::nsCString>(aReader);
if (!maybe___topWindowOrigin) {
aReader->FatalError("Error deserializing 'topWindowOrigin' (nsCString) member of 'HttpConnectionInfoCloneArgs'");
return {};
}
auto& _topWindowOrigin = *maybe___topWindowOrigin;
// Sentinel = 'topWindowOrigin'
if ((!((aReader)->ReadSentinel(837420596)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'topWindowOrigin' (nsCString) member of 'HttpConnectionInfoCloneArgs'");
return {};
}
auto maybe___isHttp3 = IPC::ReadParam<bool>(aReader);
if (!maybe___isHttp3) {
aReader->FatalError("Error deserializing 'isHttp3' (bool) member of 'HttpConnectionInfoCloneArgs'");
return {};
}
auto& _isHttp3 = *maybe___isHttp3;
// Sentinel = 'isHttp3'
if ((!((aReader)->ReadSentinel(188678832)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'isHttp3' (bool) member of 'HttpConnectionInfoCloneArgs'");
return {};
}
auto maybe___webTransport = IPC::ReadParam<bool>(aReader);
if (!maybe___webTransport) {
aReader->FatalError("Error deserializing 'webTransport' (bool) member of 'HttpConnectionInfoCloneArgs'");
return {};
}
auto& _webTransport = *maybe___webTransport;
// Sentinel = 'webTransport'
if ((!((aReader)->ReadSentinel(539886860)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'webTransport' (bool) member of 'HttpConnectionInfoCloneArgs'");
return {};
}
auto maybe___hasIPHintAddress = IPC::ReadParam<bool>(aReader);
if (!maybe___hasIPHintAddress) {
aReader->FatalError("Error deserializing 'hasIPHintAddress' (bool) member of 'HttpConnectionInfoCloneArgs'");
return {};
}
auto& _hasIPHintAddress = *maybe___hasIPHintAddress;
// Sentinel = 'hasIPHintAddress'
if ((!((aReader)->ReadSentinel(856753711)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'hasIPHintAddress' (bool) member of 'HttpConnectionInfoCloneArgs'");
return {};
}
auto maybe___echConfig = IPC::ReadParam<::nsCString>(aReader);
if (!maybe___echConfig) {
aReader->FatalError("Error deserializing 'echConfig' (nsCString) member of 'HttpConnectionInfoCloneArgs'");
return {};
}
auto& _echConfig = *maybe___echConfig;
// Sentinel = 'echConfig'
if ((!((aReader)->ReadSentinel(291898247)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'echConfig' (nsCString) member of 'HttpConnectionInfoCloneArgs'");
return {};
}
auto maybe___proxyInfo = IPC::ReadParam<nsTArray<::mozilla::net::ProxyInfoCloneArgs>>(aReader);
if (!maybe___proxyInfo) {
aReader->FatalError("Error deserializing 'proxyInfo' (ProxyInfoCloneArgs[]) member of 'HttpConnectionInfoCloneArgs'");
return {};
}
auto& _proxyInfo = *maybe___proxyInfo;
// Sentinel = 'proxyInfo'
if ((!((aReader)->ReadSentinel(325583823)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'proxyInfo' (ProxyInfoCloneArgs[]) member of 'HttpConnectionInfoCloneArgs'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_host),
::int32_t{0},
std::move(_npnToken),
std::move(_username),
std::move(_originAttributes),
std::move(_endToEndSSL),
std::move(_routedHost),
::int32_t{0},
std::move(_anonymous),
std::move(_aPrivate),
std::move(_insecureScheme),
std::move(_noSpdy),
std::move(_beConservative),
std::move(_bypassProxy),
std::move(_anonymousAllowClientCert),
std::move(_fallbackConnection),
::uint32_t{0},
std::move(_isolated),
std::move(_isTrrServiceChannel),
::uint8_t{0},
std::move(_isIPv4Disabled),
std::move(_isIPv6Disabled),
std::move(_topWindowOrigin),
std::move(_isHttp3),
std::move(_webTransport),
::uint64_t{0},
std::move(_hasIPHintAddress),
std::move(_echConfig),
std::move(_proxyInfo)};
if ((!((aReader)->ReadBytesInto((&((result__)->webTransportId())), 8)))) {
aReader->FatalError("Error bulk reading fields from uint64_t");
return {};
}
// Sentinel = 'webTransportId'
if ((!((aReader)->ReadSentinel(725353913)))) {
mozilla::ipc::SentinelReadError("Error bulk reading fields from uint64_t");
return {};
}
if ((!((aReader)->ReadBytesInto((&((result__)->port())), 12)))) {
aReader->FatalError("Error bulk reading fields from int32_t");
return {};
}
// Sentinel = 'port | routedPort | tlsFlags'
if ((!((aReader)->ReadSentinel(2612726454)))) {
mozilla::ipc::SentinelReadError("Error bulk reading fields from int32_t");
return {};
}
if ((!((aReader)->ReadBytesInto((&((result__)->trrMode())), 1)))) {
aReader->FatalError("Error bulk reading fields from uint8_t");
return {};
}
// Sentinel = 'trrMode'
if ((!((aReader)->ReadSentinel(197591774)))) {
mozilla::ipc::SentinelReadError("Error bulk reading fields from uint8_t");
return {};
}
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct ConsoleReportCollected|
//
namespace mozilla {
namespace net {
auto ConsoleReportCollected::StaticAssertions() const -> void
{
static_assert(
(offsetof(ConsoleReportCollected, columnNumber_) - offsetof(ConsoleReportCollected, errorFlags_)) == 12,
"Bad assumptions about field layout!");
}
} // namespace net
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::net::ConsoleReportCollected>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).category());
// Sentinel = 'category'
(aWriter)->WriteSentinel(247333727);
IPC::WriteParam(aWriter, (aVar).sourceFileURI());
// Sentinel = 'sourceFileURI'
(aWriter)->WriteSentinel(624035074);
IPC::WriteParam(aWriter, (aVar).messageName());
// Sentinel = 'messageName'
(aWriter)->WriteSentinel(452133991);
IPC::WriteParam(aWriter, (aVar).stringParams());
// Sentinel = 'stringParams'
(aWriter)->WriteSentinel(550438140);
(aWriter)->WriteBytes((&((aVar).errorFlags())), 16);
// Sentinel = 'errorFlags | propertiesFile | lineNumber | columnNumber'
(aWriter)->WriteSentinel(1343886625);
}
auto ParamTraits<::mozilla::net::ConsoleReportCollected>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___category = IPC::ReadParam<::nsCString>(aReader);
if (!maybe___category) {
aReader->FatalError("Error deserializing 'category' (nsCString) member of 'ConsoleReportCollected'");
return {};
}
auto& _category = *maybe___category;
// Sentinel = 'category'
if ((!((aReader)->ReadSentinel(247333727)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'category' (nsCString) member of 'ConsoleReportCollected'");
return {};
}
auto maybe___sourceFileURI = IPC::ReadParam<::nsCString>(aReader);
if (!maybe___sourceFileURI) {
aReader->FatalError("Error deserializing 'sourceFileURI' (nsCString) member of 'ConsoleReportCollected'");
return {};
}
auto& _sourceFileURI = *maybe___sourceFileURI;
// Sentinel = 'sourceFileURI'
if ((!((aReader)->ReadSentinel(624035074)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'sourceFileURI' (nsCString) member of 'ConsoleReportCollected'");
return {};
}
auto maybe___messageName = IPC::ReadParam<::nsCString>(aReader);
if (!maybe___messageName) {
aReader->FatalError("Error deserializing 'messageName' (nsCString) member of 'ConsoleReportCollected'");
return {};
}
auto& _messageName = *maybe___messageName;
// Sentinel = 'messageName'
if ((!((aReader)->ReadSentinel(452133991)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'messageName' (nsCString) member of 'ConsoleReportCollected'");
return {};
}
auto maybe___stringParams = IPC::ReadParam<nsTArray<::nsString>>(aReader);
if (!maybe___stringParams) {
aReader->FatalError("Error deserializing 'stringParams' (nsString[]) member of 'ConsoleReportCollected'");
return {};
}
auto& _stringParams = *maybe___stringParams;
// Sentinel = 'stringParams'
if ((!((aReader)->ReadSentinel(550438140)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'stringParams' (nsString[]) member of 'ConsoleReportCollected'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
::uint32_t{0},
std::move(_category),
::uint32_t{0},
std::move(_sourceFileURI),
::uint32_t{0},
::uint32_t{0},
std::move(_messageName),
std::move(_stringParams)};
if ((!((aReader)->ReadBytesInto((&((result__)->errorFlags())), 16)))) {
aReader->FatalError("Error bulk reading fields from uint32_t");
return {};
}
// Sentinel = 'errorFlags | propertiesFile | lineNumber | columnNumber'
if ((!((aReader)->ReadSentinel(1343886625)))) {
mozilla::ipc::SentinelReadError("Error bulk reading fields from uint32_t");
return {};
}
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct CookieStruct|
//
namespace mozilla {
namespace net {
auto CookieStruct::StaticAssertions() const -> void
{
static_assert(
(offsetof(CookieStruct, creationTime_) - offsetof(CookieStruct, expiry_)) == 16,
"Bad assumptions about field layout!");
static_assert(
(offsetof(CookieStruct, rawSameSite_) - offsetof(CookieStruct, sameSite_)) == 4,
"Bad assumptions about field layout!");
}
} // namespace net
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::net::CookieStruct>::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);
IPC::WriteParam(aWriter, (aVar).host());
// Sentinel = 'host'
(aWriter)->WriteSentinel(72024511);
IPC::WriteParam(aWriter, (aVar).path());
// Sentinel = 'path'
(aWriter)->WriteSentinel(70713774);
IPC::WriteParam(aWriter, (aVar).isHttpOnly());
// Sentinel = 'isHttpOnly'
(aWriter)->WriteSentinel(374998047);
IPC::WriteParam(aWriter, (aVar).isSession());
// Sentinel = 'isSession'
(aWriter)->WriteSentinel(310838209);
IPC::WriteParam(aWriter, (aVar).isSecure());
// Sentinel = 'isSecure'
(aWriter)->WriteSentinel(244581188);
IPC::WriteParam(aWriter, (aVar).isPartitioned());
// Sentinel = 'isPartitioned'
(aWriter)->WriteSentinel(628753760);
(aWriter)->WriteBytes((&((aVar).expiry())), 24);
// Sentinel = 'expiry | lastAccessed | creationTime'
(aWriter)->WriteSentinel(4275768781);
(aWriter)->WriteBytes((&((aVar).sameSite())), 8);
// Sentinel = 'sameSite | rawSameSite'
(aWriter)->WriteSentinel(1609500765);
(aWriter)->WriteBytes((&((aVar).schemeMap())), 1);
// Sentinel = 'schemeMap'
(aWriter)->WriteSentinel(305136532);
}
auto ParamTraits<::mozilla::net::CookieStruct>::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 'CookieStruct'");
return {};
}
auto& _name = *maybe___name;
// Sentinel = 'name'
if ((!((aReader)->ReadSentinel(69075362)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'name' (nsCString) member of 'CookieStruct'");
return {};
}
auto maybe___value = IPC::ReadParam<::nsCString>(aReader);
if (!maybe___value) {
aReader->FatalError("Error deserializing 'value' (nsCString) member of 'CookieStruct'");
return {};
}
auto& _value = *maybe___value;
// Sentinel = 'value'
if ((!((aReader)->ReadSentinel(107610654)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'value' (nsCString) member of 'CookieStruct'");
return {};
}
auto maybe___host = IPC::ReadParam<::nsCString>(aReader);
if (!maybe___host) {
aReader->FatalError("Error deserializing 'host' (nsCString) member of 'CookieStruct'");
return {};
}
auto& _host = *maybe___host;
// Sentinel = 'host'
if ((!((aReader)->ReadSentinel(72024511)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'host' (nsCString) member of 'CookieStruct'");
return {};
}
auto maybe___path = IPC::ReadParam<::nsCString>(aReader);
if (!maybe___path) {
aReader->FatalError("Error deserializing 'path' (nsCString) member of 'CookieStruct'");
return {};
}
auto& _path = *maybe___path;
// Sentinel = 'path'
if ((!((aReader)->ReadSentinel(70713774)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'path' (nsCString) member of 'CookieStruct'");
return {};
}
auto maybe___isHttpOnly = IPC::ReadParam<bool>(aReader);
if (!maybe___isHttpOnly) {
aReader->FatalError("Error deserializing 'isHttpOnly' (bool) member of 'CookieStruct'");
return {};
}
auto& _isHttpOnly = *maybe___isHttpOnly;
// Sentinel = 'isHttpOnly'
if ((!((aReader)->ReadSentinel(374998047)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'isHttpOnly' (bool) member of 'CookieStruct'");
return {};
}
auto maybe___isSession = IPC::ReadParam<bool>(aReader);
if (!maybe___isSession) {
aReader->FatalError("Error deserializing 'isSession' (bool) member of 'CookieStruct'");
return {};
}
auto& _isSession = *maybe___isSession;
// Sentinel = 'isSession'
if ((!((aReader)->ReadSentinel(310838209)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'isSession' (bool) member of 'CookieStruct'");
return {};
}
auto maybe___isSecure = IPC::ReadParam<bool>(aReader);
if (!maybe___isSecure) {
aReader->FatalError("Error deserializing 'isSecure' (bool) member of 'CookieStruct'");
return {};
}
auto& _isSecure = *maybe___isSecure;
// Sentinel = 'isSecure'
if ((!((aReader)->ReadSentinel(244581188)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'isSecure' (bool) member of 'CookieStruct'");
return {};
}
auto maybe___isPartitioned = IPC::ReadParam<bool>(aReader);
if (!maybe___isPartitioned) {
aReader->FatalError("Error deserializing 'isPartitioned' (bool) member of 'CookieStruct'");
return {};
}
auto& _isPartitioned = *maybe___isPartitioned;
// Sentinel = 'isPartitioned'
if ((!((aReader)->ReadSentinel(628753760)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'isPartitioned' (bool) member of 'CookieStruct'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_name),
std::move(_value),
std::move(_host),
std::move(_path),
::int64_t{0},
::int64_t{0},
::int64_t{0},
std::move(_isHttpOnly),
std::move(_isSession),
std::move(_isSecure),
std::move(_isPartitioned),
::int32_t{0},
::int32_t{0},
::uint8_t{0}};
if ((!((aReader)->ReadBytesInto((&((result__)->expiry())), 24)))) {
aReader->FatalError("Error bulk reading fields from int64_t");
return {};
}
// Sentinel = 'expiry | lastAccessed | creationTime'
if ((!((aReader)->ReadSentinel(4275768781)))) {
mozilla::ipc::SentinelReadError("Error bulk reading fields from int64_t");
return {};
}
if ((!((aReader)->ReadBytesInto((&((result__)->sameSite())), 8)))) {
aReader->FatalError("Error bulk reading fields from int32_t");
return {};
}
// Sentinel = 'sameSite | rawSameSite'
if ((!((aReader)->ReadSentinel(1609500765)))) {
mozilla::ipc::SentinelReadError("Error bulk reading fields from int32_t");
return {};
}
if ((!((aReader)->ReadBytesInto((&((result__)->schemeMap())), 1)))) {
aReader->FatalError("Error bulk reading fields from uint8_t");
return {};
}
// Sentinel = 'schemeMap'
if ((!((aReader)->ReadSentinel(305136532)))) {
mozilla::ipc::SentinelReadError("Error bulk reading fields from uint8_t");
return {};
}
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct CookieStructTable|
//
namespace mozilla {
namespace net {
} // namespace net
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::net::CookieStructTable>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).attrs());
// Sentinel = 'attrs'
(aWriter)->WriteSentinel(107807279);
IPC::WriteParam(aWriter, (aVar).cookies());
// Sentinel = 'cookies'
(aWriter)->WriteSentinel(195363566);
}
auto ParamTraits<::mozilla::net::CookieStructTable>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___attrs = IPC::ReadParam<::mozilla::OriginAttributes>(aReader);
if (!maybe___attrs) {
aReader->FatalError("Error deserializing 'attrs' (OriginAttributes) member of 'CookieStructTable'");
return {};
}
auto& _attrs = *maybe___attrs;
// Sentinel = 'attrs'
if ((!((aReader)->ReadSentinel(107807279)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'attrs' (OriginAttributes) member of 'CookieStructTable'");
return {};
}
auto maybe___cookies = IPC::ReadParam<nsTArray<::mozilla::net::CookieStruct>>(aReader);
if (!maybe___cookies) {
aReader->FatalError("Error deserializing 'cookies' (CookieStruct[]) member of 'CookieStructTable'");
return {};
}
auto& _cookies = *maybe___cookies;
// Sentinel = 'cookies'
if ((!((aReader)->ReadSentinel(195363566)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'cookies' (CookieStruct[]) member of 'CookieStructTable'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_attrs),
std::move(_cookies)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct DocumentCreationArgs|
//
namespace mozilla {
namespace net {
} // namespace net
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::net::DocumentCreationArgs>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).uriModified());
// Sentinel = 'uriModified'
(aWriter)->WriteSentinel(453903474);
IPC::WriteParam(aWriter, (aVar).isEmbeddingBlockedError());
// Sentinel = 'isEmbeddingBlockedError'
(aWriter)->WriteSentinel(1812334874);
(aWriter)->WriteBytes((&((aVar).loadFlags())), 4);
// Sentinel = 'loadFlags'
(aWriter)->WriteSentinel(297665422);
}
auto ParamTraits<::mozilla::net::DocumentCreationArgs>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___uriModified = IPC::ReadParam<bool>(aReader);
if (!maybe___uriModified) {
aReader->FatalError("Error deserializing 'uriModified' (bool) member of 'DocumentCreationArgs'");
return {};
}
auto& _uriModified = *maybe___uriModified;
// Sentinel = 'uriModified'
if ((!((aReader)->ReadSentinel(453903474)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uriModified' (bool) member of 'DocumentCreationArgs'");
return {};
}
auto maybe___isEmbeddingBlockedError = IPC::ReadParam<bool>(aReader);
if (!maybe___isEmbeddingBlockedError) {
aReader->FatalError("Error deserializing 'isEmbeddingBlockedError' (bool) member of 'DocumentCreationArgs'");
return {};
}
auto& _isEmbeddingBlockedError = *maybe___isEmbeddingBlockedError;
// Sentinel = 'isEmbeddingBlockedError'
if ((!((aReader)->ReadSentinel(1812334874)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'isEmbeddingBlockedError' (bool) member of 'DocumentCreationArgs'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
::uint32_t{0},
std::move(_uriModified),
std::move(_isEmbeddingBlockedError)};
if ((!((aReader)->ReadBytesInto((&((result__)->loadFlags())), 4)))) {
aReader->FatalError("Error bulk reading fields from uint32_t");
return {};
}
// Sentinel = 'loadFlags'
if ((!((aReader)->ReadSentinel(297665422)))) {
mozilla::ipc::SentinelReadError("Error bulk reading fields from uint32_t");
return {};
}
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct ObjectCreationArgs|
//
namespace mozilla {
namespace net {
} // namespace net
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::net::ObjectCreationArgs>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).contentPolicyType());
// Sentinel = 'contentPolicyType'
(aWriter)->WriteSentinel(1066927886);
IPC::WriteParam(aWriter, (aVar).isUrgentStart());
// Sentinel = 'isUrgentStart'
(aWriter)->WriteSentinel(625739104);
(aWriter)->WriteBytes((&((aVar).embedderInnerWindowId())), 8);
// Sentinel = 'embedderInnerWindowId'
(aWriter)->WriteSentinel(1544423514);
(aWriter)->WriteBytes((&((aVar).loadFlags())), 4);
// Sentinel = 'loadFlags'
(aWriter)->WriteSentinel(297665422);
}
auto ParamTraits<::mozilla::net::ObjectCreationArgs>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___contentPolicyType = IPC::ReadParam<::nsContentPolicyType>(aReader);
if (!maybe___contentPolicyType) {
aReader->FatalError("Error deserializing 'contentPolicyType' (nsContentPolicyType) member of 'ObjectCreationArgs'");
return {};
}
auto& _contentPolicyType = *maybe___contentPolicyType;
// Sentinel = 'contentPolicyType'
if ((!((aReader)->ReadSentinel(1066927886)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'contentPolicyType' (nsContentPolicyType) member of 'ObjectCreationArgs'");
return {};
}
auto maybe___isUrgentStart = IPC::ReadParam<bool>(aReader);
if (!maybe___isUrgentStart) {
aReader->FatalError("Error deserializing 'isUrgentStart' (bool) member of 'ObjectCreationArgs'");
return {};
}
auto& _isUrgentStart = *maybe___isUrgentStart;
// Sentinel = 'isUrgentStart'
if ((!((aReader)->ReadSentinel(625739104)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'isUrgentStart' (bool) member of 'ObjectCreationArgs'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
::uint32_t{0},
::uint64_t{0},
std::move(_contentPolicyType),
std::move(_isUrgentStart)};
if ((!((aReader)->ReadBytesInto((&((result__)->embedderInnerWindowId())), 8)))) {
aReader->FatalError("Error bulk reading fields from uint64_t");
return {};
}
// Sentinel = 'embedderInnerWindowId'
if ((!((aReader)->ReadSentinel(1544423514)))) {
mozilla::ipc::SentinelReadError("Error bulk reading fields from uint64_t");
return {};
}
if ((!((aReader)->ReadBytesInto((&((result__)->loadFlags())), 4)))) {
aReader->FatalError("Error bulk reading fields from uint32_t");
return {};
}
// Sentinel = 'loadFlags'
if ((!((aReader)->ReadSentinel(297665422)))) {
mozilla::ipc::SentinelReadError("Error bulk reading fields from uint32_t");
return {};
}
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |union DocumentChannelElementCreationArgs|
//
namespace mozilla {
namespace net {
auto DocumentChannelElementCreationArgs::MaybeDestroy() -> void
{
if ((mType) == (T__None)) {
return;
}
switch (mType) {
case TDocumentCreationArgs:
{
(ptr_DocumentCreationArgs())->~DocumentCreationArgs__tdef();
break;
}
case TObjectCreationArgs:
{
(ptr_ObjectCreationArgs())->~ObjectCreationArgs__tdef();
break;
}
default:
{
mozilla::ipc::LogicError("not reached");
break;
}
}
}
MOZ_IMPLICIT DocumentChannelElementCreationArgs::DocumentChannelElementCreationArgs(const DocumentCreationArgs& aOther)
{
new (mozilla::KnownNotNull, ptr_DocumentCreationArgs()) DocumentCreationArgs(aOther);
mType = TDocumentCreationArgs;
}
MOZ_IMPLICIT DocumentChannelElementCreationArgs::DocumentChannelElementCreationArgs(DocumentCreationArgs&& aOther)
{
new (mozilla::KnownNotNull, ptr_DocumentCreationArgs()) DocumentCreationArgs(std::move(aOther));
mType = TDocumentCreationArgs;
}
MOZ_IMPLICIT DocumentChannelElementCreationArgs::DocumentChannelElementCreationArgs(const ObjectCreationArgs& aOther)
{
new (mozilla::KnownNotNull, ptr_ObjectCreationArgs()) ObjectCreationArgs(aOther);
mType = TObjectCreationArgs;
}
MOZ_IMPLICIT DocumentChannelElementCreationArgs::DocumentChannelElementCreationArgs(ObjectCreationArgs&& aOther)
{
new (mozilla::KnownNotNull, ptr_ObjectCreationArgs()) ObjectCreationArgs(std::move(aOther));
mType = TObjectCreationArgs;
}
MOZ_IMPLICIT DocumentChannelElementCreationArgs::DocumentChannelElementCreationArgs(const DocumentChannelElementCreationArgs& aOther)
{
(aOther).AssertSanity();
switch ((aOther).type()) {
case TDocumentCreationArgs:
{
new (mozilla::KnownNotNull, ptr_DocumentCreationArgs()) DocumentCreationArgs((aOther).get_DocumentCreationArgs());
break;
}
case TObjectCreationArgs:
{
new (mozilla::KnownNotNull, ptr_ObjectCreationArgs()) ObjectCreationArgs((aOther).get_ObjectCreationArgs());
break;
}
case T__None:
{
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
return;
}
}
mType = (aOther).type();
}
MOZ_IMPLICIT DocumentChannelElementCreationArgs::DocumentChannelElementCreationArgs(DocumentChannelElementCreationArgs&& aOther)
{
(aOther).AssertSanity();
Type t = (aOther).type();
switch (t) {
case TDocumentCreationArgs:
{
new (mozilla::KnownNotNull, ptr_DocumentCreationArgs()) DocumentCreationArgs(std::move((aOther).get_DocumentCreationArgs()));
(aOther).MaybeDestroy();
break;
}
case TObjectCreationArgs:
{
new (mozilla::KnownNotNull, ptr_ObjectCreationArgs()) ObjectCreationArgs(std::move((aOther).get_ObjectCreationArgs()));
(aOther).MaybeDestroy();
break;
}
case T__None:
{
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
return;
}
}
(aOther).mType = T__None;
mType = t;
}
DocumentChannelElementCreationArgs::~DocumentChannelElementCreationArgs()
{
MaybeDestroy();
}
auto DocumentChannelElementCreationArgs::operator=(const DocumentCreationArgs& aRhs) -> DocumentChannelElementCreationArgs&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_DocumentCreationArgs()) DocumentCreationArgs(aRhs);
mType = TDocumentCreationArgs;
return (*(this));
}
auto DocumentChannelElementCreationArgs::operator=(DocumentCreationArgs&& aRhs) -> DocumentChannelElementCreationArgs&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_DocumentCreationArgs()) DocumentCreationArgs(std::move(aRhs));
mType = TDocumentCreationArgs;
return (*(this));
}
auto DocumentChannelElementCreationArgs::operator=(const ObjectCreationArgs& aRhs) -> DocumentChannelElementCreationArgs&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_ObjectCreationArgs()) ObjectCreationArgs(aRhs);
mType = TObjectCreationArgs;
return (*(this));
}
auto DocumentChannelElementCreationArgs::operator=(ObjectCreationArgs&& aRhs) -> DocumentChannelElementCreationArgs&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_ObjectCreationArgs()) ObjectCreationArgs(std::move(aRhs));
mType = TObjectCreationArgs;
return (*(this));
}
auto DocumentChannelElementCreationArgs::operator=(const DocumentChannelElementCreationArgs& aRhs) -> DocumentChannelElementCreationArgs&
{
(aRhs).AssertSanity();
Type t = (aRhs).type();
switch (t) {
case TDocumentCreationArgs:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_DocumentCreationArgs()) DocumentCreationArgs((aRhs).get_DocumentCreationArgs());
break;
}
case TObjectCreationArgs:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_ObjectCreationArgs()) ObjectCreationArgs((aRhs).get_ObjectCreationArgs());
break;
}
case T__None:
{
MaybeDestroy();
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
break;
}
}
mType = t;
return (*(this));
}
auto DocumentChannelElementCreationArgs::operator=(DocumentChannelElementCreationArgs&& aRhs) -> DocumentChannelElementCreationArgs&
{
(aRhs).AssertSanity();
Type t = (aRhs).type();
switch (t) {
case TDocumentCreationArgs:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_DocumentCreationArgs()) DocumentCreationArgs(std::move((aRhs).get_DocumentCreationArgs()));
(aRhs).MaybeDestroy();
break;
}
case TObjectCreationArgs:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_ObjectCreationArgs()) ObjectCreationArgs(std::move((aRhs).get_ObjectCreationArgs()));
(aRhs).MaybeDestroy();
break;
}
case T__None:
{
MaybeDestroy();
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
break;
}
}
(aRhs).mType = T__None;
mType = t;
return (*(this));
}
} // namespace net
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::net::DocumentChannelElementCreationArgs>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
typedef ::mozilla::net::DocumentChannelElementCreationArgs union__;
int type = (aVar).type();
IPC::WriteParam(aWriter, type);
// Sentinel = 'DocumentChannelElementCreationArgs'
(aWriter)->WriteSentinel(3941207429);
switch (type) {
case union__::TDocumentCreationArgs:
{
IPC::WriteParam(aWriter, (aVar).get_DocumentCreationArgs());
// Sentinel = 'TDocumentCreationArgs'
(aWriter)->WriteSentinel(1512245334);
return;
}
case union__::TObjectCreationArgs:
{
IPC::WriteParam(aWriter, (aVar).get_ObjectCreationArgs());
// Sentinel = 'TObjectCreationArgs'
(aWriter)->WriteSentinel(1215760238);
return;
}
default:
{
aWriter->FatalError("unknown variant of union DocumentChannelElementCreationArgs");
return;
}
}
}
auto ParamTraits<::mozilla::net::DocumentChannelElementCreationArgs>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
typedef ::mozilla::net::DocumentChannelElementCreationArgs union__;
auto maybe__type = IPC::ReadParam<int>(aReader);
if (!maybe__type) {
aReader->FatalError("Error deserializing type of union DocumentChannelElementCreationArgs");
return {};
}
auto& type = *maybe__type;
// Sentinel = 'DocumentChannelElementCreationArgs'
if ((!((aReader)->ReadSentinel(3941207429)))) {
mozilla::ipc::SentinelReadError("Error deserializing type of union DocumentChannelElementCreationArgs");
return {};
}
switch (type) {
case union__::TDocumentCreationArgs:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::net::DocumentCreationArgs>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TDocumentCreationArgs of union DocumentChannelElementCreationArgs");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TDocumentCreationArgs'
if ((!((aReader)->ReadSentinel(1512245334)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TDocumentCreationArgs of union DocumentChannelElementCreationArgs");
return {};
}
return std::move(tmp);
}
case union__::TObjectCreationArgs:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::net::ObjectCreationArgs>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TObjectCreationArgs of union DocumentChannelElementCreationArgs");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TObjectCreationArgs'
if ((!((aReader)->ReadSentinel(1215760238)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TObjectCreationArgs of union DocumentChannelElementCreationArgs");
return {};
}
return std::move(tmp);
}
default:
{
aReader->FatalError("unknown variant of union DocumentChannelElementCreationArgs");
return {};
}
}
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct DocumentChannelCreationArgs|
//
namespace mozilla {
namespace net {
auto DocumentChannelCreationArgs::StaticAssertions() const -> void
{
static_assert(
(offsetof(DocumentChannelCreationArgs, parentInitiatedNavigationEpoch_) - offsetof(DocumentChannelCreationArgs, channelId_)) == 8,
"Bad assumptions about field layout!");
}
} // namespace net
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::net::DocumentChannelCreationArgs>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).loadState());
// Sentinel = 'loadState'
(aWriter)->WriteSentinel(304808866);
IPC::WriteParam(aWriter, (aVar).asyncOpenTime());
// Sentinel = 'asyncOpenTime'
(aWriter)->WriteSentinel(623772992);
IPC::WriteParam(aWriter, (aVar).timing());
// Sentinel = 'timing'
(aWriter)->WriteSentinel(150798985);
IPC::WriteParam(aWriter, (aVar).initialClientInfo());
// Sentinel = 'initialClientInfo'
(aWriter)->WriteSentinel(1038354134);
IPC::WriteParam(aWriter, (aVar).elementCreationArgs());
// Sentinel = 'elementCreationArgs'
(aWriter)->WriteSentinel(1287718829);
(aWriter)->WriteBytes((&((aVar).channelId())), 16);
// Sentinel = 'channelId | parentInitiatedNavigationEpoch'
(aWriter)->WriteSentinel(1526403175);
(aWriter)->WriteBytes((&((aVar).cacheKey())), 4);
// Sentinel = 'cacheKey'
(aWriter)->WriteSentinel(232325918);
}
auto ParamTraits<::mozilla::net::DocumentChannelCreationArgs>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___loadState = IPC::ReadParam<mozilla::NotNull<RefPtr<::nsDocShellLoadState>>>(aReader);
if (!maybe___loadState) {
aReader->FatalError("Error deserializing 'loadState' (NotNull<nsDocShellLoadState>) member of 'DocumentChannelCreationArgs'");
return {};
}
auto& _loadState = *maybe___loadState;
// Sentinel = 'loadState'
if ((!((aReader)->ReadSentinel(304808866)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'loadState' (NotNull<nsDocShellLoadState>) member of 'DocumentChannelCreationArgs'");
return {};
}
auto maybe___asyncOpenTime = IPC::ReadParam<::mozilla::TimeStamp>(aReader);
if (!maybe___asyncOpenTime) {
aReader->FatalError("Error deserializing 'asyncOpenTime' (TimeStamp) member of 'DocumentChannelCreationArgs'");
return {};
}
auto& _asyncOpenTime = *maybe___asyncOpenTime;
// Sentinel = 'asyncOpenTime'
if ((!((aReader)->ReadSentinel(623772992)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'asyncOpenTime' (TimeStamp) member of 'DocumentChannelCreationArgs'");
return {};
}
auto maybe___timing = IPC::ReadParam<RefPtr<::nsDOMNavigationTiming>>(aReader);
if (!maybe___timing) {
aReader->FatalError("Error deserializing 'timing' (nsDOMNavigationTiming) member of 'DocumentChannelCreationArgs'");
return {};
}
auto& _timing = *maybe___timing;
// Sentinel = 'timing'
if ((!((aReader)->ReadSentinel(150798985)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'timing' (nsDOMNavigationTiming) member of 'DocumentChannelCreationArgs'");
return {};
}
auto maybe___initialClientInfo = IPC::ReadParam<mozilla::Maybe<::mozilla::dom::IPCClientInfo>>(aReader);
if (!maybe___initialClientInfo) {
aReader->FatalError("Error deserializing 'initialClientInfo' (IPCClientInfo?) member of 'DocumentChannelCreationArgs'");
return {};
}
auto& _initialClientInfo = *maybe___initialClientInfo;
// Sentinel = 'initialClientInfo'
if ((!((aReader)->ReadSentinel(1038354134)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'initialClientInfo' (IPCClientInfo?) member of 'DocumentChannelCreationArgs'");
return {};
}
auto maybe___elementCreationArgs = IPC::ReadParam<::mozilla::net::DocumentChannelElementCreationArgs>(aReader);
if (!maybe___elementCreationArgs) {
aReader->FatalError("Error deserializing 'elementCreationArgs' (DocumentChannelElementCreationArgs) member of 'DocumentChannelCreationArgs'");
return {};
}
auto& _elementCreationArgs = *maybe___elementCreationArgs;
// Sentinel = 'elementCreationArgs'
if ((!((aReader)->ReadSentinel(1287718829)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'elementCreationArgs' (DocumentChannelElementCreationArgs) member of 'DocumentChannelCreationArgs'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_loadState),
std::move(_asyncOpenTime),
::uint64_t{0},
::uint32_t{0},
std::move(_timing),
std::move(_initialClientInfo),
std::move(_elementCreationArgs),
::uint64_t{0}};
if ((!((aReader)->ReadBytesInto((&((result__)->channelId())), 16)))) {
aReader->FatalError("Error bulk reading fields from uint64_t");
return {};
}
// Sentinel = 'channelId | parentInitiatedNavigationEpoch'
if ((!((aReader)->ReadSentinel(1526403175)))) {
mozilla::ipc::SentinelReadError("Error bulk reading fields from uint64_t");
return {};
}
if ((!((aReader)->ReadBytesInto((&((result__)->cacheKey())), 4)))) {
aReader->FatalError("Error bulk reading fields from uint32_t");
return {};
}
// Sentinel = 'cacheKey'
if ((!((aReader)->ReadSentinel(232325918)))) {
mozilla::ipc::SentinelReadError("Error bulk reading fields from uint32_t");
return {};
}
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct EarlyHintConnectArgs|
//
namespace mozilla {
namespace net {
} // namespace net
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::net::EarlyHintConnectArgs>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).link());
// Sentinel = 'link'
(aWriter)->WriteSentinel(70648239);
(aWriter)->WriteBytes((&((aVar).earlyHintPreloaderId())), 8);
// Sentinel = 'earlyHintPreloaderId'
(aWriter)->WriteSentinel(1423640572);
}
auto ParamTraits<::mozilla::net::EarlyHintConnectArgs>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___link = IPC::ReadParam<::mozilla::net::LinkHeader>(aReader);
if (!maybe___link) {
aReader->FatalError("Error deserializing 'link' (LinkHeader) member of 'EarlyHintConnectArgs'");
return {};
}
auto& _link = *maybe___link;
// Sentinel = 'link'
if ((!((aReader)->ReadSentinel(70648239)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'link' (LinkHeader) member of 'EarlyHintConnectArgs'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_link),
::uint64_t{0}};
if ((!((aReader)->ReadBytesInto((&((result__)->earlyHintPreloaderId())), 8)))) {
aReader->FatalError("Error bulk reading fields from uint64_t");
return {};
}
// Sentinel = 'earlyHintPreloaderId'
if ((!((aReader)->ReadSentinel(1423640572)))) {
mozilla::ipc::SentinelReadError("Error bulk reading fields from uint64_t");
return {};
}
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct RedirectToRealChannelArgs|
//
namespace mozilla {
namespace net {
auto RedirectToRealChannelArgs::StaticAssertions() const -> void
{
static_assert(
(offsetof(RedirectToRealChannelArgs, loadIdentifier_) - offsetof(RedirectToRealChannelArgs, channelId_)) == 8,
"Bad assumptions about field layout!");
static_assert(
(offsetof(RedirectToRealChannelArgs, earlyHintLinkType_) - offsetof(RedirectToRealChannelArgs, registrarId_)) == 28,
"Bad assumptions about field layout!");
}
} // namespace net
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::net::RedirectToRealChannelArgs>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).uri());
// Sentinel = 'uri'
(aWriter)->WriteSentinel(45023569);
IPC::WriteParam(aWriter, (aVar).init());
// Sentinel = 'init'
(aWriter)->WriteSentinel(70779317);
IPC::WriteParam(aWriter, (aVar).loadInfo());
// Sentinel = 'loadInfo'
(aWriter)->WriteSentinel(240386861);
IPC::WriteParam(aWriter, (aVar).originalURI());
// Sentinel = 'originalURI'
(aWriter)->WriteSentinel(455148614);
IPC::WriteParam(aWriter, (aVar).contentDisposition());
// Sentinel = 'contentDisposition'
(aWriter)->WriteSentinel(1196361617);
IPC::WriteParam(aWriter, (aVar).contentDispositionFilename());
// Sentinel = 'contentDispositionFilename'
(aWriter)->WriteSentinel(2441153202);
IPC::WriteParam(aWriter, (aVar).properties());
// Sentinel = 'properties'
(aWriter)->WriteSentinel(399770702);
IPC::WriteParam(aWriter, (aVar).timing());
// Sentinel = 'timing'
(aWriter)->WriteSentinel(150798985);
IPC::WriteParam(aWriter, (aVar).srcdocData());
// Sentinel = 'srcdocData'
(aWriter)->WriteSentinel(375587833);
IPC::WriteParam(aWriter, (aVar).baseUri());
// Sentinel = 'baseUri'
(aWriter)->WriteSentinel(186254028);
IPC::WriteParam(aWriter, (aVar).loadingSessionHistoryInfo());
// Sentinel = 'loadingSessionHistoryInfo'
(aWriter)->WriteSentinel(2228161089);
IPC::WriteParam(aWriter, (aVar).originalUriString());
// Sentinel = 'originalUriString'
(aWriter)->WriteSentinel(1059129085);
IPC::WriteParam(aWriter, (aVar).earlyHints());
// Sentinel = 'earlyHints'
(aWriter)->WriteSentinel(376439844);
(aWriter)->WriteBytes((&((aVar).channelId())), 16);
// Sentinel = 'channelId | loadIdentifier'
(aWriter)->WriteSentinel(2204699110);
(aWriter)->WriteBytes((&((aVar).registrarId())), 32);
// Sentinel = 'registrarId | newLoadFlags | redirectMode | redirectFlags | loadStateExternalLoadFlags | loadStateInternalLoadFlags | loadStateLoadType | earlyHintLinkType'
(aWriter)->WriteSentinel(3453237937);
}
auto ParamTraits<::mozilla::net::RedirectToRealChannelArgs>::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 'RedirectToRealChannelArgs'");
return {};
}
auto& _uri = *maybe___uri;
// Sentinel = 'uri'
if ((!((aReader)->ReadSentinel(45023569)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uri' (nsIURI) member of 'RedirectToRealChannelArgs'");
return {};
}
auto maybe___init = IPC::ReadParam<mozilla::Maybe<::mozilla::dom::ReplacementChannelConfigInit>>(aReader);
if (!maybe___init) {
aReader->FatalError("Error deserializing 'init' (ReplacementChannelConfigInit?) member of 'RedirectToRealChannelArgs'");
return {};
}
auto& _init = *maybe___init;
// Sentinel = 'init'
if ((!((aReader)->ReadSentinel(70779317)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'init' (ReplacementChannelConfigInit?) member of 'RedirectToRealChannelArgs'");
return {};
}
auto maybe___loadInfo = IPC::ReadParam<::mozilla::net::LoadInfoArgs>(aReader);
if (!maybe___loadInfo) {
aReader->FatalError("Error deserializing 'loadInfo' (LoadInfoArgs) member of 'RedirectToRealChannelArgs'");
return {};
}
auto& _loadInfo = *maybe___loadInfo;
// Sentinel = 'loadInfo'
if ((!((aReader)->ReadSentinel(240386861)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'loadInfo' (LoadInfoArgs) member of 'RedirectToRealChannelArgs'");
return {};
}
auto maybe___originalURI = IPC::ReadParam<RefPtr<::nsIURI>>(aReader);
if (!maybe___originalURI) {
aReader->FatalError("Error deserializing 'originalURI' (nsIURI) member of 'RedirectToRealChannelArgs'");
return {};
}
auto& _originalURI = *maybe___originalURI;
// Sentinel = 'originalURI'
if ((!((aReader)->ReadSentinel(455148614)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'originalURI' (nsIURI) member of 'RedirectToRealChannelArgs'");
return {};
}
auto maybe___contentDisposition = IPC::ReadParam<mozilla::Maybe<::uint32_t>>(aReader);
if (!maybe___contentDisposition) {
aReader->FatalError("Error deserializing 'contentDisposition' (uint32_t?) member of 'RedirectToRealChannelArgs'");
return {};
}
auto& _contentDisposition = *maybe___contentDisposition;
// Sentinel = 'contentDisposition'
if ((!((aReader)->ReadSentinel(1196361617)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'contentDisposition' (uint32_t?) member of 'RedirectToRealChannelArgs'");
return {};
}
auto maybe___contentDispositionFilename = IPC::ReadParam<mozilla::Maybe<::nsString>>(aReader);
if (!maybe___contentDispositionFilename) {
aReader->FatalError("Error deserializing 'contentDispositionFilename' (nsString?) member of 'RedirectToRealChannelArgs'");
return {};
}
auto& _contentDispositionFilename = *maybe___contentDispositionFilename;
// Sentinel = 'contentDispositionFilename'
if ((!((aReader)->ReadSentinel(2441153202)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'contentDispositionFilename' (nsString?) member of 'RedirectToRealChannelArgs'");
return {};
}
auto maybe___properties = IPC::ReadParam<RefPtr<::nsIPropertyBag2>>(aReader);
if (!maybe___properties) {
aReader->FatalError("Error deserializing 'properties' (nsIPropertyBag2) member of 'RedirectToRealChannelArgs'");
return {};
}
auto& _properties = *maybe___properties;
// Sentinel = 'properties'
if ((!((aReader)->ReadSentinel(399770702)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'properties' (nsIPropertyBag2) member of 'RedirectToRealChannelArgs'");
return {};
}
auto maybe___timing = IPC::ReadParam<RefPtr<::nsDOMNavigationTiming>>(aReader);
if (!maybe___timing) {
aReader->FatalError("Error deserializing 'timing' (nsDOMNavigationTiming) member of 'RedirectToRealChannelArgs'");
return {};
}
auto& _timing = *maybe___timing;
// Sentinel = 'timing'
if ((!((aReader)->ReadSentinel(150798985)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'timing' (nsDOMNavigationTiming) member of 'RedirectToRealChannelArgs'");
return {};
}
auto maybe___srcdocData = IPC::ReadParam<::nsString>(aReader);
if (!maybe___srcdocData) {
aReader->FatalError("Error deserializing 'srcdocData' (nsString) member of 'RedirectToRealChannelArgs'");
return {};
}
auto& _srcdocData = *maybe___srcdocData;
// Sentinel = 'srcdocData'
if ((!((aReader)->ReadSentinel(375587833)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'srcdocData' (nsString) member of 'RedirectToRealChannelArgs'");
return {};
}
auto maybe___baseUri = IPC::ReadParam<RefPtr<::nsIURI>>(aReader);
if (!maybe___baseUri) {
aReader->FatalError("Error deserializing 'baseUri' (nsIURI) member of 'RedirectToRealChannelArgs'");
return {};
}
auto& _baseUri = *maybe___baseUri;
// Sentinel = 'baseUri'
if ((!((aReader)->ReadSentinel(186254028)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'baseUri' (nsIURI) member of 'RedirectToRealChannelArgs'");
return {};
}
auto maybe___loadingSessionHistoryInfo = IPC::ReadParam<mozilla::Maybe<::mozilla::dom::LoadingSessionHistoryInfo>>(aReader);
if (!maybe___loadingSessionHistoryInfo) {
aReader->FatalError("Error deserializing 'loadingSessionHistoryInfo' (LoadingSessionHistoryInfo?) member of 'RedirectToRealChannelArgs'");
return {};
}
auto& _loadingSessionHistoryInfo = *maybe___loadingSessionHistoryInfo;
// Sentinel = 'loadingSessionHistoryInfo'
if ((!((aReader)->ReadSentinel(2228161089)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'loadingSessionHistoryInfo' (LoadingSessionHistoryInfo?) member of 'RedirectToRealChannelArgs'");
return {};
}
auto maybe___originalUriString = IPC::ReadParam<mozilla::Maybe<::nsCString>>(aReader);
if (!maybe___originalUriString) {
aReader->FatalError("Error deserializing 'originalUriString' (nsCString?) member of 'RedirectToRealChannelArgs'");
return {};
}
auto& _originalUriString = *maybe___originalUriString;
// Sentinel = 'originalUriString'
if ((!((aReader)->ReadSentinel(1059129085)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'originalUriString' (nsCString?) member of 'RedirectToRealChannelArgs'");
return {};
}
auto maybe___earlyHints = IPC::ReadParam<nsTArray<::mozilla::net::EarlyHintConnectArgs>>(aReader);
if (!maybe___earlyHints) {
aReader->FatalError("Error deserializing 'earlyHints' (EarlyHintConnectArgs[]) member of 'RedirectToRealChannelArgs'");
return {};
}
auto& _earlyHints = *maybe___earlyHints;
// Sentinel = 'earlyHints'
if ((!((aReader)->ReadSentinel(376439844)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'earlyHints' (EarlyHintConnectArgs[]) member of 'RedirectToRealChannelArgs'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
::uint32_t{0},
std::move(_uri),
::uint32_t{0},
std::move(_init),
std::move(_loadInfo),
::uint64_t{0},
std::move(_originalURI),
::uint32_t{0},
::uint32_t{0},
std::move(_contentDisposition),
std::move(_contentDispositionFilename),
std::move(_properties),
::uint32_t{0},
::uint32_t{0},
::uint32_t{0},
std::move(_timing),
std::move(_srcdocData),
std::move(_baseUri),
std::move(_loadingSessionHistoryInfo),
::uint64_t{0},
std::move(_originalUriString),
std::move(_earlyHints),
::uint32_t{0}};
if ((!((aReader)->ReadBytesInto((&((result__)->channelId())), 16)))) {
aReader->FatalError("Error bulk reading fields from uint64_t");
return {};
}
// Sentinel = 'channelId | loadIdentifier'
if ((!((aReader)->ReadSentinel(2204699110)))) {
mozilla::ipc::SentinelReadError("Error bulk reading fields from uint64_t");
return {};
}
if ((!((aReader)->ReadBytesInto((&((result__)->registrarId())), 32)))) {
aReader->FatalError("Error bulk reading fields from uint32_t");
return {};
}
// Sentinel = 'registrarId | newLoadFlags | redirectMode | redirectFlags | loadStateExternalLoadFlags | loadStateInternalLoadFlags | loadStateLoadType | earlyHintLinkType'
if ((!((aReader)->ReadSentinel(3453237937)))) {
mozilla::ipc::SentinelReadError("Error bulk reading fields from uint32_t");
return {};
}
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct TimingStructArgs|
//
namespace mozilla {
namespace net {
} // namespace net
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::net::TimingStructArgs>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).domainLookupStart());
// Sentinel = 'domainLookupStart'
(aWriter)->WriteSentinel(1047070465);
IPC::WriteParam(aWriter, (aVar).domainLookupEnd());
// Sentinel = 'domainLookupEnd'
(aWriter)->WriteSentinel(816317962);
IPC::WriteParam(aWriter, (aVar).connectStart());
// Sentinel = 'connectStart'
(aWriter)->WriteSentinel(538838265);
IPC::WriteParam(aWriter, (aVar).tcpConnectEnd());
// Sentinel = 'tcpConnectEnd'
(aWriter)->WriteSentinel(612893993);
IPC::WriteParam(aWriter, (aVar).secureConnectionStart());
// Sentinel = 'secureConnectionStart'
(aWriter)->WriteSentinel(1588725926);
IPC::WriteParam(aWriter, (aVar).connectEnd());
// Sentinel = 'connectEnd'
(aWriter)->WriteSentinel(376243202);
IPC::WriteParam(aWriter, (aVar).requestStart());
// Sentinel = 'requestStart'
(aWriter)->WriteSentinel(556860696);
IPC::WriteParam(aWriter, (aVar).responseStart());
// Sentinel = 'responseStart'
(aWriter)->WriteSentinel(648545662);
IPC::WriteParam(aWriter, (aVar).responseEnd());
// Sentinel = 'responseEnd'
(aWriter)->WriteSentinel(468518023);
IPC::WriteParam(aWriter, (aVar).transactionPending());
// Sentinel = 'transactionPending'
(aWriter)->WriteSentinel(1196951404);
}
auto ParamTraits<::mozilla::net::TimingStructArgs>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___domainLookupStart = IPC::ReadParam<::mozilla::TimeStamp>(aReader);
if (!maybe___domainLookupStart) {
aReader->FatalError("Error deserializing 'domainLookupStart' (TimeStamp) member of 'TimingStructArgs'");
return {};
}
auto& _domainLookupStart = *maybe___domainLookupStart;
// Sentinel = 'domainLookupStart'
if ((!((aReader)->ReadSentinel(1047070465)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'domainLookupStart' (TimeStamp) member of 'TimingStructArgs'");
return {};
}
auto maybe___domainLookupEnd = IPC::ReadParam<::mozilla::TimeStamp>(aReader);
if (!maybe___domainLookupEnd) {
aReader->FatalError("Error deserializing 'domainLookupEnd' (TimeStamp) member of 'TimingStructArgs'");
return {};
}
auto& _domainLookupEnd = *maybe___domainLookupEnd;
// Sentinel = 'domainLookupEnd'
if ((!((aReader)->ReadSentinel(816317962)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'domainLookupEnd' (TimeStamp) member of 'TimingStructArgs'");
return {};
}
auto maybe___connectStart = IPC::ReadParam<::mozilla::TimeStamp>(aReader);
if (!maybe___connectStart) {
aReader->FatalError("Error deserializing 'connectStart' (TimeStamp) member of 'TimingStructArgs'");
return {};
}
auto& _connectStart = *maybe___connectStart;
// Sentinel = 'connectStart'
if ((!((aReader)->ReadSentinel(538838265)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'connectStart' (TimeStamp) member of 'TimingStructArgs'");
return {};
}
auto maybe___tcpConnectEnd = IPC::ReadParam<::mozilla::TimeStamp>(aReader);
if (!maybe___tcpConnectEnd) {
aReader->FatalError("Error deserializing 'tcpConnectEnd' (TimeStamp) member of 'TimingStructArgs'");
return {};
}
auto& _tcpConnectEnd = *maybe___tcpConnectEnd;
// Sentinel = 'tcpConnectEnd'
if ((!((aReader)->ReadSentinel(612893993)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'tcpConnectEnd' (TimeStamp) member of 'TimingStructArgs'");
return {};
}
auto maybe___secureConnectionStart = IPC::ReadParam<::mozilla::TimeStamp>(aReader);
if (!maybe___secureConnectionStart) {
aReader->FatalError("Error deserializing 'secureConnectionStart' (TimeStamp) member of 'TimingStructArgs'");
return {};
}
auto& _secureConnectionStart = *maybe___secureConnectionStart;
// Sentinel = 'secureConnectionStart'
if ((!((aReader)->ReadSentinel(1588725926)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'secureConnectionStart' (TimeStamp) member of 'TimingStructArgs'");
return {};
}
auto maybe___connectEnd = IPC::ReadParam<::mozilla::TimeStamp>(aReader);
if (!maybe___connectEnd) {
aReader->FatalError("Error deserializing 'connectEnd' (TimeStamp) member of 'TimingStructArgs'");
return {};
}
auto& _connectEnd = *maybe___connectEnd;
// Sentinel = 'connectEnd'
if ((!((aReader)->ReadSentinel(376243202)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'connectEnd' (TimeStamp) member of 'TimingStructArgs'");
return {};
}
auto maybe___requestStart = IPC::ReadParam<::mozilla::TimeStamp>(aReader);
if (!maybe___requestStart) {
aReader->FatalError("Error deserializing 'requestStart' (TimeStamp) member of 'TimingStructArgs'");
return {};
}
auto& _requestStart = *maybe___requestStart;
// Sentinel = 'requestStart'
if ((!((aReader)->ReadSentinel(556860696)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'requestStart' (TimeStamp) member of 'TimingStructArgs'");
return {};
}
auto maybe___responseStart = IPC::ReadParam<::mozilla::TimeStamp>(aReader);
if (!maybe___responseStart) {
aReader->FatalError("Error deserializing 'responseStart' (TimeStamp) member of 'TimingStructArgs'");
return {};
}
auto& _responseStart = *maybe___responseStart;
// Sentinel = 'responseStart'
if ((!((aReader)->ReadSentinel(648545662)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'responseStart' (TimeStamp) member of 'TimingStructArgs'");
return {};
}
auto maybe___responseEnd = IPC::ReadParam<::mozilla::TimeStamp>(aReader);
if (!maybe___responseEnd) {
aReader->FatalError("Error deserializing 'responseEnd' (TimeStamp) member of 'TimingStructArgs'");
return {};
}
auto& _responseEnd = *maybe___responseEnd;
// Sentinel = 'responseEnd'
if ((!((aReader)->ReadSentinel(468518023)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'responseEnd' (TimeStamp) member of 'TimingStructArgs'");
return {};
}
auto maybe___transactionPending = IPC::ReadParam<::mozilla::TimeStamp>(aReader);
if (!maybe___transactionPending) {
aReader->FatalError("Error deserializing 'transactionPending' (TimeStamp) member of 'TimingStructArgs'");
return {};
}
auto& _transactionPending = *maybe___transactionPending;
// Sentinel = 'transactionPending'
if ((!((aReader)->ReadSentinel(1196951404)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'transactionPending' (TimeStamp) member of 'TimingStructArgs'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_domainLookupStart),
std::move(_domainLookupEnd),
std::move(_connectStart),
std::move(_tcpConnectEnd),
std::move(_secureConnectionStart),
std::move(_connectEnd),
std::move(_requestStart),
std::move(_responseStart),
std::move(_responseEnd),
std::move(_transactionPending)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct ResourceTimingStructArgs|
//
namespace mozilla {
namespace net {
auto ResourceTimingStructArgs::StaticAssertions() const -> void
{
static_assert(
(offsetof(ResourceTimingStructArgs, encodedBodySize_) - offsetof(ResourceTimingStructArgs, transferSize_)) == 8,
"Bad assumptions about field layout!");
}
} // namespace net
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::net::ResourceTimingStructArgs>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).domainLookupStart());
// Sentinel = 'domainLookupStart'
(aWriter)->WriteSentinel(1047070465);
IPC::WriteParam(aWriter, (aVar).domainLookupEnd());
// Sentinel = 'domainLookupEnd'
(aWriter)->WriteSentinel(816317962);
IPC::WriteParam(aWriter, (aVar).connectStart());
// Sentinel = 'connectStart'
(aWriter)->WriteSentinel(538838265);
IPC::WriteParam(aWriter, (aVar).tcpConnectEnd());
// Sentinel = 'tcpConnectEnd'
(aWriter)->WriteSentinel(612893993);
IPC::WriteParam(aWriter, (aVar).secureConnectionStart());
// Sentinel = 'secureConnectionStart'
(aWriter)->WriteSentinel(1588725926);
IPC::WriteParam(aWriter, (aVar).connectEnd());
// Sentinel = 'connectEnd'
(aWriter)->WriteSentinel(376243202);
IPC::WriteParam(aWriter, (aVar).requestStart());
// Sentinel = 'requestStart'
(aWriter)->WriteSentinel(556860696);
IPC::WriteParam(aWriter, (aVar).responseStart());
// Sentinel = 'responseStart'
(aWriter)->WriteSentinel(648545662);
IPC::WriteParam(aWriter, (aVar).responseEnd());
// Sentinel = 'responseEnd'
(aWriter)->WriteSentinel(468518023);
IPC::WriteParam(aWriter, (aVar).fetchStart());
// Sentinel = 'fetchStart'
(aWriter)->WriteSentinel(373425177);
IPC::WriteParam(aWriter, (aVar).redirectStart());
// Sentinel = 'redirectStart'
(aWriter)->WriteSentinel(628753761);
IPC::WriteParam(aWriter, (aVar).redirectEnd());
// Sentinel = 'redirectEnd'
(aWriter)->WriteSentinel(452527210);
IPC::WriteParam(aWriter, (aVar).cacheReadStart());
// Sentinel = 'cacheReadStart'
(aWriter)->WriteSentinel(677774719);
IPC::WriteParam(aWriter, (aVar).cacheReadEnd());
// Sentinel = 'cacheReadEnd'
(aWriter)->WriteSentinel(497616008);
IPC::WriteParam(aWriter, (aVar).transactionPending());
// Sentinel = 'transactionPending'
(aWriter)->WriteSentinel(1196951404);
(aWriter)->WriteBytes((&((aVar).transferSize())), 16);
// Sentinel = 'transferSize | encodedBodySize'
(aWriter)->WriteSentinel(3071019960);
}
auto ParamTraits<::mozilla::net::ResourceTimingStructArgs>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___domainLookupStart = IPC::ReadParam<::mozilla::TimeStamp>(aReader);
if (!maybe___domainLookupStart) {
aReader->FatalError("Error deserializing 'domainLookupStart' (TimeStamp) member of 'ResourceTimingStructArgs'");
return {};
}
auto& _domainLookupStart = *maybe___domainLookupStart;
// Sentinel = 'domainLookupStart'
if ((!((aReader)->ReadSentinel(1047070465)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'domainLookupStart' (TimeStamp) member of 'ResourceTimingStructArgs'");
return {};
}
auto maybe___domainLookupEnd = IPC::ReadParam<::mozilla::TimeStamp>(aReader);
if (!maybe___domainLookupEnd) {
aReader->FatalError("Error deserializing 'domainLookupEnd' (TimeStamp) member of 'ResourceTimingStructArgs'");
return {};
}
auto& _domainLookupEnd = *maybe___domainLookupEnd;
// Sentinel = 'domainLookupEnd'
if ((!((aReader)->ReadSentinel(816317962)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'domainLookupEnd' (TimeStamp) member of 'ResourceTimingStructArgs'");
return {};
}
auto maybe___connectStart = IPC::ReadParam<::mozilla::TimeStamp>(aReader);
if (!maybe___connectStart) {
aReader->FatalError("Error deserializing 'connectStart' (TimeStamp) member of 'ResourceTimingStructArgs'");
return {};
}
auto& _connectStart = *maybe___connectStart;
// Sentinel = 'connectStart'
if ((!((aReader)->ReadSentinel(538838265)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'connectStart' (TimeStamp) member of 'ResourceTimingStructArgs'");
return {};
}
auto maybe___tcpConnectEnd = IPC::ReadParam<::mozilla::TimeStamp>(aReader);
if (!maybe___tcpConnectEnd) {
aReader->FatalError("Error deserializing 'tcpConnectEnd' (TimeStamp) member of 'ResourceTimingStructArgs'");
return {};
}
auto& _tcpConnectEnd = *maybe___tcpConnectEnd;
// Sentinel = 'tcpConnectEnd'
if ((!((aReader)->ReadSentinel(612893993)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'tcpConnectEnd' (TimeStamp) member of 'ResourceTimingStructArgs'");
return {};
}
auto maybe___secureConnectionStart = IPC::ReadParam<::mozilla::TimeStamp>(aReader);
if (!maybe___secureConnectionStart) {
aReader->FatalError("Error deserializing 'secureConnectionStart' (TimeStamp) member of 'ResourceTimingStructArgs'");
return {};
}
auto& _secureConnectionStart = *maybe___secureConnectionStart;
// Sentinel = 'secureConnectionStart'
if ((!((aReader)->ReadSentinel(1588725926)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'secureConnectionStart' (TimeStamp) member of 'ResourceTimingStructArgs'");
return {};
}
auto maybe___connectEnd = IPC::ReadParam<::mozilla::TimeStamp>(aReader);
if (!maybe___connectEnd) {
aReader->FatalError("Error deserializing 'connectEnd' (TimeStamp) member of 'ResourceTimingStructArgs'");
return {};
}
auto& _connectEnd = *maybe___connectEnd;
// Sentinel = 'connectEnd'
if ((!((aReader)->ReadSentinel(376243202)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'connectEnd' (TimeStamp) member of 'ResourceTimingStructArgs'");
return {};
}
auto maybe___requestStart = IPC::ReadParam<::mozilla::TimeStamp>(aReader);
if (!maybe___requestStart) {
aReader->FatalError("Error deserializing 'requestStart' (TimeStamp) member of 'ResourceTimingStructArgs'");
return {};
}
auto& _requestStart = *maybe___requestStart;
// Sentinel = 'requestStart'
if ((!((aReader)->ReadSentinel(556860696)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'requestStart' (TimeStamp) member of 'ResourceTimingStructArgs'");
return {};
}
auto maybe___responseStart = IPC::ReadParam<::mozilla::TimeStamp>(aReader);
if (!maybe___responseStart) {
aReader->FatalError("Error deserializing 'responseStart' (TimeStamp) member of 'ResourceTimingStructArgs'");
return {};
}
auto& _responseStart = *maybe___responseStart;
// Sentinel = 'responseStart'
if ((!((aReader)->ReadSentinel(648545662)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'responseStart' (TimeStamp) member of 'ResourceTimingStructArgs'");
return {};
}
auto maybe___responseEnd = IPC::ReadParam<::mozilla::TimeStamp>(aReader);
if (!maybe___responseEnd) {
aReader->FatalError("Error deserializing 'responseEnd' (TimeStamp) member of 'ResourceTimingStructArgs'");
return {};
}
auto& _responseEnd = *maybe___responseEnd;
// Sentinel = 'responseEnd'
if ((!((aReader)->ReadSentinel(468518023)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'responseEnd' (TimeStamp) member of 'ResourceTimingStructArgs'");
return {};
}
auto maybe___fetchStart = IPC::ReadParam<::mozilla::TimeStamp>(aReader);
if (!maybe___fetchStart) {
aReader->FatalError("Error deserializing 'fetchStart' (TimeStamp) member of 'ResourceTimingStructArgs'");
return {};
}
auto& _fetchStart = *maybe___fetchStart;
// Sentinel = 'fetchStart'
if ((!((aReader)->ReadSentinel(373425177)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'fetchStart' (TimeStamp) member of 'ResourceTimingStructArgs'");
return {};
}
auto maybe___redirectStart = IPC::ReadParam<::mozilla::TimeStamp>(aReader);
if (!maybe___redirectStart) {
aReader->FatalError("Error deserializing 'redirectStart' (TimeStamp) member of 'ResourceTimingStructArgs'");
return {};
}
auto& _redirectStart = *maybe___redirectStart;
// Sentinel = 'redirectStart'
if ((!((aReader)->ReadSentinel(628753761)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'redirectStart' (TimeStamp) member of 'ResourceTimingStructArgs'");
return {};
}
auto maybe___redirectEnd = IPC::ReadParam<::mozilla::TimeStamp>(aReader);
if (!maybe___redirectEnd) {
aReader->FatalError("Error deserializing 'redirectEnd' (TimeStamp) member of 'ResourceTimingStructArgs'");
return {};
}
auto& _redirectEnd = *maybe___redirectEnd;
// Sentinel = 'redirectEnd'
if ((!((aReader)->ReadSentinel(452527210)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'redirectEnd' (TimeStamp) member of 'ResourceTimingStructArgs'");
return {};
}
auto maybe___cacheReadStart = IPC::ReadParam<::mozilla::TimeStamp>(aReader);
if (!maybe___cacheReadStart) {
aReader->FatalError("Error deserializing 'cacheReadStart' (TimeStamp) member of 'ResourceTimingStructArgs'");
return {};
}
auto& _cacheReadStart = *maybe___cacheReadStart;
// Sentinel = 'cacheReadStart'
if ((!((aReader)->ReadSentinel(677774719)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'cacheReadStart' (TimeStamp) member of 'ResourceTimingStructArgs'");
return {};
}
auto maybe___cacheReadEnd = IPC::ReadParam<::mozilla::TimeStamp>(aReader);
if (!maybe___cacheReadEnd) {
aReader->FatalError("Error deserializing 'cacheReadEnd' (TimeStamp) member of 'ResourceTimingStructArgs'");
return {};
}
auto& _cacheReadEnd = *maybe___cacheReadEnd;
// Sentinel = 'cacheReadEnd'
if ((!((aReader)->ReadSentinel(497616008)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'cacheReadEnd' (TimeStamp) member of 'ResourceTimingStructArgs'");
return {};
}
auto maybe___transactionPending = IPC::ReadParam<::mozilla::TimeStamp>(aReader);
if (!maybe___transactionPending) {
aReader->FatalError("Error deserializing 'transactionPending' (TimeStamp) member of 'ResourceTimingStructArgs'");
return {};
}
auto& _transactionPending = *maybe___transactionPending;
// Sentinel = 'transactionPending'
if ((!((aReader)->ReadSentinel(1196951404)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'transactionPending' (TimeStamp) member of 'ResourceTimingStructArgs'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_domainLookupStart),
std::move(_domainLookupEnd),
std::move(_connectStart),
std::move(_tcpConnectEnd),
std::move(_secureConnectionStart),
std::move(_connectEnd),
std::move(_requestStart),
std::move(_responseStart),
std::move(_responseEnd),
std::move(_fetchStart),
std::move(_redirectStart),
std::move(_redirectEnd),
::uint64_t{0},
::uint64_t{0},
std::move(_cacheReadStart),
std::move(_cacheReadEnd),
std::move(_transactionPending)};
if ((!((aReader)->ReadBytesInto((&((result__)->transferSize())), 16)))) {
aReader->FatalError("Error bulk reading fields from uint64_t");
return {};
}
// Sentinel = 'transferSize | encodedBodySize'
if ((!((aReader)->ReadSentinel(3071019960)))) {
mozilla::ipc::SentinelReadError("Error bulk reading fields from uint64_t");
return {};
}
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct HttpActivity|
//
namespace mozilla {
namespace net {
} // namespace net
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::net::HttpActivity>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).host());
// Sentinel = 'host'
(aWriter)->WriteSentinel(72024511);
IPC::WriteParam(aWriter, (aVar).endToEndSSL());
// Sentinel = 'endToEndSSL'
(aWriter)->WriteSentinel(421135364);
(aWriter)->WriteBytes((&((aVar).port())), 4);
// Sentinel = 'port'
(aWriter)->WriteSentinel(73990598);
}
auto ParamTraits<::mozilla::net::HttpActivity>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___host = IPC::ReadParam<::nsCString>(aReader);
if (!maybe___host) {
aReader->FatalError("Error deserializing 'host' (nsCString) member of 'HttpActivity'");
return {};
}
auto& _host = *maybe___host;
// Sentinel = 'host'
if ((!((aReader)->ReadSentinel(72024511)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'host' (nsCString) member of 'HttpActivity'");
return {};
}
auto maybe___endToEndSSL = IPC::ReadParam<bool>(aReader);
if (!maybe___endToEndSSL) {
aReader->FatalError("Error deserializing 'endToEndSSL' (bool) member of 'HttpActivity'");
return {};
}
auto& _endToEndSSL = *maybe___endToEndSSL;
// Sentinel = 'endToEndSSL'
if ((!((aReader)->ReadSentinel(421135364)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'endToEndSSL' (bool) member of 'HttpActivity'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_host),
::int32_t{0},
std::move(_endToEndSSL)};
if ((!((aReader)->ReadBytesInto((&((result__)->port())), 4)))) {
aReader->FatalError("Error bulk reading fields from int32_t");
return {};
}
// Sentinel = 'port'
if ((!((aReader)->ReadSentinel(73990598)))) {
mozilla::ipc::SentinelReadError("Error bulk reading fields from int32_t");
return {};
}
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct HttpConnectionActivity|
//
namespace mozilla {
namespace net {
} // namespace net
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::net::HttpConnectionActivity>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).connInfoKey());
// Sentinel = 'connInfoKey'
(aWriter)->WriteSentinel(442565732);
IPC::WriteParam(aWriter, (aVar).host());
// Sentinel = 'host'
(aWriter)->WriteSentinel(72024511);
IPC::WriteParam(aWriter, (aVar).ssl());
// Sentinel = 'ssl'
(aWriter)->WriteSentinel(44958035);
IPC::WriteParam(aWriter, (aVar).hasECH());
// Sentinel = 'hasECH'
(aWriter)->WriteSentinel(130286093);
IPC::WriteParam(aWriter, (aVar).isHttp3());
// Sentinel = 'isHttp3'
(aWriter)->WriteSentinel(188678832);
(aWriter)->WriteBytes((&((aVar).port())), 4);
// Sentinel = 'port'
(aWriter)->WriteSentinel(73990598);
}
auto ParamTraits<::mozilla::net::HttpConnectionActivity>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___connInfoKey = IPC::ReadParam<::nsCString>(aReader);
if (!maybe___connInfoKey) {
aReader->FatalError("Error deserializing 'connInfoKey' (nsCString) member of 'HttpConnectionActivity'");
return {};
}
auto& _connInfoKey = *maybe___connInfoKey;
// Sentinel = 'connInfoKey'
if ((!((aReader)->ReadSentinel(442565732)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'connInfoKey' (nsCString) member of 'HttpConnectionActivity'");
return {};
}
auto maybe___host = IPC::ReadParam<::nsCString>(aReader);
if (!maybe___host) {
aReader->FatalError("Error deserializing 'host' (nsCString) member of 'HttpConnectionActivity'");
return {};
}
auto& _host = *maybe___host;
// Sentinel = 'host'
if ((!((aReader)->ReadSentinel(72024511)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'host' (nsCString) member of 'HttpConnectionActivity'");
return {};
}
auto maybe___ssl = IPC::ReadParam<bool>(aReader);
if (!maybe___ssl) {
aReader->FatalError("Error deserializing 'ssl' (bool) member of 'HttpConnectionActivity'");
return {};
}
auto& _ssl = *maybe___ssl;
// Sentinel = 'ssl'
if ((!((aReader)->ReadSentinel(44958035)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ssl' (bool) member of 'HttpConnectionActivity'");
return {};
}
auto maybe___hasECH = IPC::ReadParam<bool>(aReader);
if (!maybe___hasECH) {
aReader->FatalError("Error deserializing 'hasECH' (bool) member of 'HttpConnectionActivity'");
return {};
}
auto& _hasECH = *maybe___hasECH;
// Sentinel = 'hasECH'
if ((!((aReader)->ReadSentinel(130286093)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'hasECH' (bool) member of 'HttpConnectionActivity'");
return {};
}
auto maybe___isHttp3 = IPC::ReadParam<bool>(aReader);
if (!maybe___isHttp3) {
aReader->FatalError("Error deserializing 'isHttp3' (bool) member of 'HttpConnectionActivity'");
return {};
}
auto& _isHttp3 = *maybe___isHttp3;
// Sentinel = 'isHttp3'
if ((!((aReader)->ReadSentinel(188678832)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'isHttp3' (bool) member of 'HttpConnectionActivity'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_connInfoKey),
std::move(_host),
::int32_t{0},
std::move(_ssl),
std::move(_hasECH),
std::move(_isHttp3)};
if ((!((aReader)->ReadBytesInto((&((result__)->port())), 4)))) {
aReader->FatalError("Error bulk reading fields from int32_t");
return {};
}
// Sentinel = 'port'
if ((!((aReader)->ReadSentinel(73990598)))) {
mozilla::ipc::SentinelReadError("Error bulk reading fields from int32_t");
return {};
}
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |union HttpActivityArgs|
//
namespace mozilla {
namespace net {
auto HttpActivityArgs::MaybeDestroy() -> void
{
if ((mType) == (T__None)) {
return;
}
switch (mType) {
case Tuint64_t:
{
(ptr_uint64_t())->~uint64_t__tdef();
break;
}
case THttpActivity:
{
(ptr_HttpActivity())->~HttpActivity__tdef();
break;
}
case THttpConnectionActivity:
{
(ptr_HttpConnectionActivity())->~HttpConnectionActivity__tdef();
break;
}
default:
{
mozilla::ipc::LogicError("not reached");
break;
}
}
}
MOZ_IMPLICIT HttpActivityArgs::HttpActivityArgs(const uint64_t& aOther)
{
new (mozilla::KnownNotNull, ptr_uint64_t()) uint64_t(aOther);
mType = Tuint64_t;
}
MOZ_IMPLICIT HttpActivityArgs::HttpActivityArgs(uint64_t&& aOther)
{
new (mozilla::KnownNotNull, ptr_uint64_t()) uint64_t(std::move(aOther));
mType = Tuint64_t;
}
MOZ_IMPLICIT HttpActivityArgs::HttpActivityArgs(const HttpActivity& aOther)
{
new (mozilla::KnownNotNull, ptr_HttpActivity()) HttpActivity(aOther);
mType = THttpActivity;
}
MOZ_IMPLICIT HttpActivityArgs::HttpActivityArgs(HttpActivity&& aOther)
{
new (mozilla::KnownNotNull, ptr_HttpActivity()) HttpActivity(std::move(aOther));
mType = THttpActivity;
}
MOZ_IMPLICIT HttpActivityArgs::HttpActivityArgs(const HttpConnectionActivity& aOther)
{
new (mozilla::KnownNotNull, ptr_HttpConnectionActivity()) HttpConnectionActivity(aOther);
mType = THttpConnectionActivity;
}
MOZ_IMPLICIT HttpActivityArgs::HttpActivityArgs(HttpConnectionActivity&& aOther)
{
new (mozilla::KnownNotNull, ptr_HttpConnectionActivity()) HttpConnectionActivity(std::move(aOther));
mType = THttpConnectionActivity;
}
MOZ_IMPLICIT HttpActivityArgs::HttpActivityArgs(const HttpActivityArgs& aOther)
{
(aOther).AssertSanity();
switch ((aOther).type()) {
case Tuint64_t:
{
new (mozilla::KnownNotNull, ptr_uint64_t()) uint64_t((aOther).get_uint64_t());
break;
}
case THttpActivity:
{
new (mozilla::KnownNotNull, ptr_HttpActivity()) HttpActivity((aOther).get_HttpActivity());
break;
}
case THttpConnectionActivity:
{
new (mozilla::KnownNotNull, ptr_HttpConnectionActivity()) HttpConnectionActivity((aOther).get_HttpConnectionActivity());
break;
}
case T__None:
{
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
return;
}
}
mType = (aOther).type();
}
MOZ_IMPLICIT HttpActivityArgs::HttpActivityArgs(HttpActivityArgs&& aOther)
{
(aOther).AssertSanity();
Type t = (aOther).type();
switch (t) {
case Tuint64_t:
{
new (mozilla::KnownNotNull, ptr_uint64_t()) uint64_t(std::move((aOther).get_uint64_t()));
(aOther).MaybeDestroy();
break;
}
case THttpActivity:
{
new (mozilla::KnownNotNull, ptr_HttpActivity()) HttpActivity(std::move((aOther).get_HttpActivity()));
(aOther).MaybeDestroy();
break;
}
case THttpConnectionActivity:
{
new (mozilla::KnownNotNull, ptr_HttpConnectionActivity()) HttpConnectionActivity(std::move((aOther).get_HttpConnectionActivity()));
(aOther).MaybeDestroy();
break;
}
case T__None:
{
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
return;
}
}
(aOther).mType = T__None;
mType = t;
}
HttpActivityArgs::~HttpActivityArgs()
{
MaybeDestroy();
}
auto HttpActivityArgs::operator=(const uint64_t& aRhs) -> HttpActivityArgs&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_uint64_t()) uint64_t(aRhs);
mType = Tuint64_t;
return (*(this));
}
auto HttpActivityArgs::operator=(uint64_t&& aRhs) -> HttpActivityArgs&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_uint64_t()) uint64_t(std::move(aRhs));
mType = Tuint64_t;
return (*(this));
}
auto HttpActivityArgs::operator=(const HttpActivity& aRhs) -> HttpActivityArgs&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_HttpActivity()) HttpActivity(aRhs);
mType = THttpActivity;
return (*(this));
}
auto HttpActivityArgs::operator=(HttpActivity&& aRhs) -> HttpActivityArgs&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_HttpActivity()) HttpActivity(std::move(aRhs));
mType = THttpActivity;
return (*(this));
}
auto HttpActivityArgs::operator=(const HttpConnectionActivity& aRhs) -> HttpActivityArgs&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_HttpConnectionActivity()) HttpConnectionActivity(aRhs);
mType = THttpConnectionActivity;
return (*(this));
}
auto HttpActivityArgs::operator=(HttpConnectionActivity&& aRhs) -> HttpActivityArgs&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_HttpConnectionActivity()) HttpConnectionActivity(std::move(aRhs));
mType = THttpConnectionActivity;
return (*(this));
}
auto HttpActivityArgs::operator=(const HttpActivityArgs& aRhs) -> HttpActivityArgs&
{
(aRhs).AssertSanity();
Type t = (aRhs).type();
switch (t) {
case Tuint64_t:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_uint64_t()) uint64_t((aRhs).get_uint64_t());
break;
}
case THttpActivity:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_HttpActivity()) HttpActivity((aRhs).get_HttpActivity());
break;
}
case THttpConnectionActivity:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_HttpConnectionActivity()) HttpConnectionActivity((aRhs).get_HttpConnectionActivity());
break;
}
case T__None:
{
MaybeDestroy();
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
break;
}
}
mType = t;
return (*(this));
}
auto HttpActivityArgs::operator=(HttpActivityArgs&& aRhs) -> HttpActivityArgs&
{
(aRhs).AssertSanity();
Type t = (aRhs).type();
switch (t) {
case Tuint64_t:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_uint64_t()) uint64_t(std::move((aRhs).get_uint64_t()));
(aRhs).MaybeDestroy();
break;
}
case THttpActivity:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_HttpActivity()) HttpActivity(std::move((aRhs).get_HttpActivity()));
(aRhs).MaybeDestroy();
break;
}
case THttpConnectionActivity:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_HttpConnectionActivity()) HttpConnectionActivity(std::move((aRhs).get_HttpConnectionActivity()));
(aRhs).MaybeDestroy();
break;
}
case T__None:
{
MaybeDestroy();
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
break;
}
}
(aRhs).mType = T__None;
mType = t;
return (*(this));
}
} // namespace net
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::net::HttpActivityArgs>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
typedef ::mozilla::net::HttpActivityArgs union__;
int type = (aVar).type();
IPC::WriteParam(aWriter, type);
// Sentinel = 'HttpActivityArgs'
(aWriter)->WriteSentinel(908658299);
switch (type) {
case union__::Tuint64_t:
{
IPC::WriteParam(aWriter, (aVar).get_uint64_t());
// Sentinel = 'Tuint64_t'
(aWriter)->WriteSentinel(285344594);
return;
}
case union__::THttpActivity:
{
IPC::WriteParam(aWriter, (aVar).get_HttpActivity());
// Sentinel = 'THttpActivity'
(aWriter)->WriteSentinel(588973378);
return;
}
case union__::THttpConnectionActivity:
{
IPC::WriteParam(aWriter, (aVar).get_HttpConnectionActivity());
// Sentinel = 'THttpConnectionActivity'
(aWriter)->WriteSentinel(1825048914);
return;
}
default:
{
aWriter->FatalError("unknown variant of union HttpActivityArgs");
return;
}
}
}
auto ParamTraits<::mozilla::net::HttpActivityArgs>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
typedef ::mozilla::net::HttpActivityArgs union__;
auto maybe__type = IPC::ReadParam<int>(aReader);
if (!maybe__type) {
aReader->FatalError("Error deserializing type of union HttpActivityArgs");
return {};
}
auto& type = *maybe__type;
// Sentinel = 'HttpActivityArgs'
if ((!((aReader)->ReadSentinel(908658299)))) {
mozilla::ipc::SentinelReadError("Error deserializing type of union HttpActivityArgs");
return {};
}
switch (type) {
case union__::Tuint64_t:
{
auto maybe__tmp = IPC::ReadParam<::uint64_t>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant Tuint64_t of union HttpActivityArgs");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'Tuint64_t'
if ((!((aReader)->ReadSentinel(285344594)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant Tuint64_t of union HttpActivityArgs");
return {};
}
return std::move(tmp);
}
case union__::THttpActivity:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::net::HttpActivity>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant THttpActivity of union HttpActivityArgs");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'THttpActivity'
if ((!((aReader)->ReadSentinel(588973378)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant THttpActivity of union HttpActivityArgs");
return {};
}
return std::move(tmp);
}
case union__::THttpConnectionActivity:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::net::HttpConnectionActivity>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant THttpConnectionActivity of union HttpActivityArgs");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'THttpConnectionActivity'
if ((!((aReader)->ReadSentinel(1825048914)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant THttpConnectionActivity of union HttpActivityArgs");
return {};
}
return std::move(tmp);
}
default:
{
aReader->FatalError("unknown variant of union HttpActivityArgs");
return {};
}
}
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct TransactionObserverResult|
//
namespace mozilla {
namespace net {
} // namespace net
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::net::TransactionObserverResult>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).versionOk());
// Sentinel = 'versionOk'
(aWriter)->WriteSentinel(323158977);
IPC::WriteParam(aWriter, (aVar).authOk());
// Sentinel = 'authOk'
(aWriter)->WriteSentinel(145097325);
IPC::WriteParam(aWriter, (aVar).closeReason());
// Sentinel = 'closeReason'
(aWriter)->WriteSentinel(450102399);
}
auto ParamTraits<::mozilla::net::TransactionObserverResult>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___versionOk = IPC::ReadParam<bool>(aReader);
if (!maybe___versionOk) {
aReader->FatalError("Error deserializing 'versionOk' (bool) member of 'TransactionObserverResult'");
return {};
}
auto& _versionOk = *maybe___versionOk;
// Sentinel = 'versionOk'
if ((!((aReader)->ReadSentinel(323158977)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'versionOk' (bool) member of 'TransactionObserverResult'");
return {};
}
auto maybe___authOk = IPC::ReadParam<bool>(aReader);
if (!maybe___authOk) {
aReader->FatalError("Error deserializing 'authOk' (bool) member of 'TransactionObserverResult'");
return {};
}
auto& _authOk = *maybe___authOk;
// Sentinel = 'authOk'
if ((!((aReader)->ReadSentinel(145097325)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'authOk' (bool) member of 'TransactionObserverResult'");
return {};
}
auto maybe___closeReason = IPC::ReadParam<::nsresult>(aReader);
if (!maybe___closeReason) {
aReader->FatalError("Error deserializing 'closeReason' (nsresult) member of 'TransactionObserverResult'");
return {};
}
auto& _closeReason = *maybe___closeReason;
// Sentinel = 'closeReason'
if ((!((aReader)->ReadSentinel(450102399)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'closeReason' (nsresult) member of 'TransactionObserverResult'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_versionOk),
std::move(_authOk),
std::move(_closeReason)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct SpeculativeConnectionOverriderArgs|
//
namespace mozilla {
namespace net {
} // namespace net
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::net::SpeculativeConnectionOverriderArgs>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).ignoreIdle());
// Sentinel = 'ignoreIdle'
(aWriter)->WriteSentinel(376308739);
IPC::WriteParam(aWriter, (aVar).isFromPredictor());
// Sentinel = 'isFromPredictor'
(aWriter)->WriteSentinel(808257053);
IPC::WriteParam(aWriter, (aVar).allow1918());
// Sentinel = 'allow1918'
(aWriter)->WriteSentinel(280756979);
(aWriter)->WriteBytes((&((aVar).parallelSpeculativeConnectLimit())), 4);
// Sentinel = 'parallelSpeculativeConnectLimit'
(aWriter)->WriteSentinel(3389983900);
}
auto ParamTraits<::mozilla::net::SpeculativeConnectionOverriderArgs>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___ignoreIdle = IPC::ReadParam<bool>(aReader);
if (!maybe___ignoreIdle) {
aReader->FatalError("Error deserializing 'ignoreIdle' (bool) member of 'SpeculativeConnectionOverriderArgs'");
return {};
}
auto& _ignoreIdle = *maybe___ignoreIdle;
// Sentinel = 'ignoreIdle'
if ((!((aReader)->ReadSentinel(376308739)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ignoreIdle' (bool) member of 'SpeculativeConnectionOverriderArgs'");
return {};
}
auto maybe___isFromPredictor = IPC::ReadParam<bool>(aReader);
if (!maybe___isFromPredictor) {
aReader->FatalError("Error deserializing 'isFromPredictor' (bool) member of 'SpeculativeConnectionOverriderArgs'");
return {};
}
auto& _isFromPredictor = *maybe___isFromPredictor;
// Sentinel = 'isFromPredictor'
if ((!((aReader)->ReadSentinel(808257053)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'isFromPredictor' (bool) member of 'SpeculativeConnectionOverriderArgs'");
return {};
}
auto maybe___allow1918 = IPC::ReadParam<bool>(aReader);
if (!maybe___allow1918) {
aReader->FatalError("Error deserializing 'allow1918' (bool) member of 'SpeculativeConnectionOverriderArgs'");
return {};
}
auto& _allow1918 = *maybe___allow1918;
// Sentinel = 'allow1918'
if ((!((aReader)->ReadSentinel(280756979)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'allow1918' (bool) member of 'SpeculativeConnectionOverriderArgs'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
::uint32_t{0},
std::move(_ignoreIdle),
std::move(_isFromPredictor),
std::move(_allow1918)};
if ((!((aReader)->ReadBytesInto((&((result__)->parallelSpeculativeConnectLimit())), 4)))) {
aReader->FatalError("Error bulk reading fields from uint32_t");
return {};
}
// Sentinel = 'parallelSpeculativeConnectLimit'
if ((!((aReader)->ReadSentinel(3389983900)))) {
mozilla::ipc::SentinelReadError("Error bulk reading fields from uint32_t");
return {};
}
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct GIOChannelOpenArgs|
//
namespace mozilla {
namespace net {
} // namespace net
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::net::GIOChannelOpenArgs>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).uri());
// Sentinel = 'uri'
(aWriter)->WriteSentinel(45023569);
IPC::WriteParam(aWriter, (aVar).entityID());
// Sentinel = 'entityID'
(aWriter)->WriteSentinel(252183339);
IPC::WriteParam(aWriter, (aVar).uploadStream());
// Sentinel = 'uploadStream'
(aWriter)->WriteSentinel(546768114);
IPC::WriteParam(aWriter, (aVar).loadInfo());
// Sentinel = 'loadInfo'
(aWriter)->WriteSentinel(240386861);
(aWriter)->WriteBytes((&((aVar).startPos())), 8);
// Sentinel = 'startPos'
(aWriter)->WriteSentinel(257753953);
(aWriter)->WriteBytes((&((aVar).loadFlags())), 4);
// Sentinel = 'loadFlags'
(aWriter)->WriteSentinel(297665422);
}
auto ParamTraits<::mozilla::net::GIOChannelOpenArgs>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___uri = IPC::ReadParam<::mozilla::ipc::URIParams>(aReader);
if (!maybe___uri) {
aReader->FatalError("Error deserializing 'uri' (URIParams) member of 'GIOChannelOpenArgs'");
return {};
}
auto& _uri = *maybe___uri;
// Sentinel = 'uri'
if ((!((aReader)->ReadSentinel(45023569)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uri' (URIParams) member of 'GIOChannelOpenArgs'");
return {};
}
auto maybe___entityID = IPC::ReadParam<::nsCString>(aReader);
if (!maybe___entityID) {
aReader->FatalError("Error deserializing 'entityID' (nsCString) member of 'GIOChannelOpenArgs'");
return {};
}
auto& _entityID = *maybe___entityID;
// Sentinel = 'entityID'
if ((!((aReader)->ReadSentinel(252183339)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'entityID' (nsCString) member of 'GIOChannelOpenArgs'");
return {};
}
auto maybe___uploadStream = IPC::ReadParam<mozilla::Maybe<::mozilla::ipc::IPCStream>>(aReader);
if (!maybe___uploadStream) {
aReader->FatalError("Error deserializing 'uploadStream' (IPCStream?) member of 'GIOChannelOpenArgs'");
return {};
}
auto& _uploadStream = *maybe___uploadStream;
// Sentinel = 'uploadStream'
if ((!((aReader)->ReadSentinel(546768114)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uploadStream' (IPCStream?) member of 'GIOChannelOpenArgs'");
return {};
}
auto maybe___loadInfo = IPC::ReadParam<::mozilla::net::LoadInfoArgs>(aReader);
if (!maybe___loadInfo) {
aReader->FatalError("Error deserializing 'loadInfo' (LoadInfoArgs) member of 'GIOChannelOpenArgs'");
return {};
}
auto& _loadInfo = *maybe___loadInfo;
// Sentinel = 'loadInfo'
if ((!((aReader)->ReadSentinel(240386861)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'loadInfo' (LoadInfoArgs) member of 'GIOChannelOpenArgs'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_uri),
::uint64_t{0},
std::move(_entityID),
std::move(_uploadStream),
std::move(_loadInfo),
::uint32_t{0}};
if ((!((aReader)->ReadBytesInto((&((result__)->startPos())), 8)))) {
aReader->FatalError("Error bulk reading fields from uint64_t");
return {};
}
// Sentinel = 'startPos'
if ((!((aReader)->ReadSentinel(257753953)))) {
mozilla::ipc::SentinelReadError("Error bulk reading fields from uint64_t");
return {};
}
if ((!((aReader)->ReadBytesInto((&((result__)->loadFlags())), 4)))) {
aReader->FatalError("Error bulk reading fields from uint32_t");
return {};
}
// Sentinel = 'loadFlags'
if ((!((aReader)->ReadSentinel(297665422)))) {
mozilla::ipc::SentinelReadError("Error bulk reading fields from uint32_t");
return {};
}
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct GIOChannelConnectArgs|
//
namespace mozilla {
namespace net {
} // namespace net
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::net::GIOChannelConnectArgs>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
(aWriter)->WriteBytes((&((aVar).channelId())), 4);
// Sentinel = 'channelId'
(aWriter)->WriteSentinel(301138823);
}
auto ParamTraits<::mozilla::net::GIOChannelConnectArgs>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
IPC::ReadResult<paramType> result__{
std::in_place,
::uint32_t{0}};
if ((!((aReader)->ReadBytesInto((&((result__)->channelId())), 4)))) {
aReader->FatalError("Error bulk reading fields from uint32_t");
return {};
}
// Sentinel = 'channelId'
if ((!((aReader)->ReadSentinel(301138823)))) {
mozilla::ipc::SentinelReadError("Error bulk reading fields from uint32_t");
return {};
}
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |union GIOChannelCreationArgs|
//
namespace mozilla {
namespace net {
auto GIOChannelCreationArgs::MaybeDestroy() -> void
{
if ((mType) == (T__None)) {
return;
}
switch (mType) {
case TGIOChannelOpenArgs:
{
(ptr_GIOChannelOpenArgs())->~GIOChannelOpenArgs__tdef();
break;
}
case TGIOChannelConnectArgs:
{
(ptr_GIOChannelConnectArgs())->~GIOChannelConnectArgs__tdef();
break;
}
default:
{
mozilla::ipc::LogicError("not reached");
break;
}
}
}
MOZ_IMPLICIT GIOChannelCreationArgs::GIOChannelCreationArgs(const GIOChannelOpenArgs& aOther)
{
new (mozilla::KnownNotNull, ptr_GIOChannelOpenArgs()) GIOChannelOpenArgs(aOther);
mType = TGIOChannelOpenArgs;
}
MOZ_IMPLICIT GIOChannelCreationArgs::GIOChannelCreationArgs(GIOChannelOpenArgs&& aOther)
{
new (mozilla::KnownNotNull, ptr_GIOChannelOpenArgs()) GIOChannelOpenArgs(std::move(aOther));
mType = TGIOChannelOpenArgs;
}
MOZ_IMPLICIT GIOChannelCreationArgs::GIOChannelCreationArgs(const GIOChannelConnectArgs& aOther)
{
new (mozilla::KnownNotNull, ptr_GIOChannelConnectArgs()) GIOChannelConnectArgs(aOther);
mType = TGIOChannelConnectArgs;
}
MOZ_IMPLICIT GIOChannelCreationArgs::GIOChannelCreationArgs(GIOChannelConnectArgs&& aOther)
{
new (mozilla::KnownNotNull, ptr_GIOChannelConnectArgs()) GIOChannelConnectArgs(std::move(aOther));
mType = TGIOChannelConnectArgs;
}
MOZ_IMPLICIT GIOChannelCreationArgs::GIOChannelCreationArgs(const GIOChannelCreationArgs& aOther)
{
(aOther).AssertSanity();
switch ((aOther).type()) {
case TGIOChannelOpenArgs:
{
new (mozilla::KnownNotNull, ptr_GIOChannelOpenArgs()) GIOChannelOpenArgs((aOther).get_GIOChannelOpenArgs());
break;
}
case TGIOChannelConnectArgs:
{
new (mozilla::KnownNotNull, ptr_GIOChannelConnectArgs()) GIOChannelConnectArgs((aOther).get_GIOChannelConnectArgs());
break;
}
case T__None:
{
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
return;
}
}
mType = (aOther).type();
}
MOZ_IMPLICIT GIOChannelCreationArgs::GIOChannelCreationArgs(GIOChannelCreationArgs&& aOther)
{
(aOther).AssertSanity();
Type t = (aOther).type();
switch (t) {
case TGIOChannelOpenArgs:
{
new (mozilla::KnownNotNull, ptr_GIOChannelOpenArgs()) GIOChannelOpenArgs(std::move((aOther).get_GIOChannelOpenArgs()));
(aOther).MaybeDestroy();
break;
}
case TGIOChannelConnectArgs:
{
new (mozilla::KnownNotNull, ptr_GIOChannelConnectArgs()) GIOChannelConnectArgs(std::move((aOther).get_GIOChannelConnectArgs()));
(aOther).MaybeDestroy();
break;
}
case T__None:
{
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
return;
}
}
(aOther).mType = T__None;
mType = t;
}
GIOChannelCreationArgs::~GIOChannelCreationArgs()
{
MaybeDestroy();
}
auto GIOChannelCreationArgs::operator=(const GIOChannelOpenArgs& aRhs) -> GIOChannelCreationArgs&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_GIOChannelOpenArgs()) GIOChannelOpenArgs(aRhs);
mType = TGIOChannelOpenArgs;
return (*(this));
}
auto GIOChannelCreationArgs::operator=(GIOChannelOpenArgs&& aRhs) -> GIOChannelCreationArgs&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_GIOChannelOpenArgs()) GIOChannelOpenArgs(std::move(aRhs));
mType = TGIOChannelOpenArgs;
return (*(this));
}
auto GIOChannelCreationArgs::operator=(const GIOChannelConnectArgs& aRhs) -> GIOChannelCreationArgs&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_GIOChannelConnectArgs()) GIOChannelConnectArgs(aRhs);
mType = TGIOChannelConnectArgs;
return (*(this));
}
auto GIOChannelCreationArgs::operator=(GIOChannelConnectArgs&& aRhs) -> GIOChannelCreationArgs&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_GIOChannelConnectArgs()) GIOChannelConnectArgs(std::move(aRhs));
mType = TGIOChannelConnectArgs;
return (*(this));
}
auto GIOChannelCreationArgs::operator=(const GIOChannelCreationArgs& aRhs) -> GIOChannelCreationArgs&
{
(aRhs).AssertSanity();
Type t = (aRhs).type();
switch (t) {
case TGIOChannelOpenArgs:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_GIOChannelOpenArgs()) GIOChannelOpenArgs((aRhs).get_GIOChannelOpenArgs());
break;
}
case TGIOChannelConnectArgs:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_GIOChannelConnectArgs()) GIOChannelConnectArgs((aRhs).get_GIOChannelConnectArgs());
break;
}
case T__None:
{
MaybeDestroy();
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
break;
}
}
mType = t;
return (*(this));
}
auto GIOChannelCreationArgs::operator=(GIOChannelCreationArgs&& aRhs) -> GIOChannelCreationArgs&
{
(aRhs).AssertSanity();
Type t = (aRhs).type();
switch (t) {
case TGIOChannelOpenArgs:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_GIOChannelOpenArgs()) GIOChannelOpenArgs(std::move((aRhs).get_GIOChannelOpenArgs()));
(aRhs).MaybeDestroy();
break;
}
case TGIOChannelConnectArgs:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_GIOChannelConnectArgs()) GIOChannelConnectArgs(std::move((aRhs).get_GIOChannelConnectArgs()));
(aRhs).MaybeDestroy();
break;
}
case T__None:
{
MaybeDestroy();
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
break;
}
}
(aRhs).mType = T__None;
mType = t;
return (*(this));
}
} // namespace net
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::net::GIOChannelCreationArgs>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
typedef ::mozilla::net::GIOChannelCreationArgs union__;
int type = (aVar).type();
IPC::WriteParam(aWriter, type);
// Sentinel = 'GIOChannelCreationArgs'
(aWriter)->WriteSentinel(1537607771);
switch (type) {
case union__::TGIOChannelOpenArgs:
{
IPC::WriteParam(aWriter, (aVar).get_GIOChannelOpenArgs());
// Sentinel = 'TGIOChannelOpenArgs'
(aWriter)->WriteSentinel(1122436876);
return;
}
case union__::TGIOChannelConnectArgs:
{
IPC::WriteParam(aWriter, (aVar).get_GIOChannelConnectArgs());
// Sentinel = 'TGIOChannelConnectArgs'
(aWriter)->WriteSentinel(1518340164);
return;
}
default:
{
aWriter->FatalError("unknown variant of union GIOChannelCreationArgs");
return;
}
}
}
auto ParamTraits<::mozilla::net::GIOChannelCreationArgs>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
typedef ::mozilla::net::GIOChannelCreationArgs union__;
auto maybe__type = IPC::ReadParam<int>(aReader);
if (!maybe__type) {
aReader->FatalError("Error deserializing type of union GIOChannelCreationArgs");
return {};
}
auto& type = *maybe__type;
// Sentinel = 'GIOChannelCreationArgs'
if ((!((aReader)->ReadSentinel(1537607771)))) {
mozilla::ipc::SentinelReadError("Error deserializing type of union GIOChannelCreationArgs");
return {};
}
switch (type) {
case union__::TGIOChannelOpenArgs:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::net::GIOChannelOpenArgs>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TGIOChannelOpenArgs of union GIOChannelCreationArgs");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TGIOChannelOpenArgs'
if ((!((aReader)->ReadSentinel(1122436876)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TGIOChannelOpenArgs of union GIOChannelCreationArgs");
return {};
}
return std::move(tmp);
}
case union__::TGIOChannelConnectArgs:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::net::GIOChannelConnectArgs>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TGIOChannelConnectArgs of union GIOChannelCreationArgs");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TGIOChannelConnectArgs'
if ((!((aReader)->ReadSentinel(1518340164)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TGIOChannelConnectArgs of union GIOChannelCreationArgs");
return {};
}
return std::move(tmp);
}
default:
{
aReader->FatalError("unknown variant of union GIOChannelCreationArgs");
return {};
}
}
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct DataChannelInfo|
//
namespace mozilla {
namespace net {
} // namespace net
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::net::DataChannelInfo>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).uri());
// Sentinel = 'uri'
(aWriter)->WriteSentinel(45023569);
IPC::WriteParam(aWriter, (aVar).loadInfo());
// Sentinel = 'loadInfo'
(aWriter)->WriteSentinel(240386861);
IPC::WriteParam(aWriter, (aVar).contentType());
// Sentinel = 'contentType'
(aWriter)->WriteSentinel(465241246);
(aWriter)->WriteBytes((&((aVar).channelId())), 8);
// Sentinel = 'channelId'
(aWriter)->WriteSentinel(301138823);
(aWriter)->WriteBytes((&((aVar).loadFlags())), 4);
// Sentinel = 'loadFlags'
(aWriter)->WriteSentinel(297665422);
}
auto ParamTraits<::mozilla::net::DataChannelInfo>::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 'DataChannelInfo'");
return {};
}
auto& _uri = *maybe___uri;
// Sentinel = 'uri'
if ((!((aReader)->ReadSentinel(45023569)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uri' (nsIURI) member of 'DataChannelInfo'");
return {};
}
auto maybe___loadInfo = IPC::ReadParam<::mozilla::net::LoadInfoArgs>(aReader);
if (!maybe___loadInfo) {
aReader->FatalError("Error deserializing 'loadInfo' (LoadInfoArgs) member of 'DataChannelInfo'");
return {};
}
auto& _loadInfo = *maybe___loadInfo;
// Sentinel = 'loadInfo'
if ((!((aReader)->ReadSentinel(240386861)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'loadInfo' (LoadInfoArgs) member of 'DataChannelInfo'");
return {};
}
auto maybe___contentType = IPC::ReadParam<::nsCString>(aReader);
if (!maybe___contentType) {
aReader->FatalError("Error deserializing 'contentType' (nsCString) member of 'DataChannelInfo'");
return {};
}
auto& _contentType = *maybe___contentType;
// Sentinel = 'contentType'
if ((!((aReader)->ReadSentinel(465241246)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'contentType' (nsCString) member of 'DataChannelInfo'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_uri),
::uint32_t{0},
std::move(_loadInfo),
std::move(_contentType),
::uint64_t{0}};
if ((!((aReader)->ReadBytesInto((&((result__)->channelId())), 8)))) {
aReader->FatalError("Error bulk reading fields from uint64_t");
return {};
}
// Sentinel = 'channelId'
if ((!((aReader)->ReadSentinel(301138823)))) {
mozilla::ipc::SentinelReadError("Error bulk reading fields from uint64_t");
return {};
}
if ((!((aReader)->ReadBytesInto((&((result__)->loadFlags())), 4)))) {
aReader->FatalError("Error bulk reading fields from uint32_t");
return {};
}
// Sentinel = 'loadFlags'
if ((!((aReader)->ReadSentinel(297665422)))) {
mozilla::ipc::SentinelReadError("Error bulk reading fields from uint32_t");
return {};
}
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct FileChannelInfo|
//
namespace mozilla {
namespace net {
} // namespace net
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::net::FileChannelInfo>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).uri());
// Sentinel = 'uri'
(aWriter)->WriteSentinel(45023569);
IPC::WriteParam(aWriter, (aVar).originalURI());
// Sentinel = 'originalURI'
(aWriter)->WriteSentinel(455148614);
IPC::WriteParam(aWriter, (aVar).loadInfo());
// Sentinel = 'loadInfo'
(aWriter)->WriteSentinel(240386861);
IPC::WriteParam(aWriter, (aVar).contentType());
// Sentinel = 'contentType'
(aWriter)->WriteSentinel(465241246);
(aWriter)->WriteBytes((&((aVar).channelId())), 8);
// Sentinel = 'channelId'
(aWriter)->WriteSentinel(301138823);
(aWriter)->WriteBytes((&((aVar).loadFlags())), 4);
// Sentinel = 'loadFlags'
(aWriter)->WriteSentinel(297665422);
}
auto ParamTraits<::mozilla::net::FileChannelInfo>::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 'FileChannelInfo'");
return {};
}
auto& _uri = *maybe___uri;
// Sentinel = 'uri'
if ((!((aReader)->ReadSentinel(45023569)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uri' (nsIURI) member of 'FileChannelInfo'");
return {};
}
auto maybe___originalURI = IPC::ReadParam<RefPtr<::nsIURI>>(aReader);
if (!maybe___originalURI) {
aReader->FatalError("Error deserializing 'originalURI' (nsIURI) member of 'FileChannelInfo'");
return {};
}
auto& _originalURI = *maybe___originalURI;
// Sentinel = 'originalURI'
if ((!((aReader)->ReadSentinel(455148614)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'originalURI' (nsIURI) member of 'FileChannelInfo'");
return {};
}
auto maybe___loadInfo = IPC::ReadParam<::mozilla::net::LoadInfoArgs>(aReader);
if (!maybe___loadInfo) {
aReader->FatalError("Error deserializing 'loadInfo' (LoadInfoArgs) member of 'FileChannelInfo'");
return {};
}
auto& _loadInfo = *maybe___loadInfo;
// Sentinel = 'loadInfo'
if ((!((aReader)->ReadSentinel(240386861)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'loadInfo' (LoadInfoArgs) member of 'FileChannelInfo'");
return {};
}
auto maybe___contentType = IPC::ReadParam<::nsCString>(aReader);
if (!maybe___contentType) {
aReader->FatalError("Error deserializing 'contentType' (nsCString) member of 'FileChannelInfo'");
return {};
}
auto& _contentType = *maybe___contentType;
// Sentinel = 'contentType'
if ((!((aReader)->ReadSentinel(465241246)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'contentType' (nsCString) member of 'FileChannelInfo'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_uri),
std::move(_originalURI),
::uint32_t{0},
std::move(_loadInfo),
std::move(_contentType),
::uint64_t{0}};
if ((!((aReader)->ReadBytesInto((&((result__)->channelId())), 8)))) {
aReader->FatalError("Error bulk reading fields from uint64_t");
return {};
}
// Sentinel = 'channelId'
if ((!((aReader)->ReadSentinel(301138823)))) {
mozilla::ipc::SentinelReadError("Error bulk reading fields from uint64_t");
return {};
}
if ((!((aReader)->ReadBytesInto((&((result__)->loadFlags())), 4)))) {
aReader->FatalError("Error bulk reading fields from uint32_t");
return {};
}
// Sentinel = 'loadFlags'
if ((!((aReader)->ReadSentinel(297665422)))) {
mozilla::ipc::SentinelReadError("Error bulk reading fields from uint32_t");
return {};
}
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct RemoteStreamInfo|
//
namespace mozilla {
namespace net {
} // namespace net
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::net::RemoteStreamInfo>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).inputStream());
// Sentinel = 'inputStream'
(aWriter)->WriteSentinel(469370013);
IPC::WriteParam(aWriter, (aVar).contentType());
// Sentinel = 'contentType'
(aWriter)->WriteSentinel(465241246);
(aWriter)->WriteBytes((&((aVar).contentLength())), 8);
// Sentinel = 'contentLength'
(aWriter)->WriteSentinel(632358238);
}
auto ParamTraits<::mozilla::net::RemoteStreamInfo>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___inputStream = IPC::ReadParam<RefPtr<::nsIInputStream>>(aReader);
if (!maybe___inputStream) {
aReader->FatalError("Error deserializing 'inputStream' (nsIInputStream) member of 'RemoteStreamInfo'");
return {};
}
auto& _inputStream = *maybe___inputStream;
// Sentinel = 'inputStream'
if ((!((aReader)->ReadSentinel(469370013)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'inputStream' (nsIInputStream) member of 'RemoteStreamInfo'");
return {};
}
auto maybe___contentType = IPC::ReadParam<::nsCString>(aReader);
if (!maybe___contentType) {
aReader->FatalError("Error deserializing 'contentType' (nsCString) member of 'RemoteStreamInfo'");
return {};
}
auto& _contentType = *maybe___contentType;
// Sentinel = 'contentType'
if ((!((aReader)->ReadSentinel(465241246)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'contentType' (nsCString) member of 'RemoteStreamInfo'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_inputStream),
std::move(_contentType),
::int64_t{0}};
if ((!((aReader)->ReadBytesInto((&((result__)->contentLength())), 8)))) {
aReader->FatalError("Error bulk reading fields from int64_t");
return {};
}
// Sentinel = 'contentLength'
if ((!((aReader)->ReadSentinel(632358238)))) {
mozilla::ipc::SentinelReadError("Error bulk reading fields from int64_t");
return {};
}
return result__;
}
} // namespace IPC