//
// 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/NavigationAPIIPCUtils.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/WorkerIPCUtils.h"
#include "mozilla/dom/DomSecurityIPCUtils.h"
#include "mozilla/dom/DomSecurityIPCUtils.h"
#include "mozilla/GfxMessageUtils.h"
#include "mozilla/dom/CSPMessageUtils.h"
#include "mozilla/dom/PolicyContainerMessageUtils.h"
#include "mozilla/dom/DocShellMessageUtils.h"
#include "mozilla/dom/NavigationAPIIPCUtils.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/URLClassifierIPCUtils.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 CookieChange|
//
namespace mozilla {
namespace net {
} // namespace net
} // namespace mozilla

namespace IPC {
auto ParamTraits<::mozilla::net::CookieChange>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).added());
    // Sentinel = 'added'
    (aWriter)->WriteSentinel(97780211);
    IPC::WriteParam(aWriter, (aVar).cookie());
    // Sentinel = 'cookie'
    (aWriter)->WriteSentinel(146211451);
    IPC::WriteParam(aWriter, (aVar).originAttributes());
    // Sentinel = 'originAttributes'
    (aWriter)->WriteSentinel(947259056);
}

auto ParamTraits<::mozilla::net::CookieChange>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___added = IPC::ReadParam<bool>(aReader);
    if (!maybe___added) {
        aReader->FatalError("Error deserializing 'added' (bool) member of 'CookieChange'");
        return {};

    }
    auto& _added = *maybe___added;
    // Sentinel = 'added'
    if ((!((aReader)->ReadSentinel(97780211)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'added' (bool) member of 'CookieChange'");
        return {};
    }
    auto maybe___cookie = IPC::ReadParam<::mozilla::net::CookieStruct>(aReader);
    if (!maybe___cookie) {
        aReader->FatalError("Error deserializing 'cookie' (CookieStruct) member of 'CookieChange'");
        return {};

    }
    auto& _cookie = *maybe___cookie;
    // Sentinel = 'cookie'
    if ((!((aReader)->ReadSentinel(146211451)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'cookie' (CookieStruct) member of 'CookieChange'");
        return {};
    }
    auto maybe___originAttributes = IPC::ReadParam<::mozilla::OriginAttributes>(aReader);
    if (!maybe___originAttributes) {
        aReader->FatalError("Error deserializing 'originAttributes' (OriginAttributes) member of 'CookieChange'");
        return {};

    }
    auto& _originAttributes = *maybe___originAttributes;
    // Sentinel = 'originAttributes'
    if ((!((aReader)->ReadSentinel(947259056)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'originAttributes' (OriginAttributes) member of 'CookieChange'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_added),
            std::move(_cookie),
            std::move(_originAttributes)};
    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_)) == 28,
        "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).forceMediaDocument());
    // Sentinel = 'forceMediaDocument'
    (aWriter)->WriteSentinel(1132136239);
    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).isOn3PCBExceptionList());
    // Sentinel = 'isOn3PCBExceptionList'
    (aWriter)->WriteSentinel(1400571885);
    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).requestMode());
    // Sentinel = 'requestMode'
    (aWriter)->WriteSentinel(468386959);
    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).policyContainerToInherit());
    // Sentinel = 'policyContainerToInherit'
    (aWriter)->WriteSentinel(2059078090);
    IPC::WriteParam(aWriter, (aVar).storagePermission());
    // Sentinel = 'storagePermission'
    (aWriter)->WriteSentinel(1074333471);
    IPC::WriteParam(aWriter, (aVar).parentIPAddressSpace());
    // Sentinel = 'parentIPAddressSpace'
    (aWriter)->WriteSentinel(1382549462);
    IPC::WriteParam(aWriter, (aVar).ipAddressSpace());
    // Sentinel = 'ipAddressSpace'
    (aWriter)->WriteSentinel(694814092);
    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);
    IPC::WriteParam(aWriter, (aVar).userNavigationInvolvement());
    // Sentinel = 'userNavigationInvolvement'
    (aWriter)->WriteSentinel(2256013927);
    IPC::WriteParam(aWriter, (aVar).containerFeaturePolicyInfo());
    // Sentinel = 'containerFeaturePolicyInfo'
    (aWriter)->WriteSentinel(2399406732);
    (aWriter)->WriteBytes((&((aVar).triggeringWindowId())), 32);
    // Sentinel = 'triggeringWindowId | innerWindowID | browsingContextID | frameBrowsingContextID'
    (aWriter)->WriteSentinel(3275628114);
    (aWriter)->WriteBytes((&((aVar).securityFlags())), 32);
    // Sentinel = 'securityFlags | sandboxFlags | triggeringSandboxFlags | triggeringFirstPartyClassificationFlags | triggeringThirdPartyClassificationFlags | tainting | httpsOnlyStatus | requestBlockingReason'
    (aWriter)->WriteSentinel(2894940766);
}

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___forceMediaDocument = IPC::ReadParam<::mozilla::dom::ForceMediaDocument>(aReader);
    if (!maybe___forceMediaDocument) {
        aReader->FatalError("Error deserializing 'forceMediaDocument' (ForceMediaDocument) member of 'LoadInfoArgs'");
        return {};

    }
    auto& _forceMediaDocument = *maybe___forceMediaDocument;
    // Sentinel = 'forceMediaDocument'
    if ((!((aReader)->ReadSentinel(1132136239)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'forceMediaDocument' (ForceMediaDocument) 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___isOn3PCBExceptionList = IPC::ReadParam<bool>(aReader);
    if (!maybe___isOn3PCBExceptionList) {
        aReader->FatalError("Error deserializing 'isOn3PCBExceptionList' (bool) member of 'LoadInfoArgs'");
        return {};

    }
    auto& _isOn3PCBExceptionList = *maybe___isOn3PCBExceptionList;
    // Sentinel = 'isOn3PCBExceptionList'
    if ((!((aReader)->ReadSentinel(1400571885)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'isOn3PCBExceptionList' (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___requestMode = IPC::ReadParam<mozilla::Maybe<::mozilla::dom::RequestMode>>(aReader);
    if (!maybe___requestMode) {
        aReader->FatalError("Error deserializing 'requestMode' (RequestMode?) member of 'LoadInfoArgs'");
        return {};

    }
    auto& _requestMode = *maybe___requestMode;
    // Sentinel = 'requestMode'
    if ((!((aReader)->ReadSentinel(468386959)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'requestMode' (RequestMode?) 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___policyContainerToInherit = IPC::ReadParam<mozilla::Maybe<::mozilla::ipc::PolicyContainerArgs>>(aReader);
    if (!maybe___policyContainerToInherit) {
        aReader->FatalError("Error deserializing 'policyContainerToInherit' (PolicyContainerArgs?) member of 'LoadInfoArgs'");
        return {};

    }
    auto& _policyContainerToInherit = *maybe___policyContainerToInherit;
    // Sentinel = 'policyContainerToInherit'
    if ((!((aReader)->ReadSentinel(2059078090)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'policyContainerToInherit' (PolicyContainerArgs?) 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___parentIPAddressSpace = IPC::ReadParam<::nsILoadInfo::IPAddressSpace>(aReader);
    if (!maybe___parentIPAddressSpace) {
        aReader->FatalError("Error deserializing 'parentIPAddressSpace' (IPAddressSpace) member of 'LoadInfoArgs'");
        return {};

    }
    auto& _parentIPAddressSpace = *maybe___parentIPAddressSpace;
    // Sentinel = 'parentIPAddressSpace'
    if ((!((aReader)->ReadSentinel(1382549462)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'parentIPAddressSpace' (IPAddressSpace) member of 'LoadInfoArgs'");
        return {};
    }
    auto maybe___ipAddressSpace = IPC::ReadParam<::nsILoadInfo::IPAddressSpace>(aReader);
    if (!maybe___ipAddressSpace) {
        aReader->FatalError("Error deserializing 'ipAddressSpace' (IPAddressSpace) member of 'LoadInfoArgs'");
        return {};

    }
    auto& _ipAddressSpace = *maybe___ipAddressSpace;
    // Sentinel = 'ipAddressSpace'
    if ((!((aReader)->ReadSentinel(694814092)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'ipAddressSpace' (IPAddressSpace) member of 'LoadInfoArgs'");
        return {};
    }
    auto maybe___overriddenFingerprintingSettings = IPC::ReadParam<mozilla::Maybe<::mozilla::RFPTargetSet>>(aReader);
    if (!maybe___overriddenFingerprintingSettings) {
        aReader->FatalError("Error deserializing 'overriddenFingerprintingSettings' (RFPTargetSet?) member of 'LoadInfoArgs'");
        return {};

    }
    auto& _overriddenFingerprintingSettings = *maybe___overriddenFingerprintingSettings;
    // Sentinel = 'overriddenFingerprintingSettings'
    if ((!((aReader)->ReadSentinel(3670740298)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'overriddenFingerprintingSettings' (RFPTargetSet?) 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 {};
    }
    auto maybe___userNavigationInvolvement = IPC::ReadParam<::mozilla::dom::UserNavigationInvolvement>(aReader);
    if (!maybe___userNavigationInvolvement) {
        aReader->FatalError("Error deserializing 'userNavigationInvolvement' (UserNavigationInvolvement) member of 'LoadInfoArgs'");
        return {};

    }
    auto& _userNavigationInvolvement = *maybe___userNavigationInvolvement;
    // Sentinel = 'userNavigationInvolvement'
    if ((!((aReader)->ReadSentinel(2256013927)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'userNavigationInvolvement' (UserNavigationInvolvement) member of 'LoadInfoArgs'");
        return {};
    }
    auto maybe___containerFeaturePolicyInfo = IPC::ReadParam<mozilla::Maybe<::mozilla::dom::FeaturePolicyInfo>>(aReader);
    if (!maybe___containerFeaturePolicyInfo) {
        aReader->FatalError("Error deserializing 'containerFeaturePolicyInfo' (FeaturePolicyInfo?) member of 'LoadInfoArgs'");
        return {};

    }
    auto& _containerFeaturePolicyInfo = *maybe___containerFeaturePolicyInfo;
    // Sentinel = 'containerFeaturePolicyInfo'
    if ((!((aReader)->ReadSentinel(2399406732)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'containerFeaturePolicyInfo' (FeaturePolicyInfo?) 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),
            ::uint32_t{0},
            ::uint32_t{0},
            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(_forceMediaDocument),
            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(_isOn3PCBExceptionList),
            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(_requestMode),
            std::move(_isFromProcessingFrameAttributes),
            std::move(_isMediaRequest),
            std::move(_isMediaInitialRequest),
            std::move(_isFromObjectOrEmbed),
            std::move(_cookieJarSettings),
            ::uint32_t{0},
            std::move(_policyContainerToInherit),
            std::move(_storagePermission),
            std::move(_parentIPAddressSpace),
            std::move(_ipAddressSpace),
            std::move(_overriddenFingerprintingSettings),
            std::move(_isMetaRefresh),
            std::move(_loadingEmbedderPolicy),
            std::move(_originTrialCoepCredentiallessEnabledForTopLevel),
            std::move(_unstrippedURI),
            std::move(_interceptionInfo),
            std::move(_isNewWindowTarget),
            std::move(_userNavigationInvolvement),
            std::move(_containerFeaturePolicyInfo)};
    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())), 32)))) {
        aReader->FatalError("Error bulk reading fields from uint32_t");
        return {};
    }
    // Sentinel = 'securityFlags | sandboxFlags | triggeringSandboxFlags | triggeringFirstPartyClassificationFlags | triggeringThirdPartyClassificationFlags | tainting | httpsOnlyStatus | requestBlockingReason'
    if ((!((aReader)->ReadSentinel(2894940766)))) {
        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).requestMode());
    // Sentinel = 'requestMode'
    (aWriter)->WriteSentinel(468386959);
    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).isOn3PCBExceptionList());
    // Sentinel = 'isOn3PCBExceptionList'
    (aWriter)->WriteSentinel(1400571885);
    IPC::WriteParam(aWriter, (aVar).unstrippedURI());
    // Sentinel = 'unstrippedURI'
    (aWriter)->WriteSentinel(655230271);
    IPC::WriteParam(aWriter, (aVar).userNavigationInvolvement());
    // Sentinel = 'userNavigationInvolvement'
    (aWriter)->WriteSentinel(2256013927);
    (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___requestMode = IPC::ReadParam<mozilla::Maybe<::mozilla::dom::RequestMode>>(aReader);
    if (!maybe___requestMode) {
        aReader->FatalError("Error deserializing 'requestMode' (RequestMode?) member of 'ParentLoadInfoForwarderArgs'");
        return {};

    }
    auto& _requestMode = *maybe___requestMode;
    // Sentinel = 'requestMode'
    if ((!((aReader)->ReadSentinel(468386959)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'requestMode' (RequestMode?) 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<::mozilla::RFPTargetSet>>(aReader);
    if (!maybe___overriddenFingerprintingSettings) {
        aReader->FatalError("Error deserializing 'overriddenFingerprintingSettings' (RFPTargetSet?) member of 'ParentLoadInfoForwarderArgs'");
        return {};

    }
    auto& _overriddenFingerprintingSettings = *maybe___overriddenFingerprintingSettings;
    // Sentinel = 'overriddenFingerprintingSettings'
    if ((!((aReader)->ReadSentinel(3670740298)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'overriddenFingerprintingSettings' (RFPTargetSet?) 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___isOn3PCBExceptionList = IPC::ReadParam<bool>(aReader);
    if (!maybe___isOn3PCBExceptionList) {
        aReader->FatalError("Error deserializing 'isOn3PCBExceptionList' (bool) member of 'ParentLoadInfoForwarderArgs'");
        return {};

    }
    auto& _isOn3PCBExceptionList = *maybe___isOn3PCBExceptionList;
    // Sentinel = 'isOn3PCBExceptionList'
    if ((!((aReader)->ReadSentinel(1400571885)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'isOn3PCBExceptionList' (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 {};
    }
    auto maybe___userNavigationInvolvement = IPC::ReadParam<::mozilla::dom::UserNavigationInvolvement>(aReader);
    if (!maybe___userNavigationInvolvement) {
        aReader->FatalError("Error deserializing 'userNavigationInvolvement' (UserNavigationInvolvement) member of 'ParentLoadInfoForwarderArgs'");
        return {};

    }
    auto& _userNavigationInvolvement = *maybe___userNavigationInvolvement;
    // Sentinel = 'userNavigationInvolvement'
    if ((!((aReader)->ReadSentinel(2256013927)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'userNavigationInvolvement' (UserNavigationInvolvement) 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),
            std::move(_requestMode),
            ::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(_isOn3PCBExceptionList),
            std::move(_unstrippedURI),
            std::move(_userNavigationInvolvement)};
    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).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___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(_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).masqueTemplate());
    // Sentinel = 'masqueTemplate'
    (aWriter)->WriteSentinel(730858953);
    IPC::WriteParam(aWriter, (aVar).alpn());
    // Sentinel = 'alpn'
    (aWriter)->WriteSentinel(68813228);
    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___masqueTemplate = IPC::ReadParam<::nsCString>(aReader);
    if (!maybe___masqueTemplate) {
        aReader->FatalError("Error deserializing 'masqueTemplate' (nsCString) member of 'ProxyInfoCloneArgs'");
        return {};

    }
    auto& _masqueTemplate = *maybe___masqueTemplate;
    // Sentinel = 'masqueTemplate'
    if ((!((aReader)->ReadSentinel(730858953)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'masqueTemplate' (nsCString) member of 'ProxyInfoCloneArgs'");
        return {};
    }
    auto maybe___alpn = IPC::ReadParam<::nsCString>(aReader);
    if (!maybe___alpn) {
        aReader->FatalError("Error deserializing 'alpn' (nsCString) member of 'ProxyInfoCloneArgs'");
        return {};

    }
    auto& _alpn = *maybe___alpn;
    // Sentinel = 'alpn'
    if ((!((aReader)->ReadSentinel(68813228)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'alpn' (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(_masqueTemplate),
            std::move(_alpn),
            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, updateTimeInUSec_) - offsetof(CookieStruct, expiryInMSec_)) == 24,
        "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).expiryInMSec())), 32);
    // Sentinel = 'expiryInMSec | lastAccessedInUSec | creationTimeInUSec | updateTimeInUSec'
    (aWriter)->WriteSentinel(4075232047);
    (aWriter)->WriteBytes((&((aVar).sameSite())), 4);
    // Sentinel = 'sameSite'
    (aWriter)->WriteSentinel(245498684);
    (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},
            ::int64_t{0},
            std::move(_isHttpOnly),
            std::move(_isSession),
            std::move(_isSecure),
            std::move(_isPartitioned),
            ::int32_t{0},
            ::uint8_t{0}};
    if ((!((aReader)->ReadBytesInto((&((result__)->expiryInMSec())), 32)))) {
        aReader->FatalError("Error bulk reading fields from int64_t");
        return {};
    }
    // Sentinel = 'expiryInMSec | lastAccessedInUSec | creationTimeInUSec | updateTimeInUSec'
    if ((!((aReader)->ReadSentinel(4075232047)))) {
        mozilla::ipc::SentinelReadError("Error bulk reading fields from int64_t");
        return {};
    }
    if ((!((aReader)->ReadBytesInto((&((result__)->sameSite())), 4)))) {
        aReader->FatalError("Error bulk reading fields from int32_t");
        return {};
    }
    // Sentinel = 'sameSite'
    if ((!((aReader)->ReadSentinel(245498684)))) {
        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);
    IPC::WriteParam(aWriter, (aVar).referrerInfo());
    // Sentinel = 'referrerInfo'
    (aWriter)->WriteSentinel(540214506);
    (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 {};
    }
    auto maybe___referrerInfo = IPC::ReadParam<RefPtr<::nsIReferrerInfo>>(aReader);
    if (!maybe___referrerInfo) {
        aReader->FatalError("Error deserializing 'referrerInfo' (nsIReferrerInfo) member of 'RedirectToRealChannelArgs'");
        return {};

    }
    auto& _referrerInfo = *maybe___referrerInfo;
    // Sentinel = 'referrerInfo'
    if ((!((aReader)->ReadSentinel(540214506)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'referrerInfo' (nsIReferrerInfo) 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},
            std::move(_referrerInfo)};
    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, decodedBodySize_) - offsetof(ResourceTimingStructArgs, transferSize_)) == 16,
        "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())), 24);
    // Sentinel = 'transferSize | encodedBodySize | decodedBodySize'
    (aWriter)->WriteSentinel(3314815589);
}

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},
            ::uint64_t{0},
            std::move(_cacheReadStart),
            std::move(_cacheReadEnd),
            std::move(_transactionPending)};
    if ((!((aReader)->ReadBytesInto((&((result__)->transferSize())), 24)))) {
        aReader->FatalError("Error bulk reading fields from uint64_t");
        return {};
    }
    // Sentinel = 'transferSize | encodedBodySize | decodedBodySize'
    if ((!((aReader)->ReadSentinel(3314815589)))) {
        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 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 GeckoViewContentChannelOpenArgs|
//
namespace mozilla {
namespace net {
} // namespace net
} // namespace mozilla

namespace IPC {
auto ParamTraits<::mozilla::net::GeckoViewContentChannelOpenArgs>::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);
    (aWriter)->WriteBytes((&((aVar).loadFlags())), 4);
    // Sentinel = 'loadFlags'
    (aWriter)->WriteSentinel(297665422);
}

auto ParamTraits<::mozilla::net::GeckoViewContentChannelOpenArgs>::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 'GeckoViewContentChannelOpenArgs'");
        return {};

    }
    auto& _uri = *maybe___uri;
    // Sentinel = 'uri'
    if ((!((aReader)->ReadSentinel(45023569)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'uri' (URIParams) member of 'GeckoViewContentChannelOpenArgs'");
        return {};
    }
    auto maybe___loadInfo = IPC::ReadParam<::mozilla::net::LoadInfoArgs>(aReader);
    if (!maybe___loadInfo) {
        aReader->FatalError("Error deserializing 'loadInfo' (LoadInfoArgs) member of 'GeckoViewContentChannelOpenArgs'");
        return {};

    }
    auto& _loadInfo = *maybe___loadInfo;
    // Sentinel = 'loadInfo'
    if ((!((aReader)->ReadSentinel(240386861)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'loadInfo' (LoadInfoArgs) member of 'GeckoViewContentChannelOpenArgs'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_uri),
            std::move(_loadInfo),
            ::uint32_t{0}};
    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 GeckoViewContentChannelConnectArgs|
//
namespace mozilla {
namespace net {
} // namespace net
} // namespace mozilla

namespace IPC {
auto ParamTraits<::mozilla::net::GeckoViewContentChannelConnectArgs>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    (aWriter)->WriteBytes((&((aVar).channelId())), 4);
    // Sentinel = 'channelId'
    (aWriter)->WriteSentinel(301138823);
}

auto ParamTraits<::mozilla::net::GeckoViewContentChannelConnectArgs>::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 GeckoViewContentChannelArgs|
//
namespace mozilla {
namespace net {
auto GeckoViewContentChannelArgs::MaybeDestroy() -> void
{
    if ((mType) == (T__None)) {
        return;
    }
    switch (mType) {
    case TGeckoViewContentChannelOpenArgs:
        {
            (ptr_GeckoViewContentChannelOpenArgs())->~GeckoViewContentChannelOpenArgs__tdef();
            break;
        }
    case TGeckoViewContentChannelConnectArgs:
        {
            (ptr_GeckoViewContentChannelConnectArgs())->~GeckoViewContentChannelConnectArgs__tdef();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("not reached");
            break;
        }
    }
}

MOZ_IMPLICIT GeckoViewContentChannelArgs::GeckoViewContentChannelArgs(const GeckoViewContentChannelOpenArgs& aOther)
{
    new (mozilla::KnownNotNull, ptr_GeckoViewContentChannelOpenArgs()) GeckoViewContentChannelOpenArgs(aOther);
    mType = TGeckoViewContentChannelOpenArgs;
}

MOZ_IMPLICIT GeckoViewContentChannelArgs::GeckoViewContentChannelArgs(GeckoViewContentChannelOpenArgs&& aOther)
{
    new (mozilla::KnownNotNull, ptr_GeckoViewContentChannelOpenArgs()) GeckoViewContentChannelOpenArgs(std::move(aOther));
    mType = TGeckoViewContentChannelOpenArgs;
}

MOZ_IMPLICIT GeckoViewContentChannelArgs::GeckoViewContentChannelArgs(const GeckoViewContentChannelConnectArgs& aOther)
{
    new (mozilla::KnownNotNull, ptr_GeckoViewContentChannelConnectArgs()) GeckoViewContentChannelConnectArgs(aOther);
    mType = TGeckoViewContentChannelConnectArgs;
}

MOZ_IMPLICIT GeckoViewContentChannelArgs::GeckoViewContentChannelArgs(GeckoViewContentChannelConnectArgs&& aOther)
{
    new (mozilla::KnownNotNull, ptr_GeckoViewContentChannelConnectArgs()) GeckoViewContentChannelConnectArgs(std::move(aOther));
    mType = TGeckoViewContentChannelConnectArgs;
}

MOZ_IMPLICIT GeckoViewContentChannelArgs::GeckoViewContentChannelArgs(const GeckoViewContentChannelArgs& aOther)
{
    (aOther).AssertSanity();
    switch ((aOther).type()) {
    case TGeckoViewContentChannelOpenArgs:
        {
            new (mozilla::KnownNotNull, ptr_GeckoViewContentChannelOpenArgs()) GeckoViewContentChannelOpenArgs((aOther).get_GeckoViewContentChannelOpenArgs());
            break;
        }
    case TGeckoViewContentChannelConnectArgs:
        {
            new (mozilla::KnownNotNull, ptr_GeckoViewContentChannelConnectArgs()) GeckoViewContentChannelConnectArgs((aOther).get_GeckoViewContentChannelConnectArgs());
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    mType = (aOther).type();
}

MOZ_IMPLICIT GeckoViewContentChannelArgs::GeckoViewContentChannelArgs(GeckoViewContentChannelArgs&& aOther)
{
    (aOther).AssertSanity();
    Type t = (aOther).type();
    switch (t) {
    case TGeckoViewContentChannelOpenArgs:
        {
            new (mozilla::KnownNotNull, ptr_GeckoViewContentChannelOpenArgs()) GeckoViewContentChannelOpenArgs(std::move((aOther).get_GeckoViewContentChannelOpenArgs()));
            (aOther).MaybeDestroy();
            break;
        }
    case TGeckoViewContentChannelConnectArgs:
        {
            new (mozilla::KnownNotNull, ptr_GeckoViewContentChannelConnectArgs()) GeckoViewContentChannelConnectArgs(std::move((aOther).get_GeckoViewContentChannelConnectArgs()));
            (aOther).MaybeDestroy();
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    (aOther).mType = T__None;
    mType = t;
}

GeckoViewContentChannelArgs::~GeckoViewContentChannelArgs()
{
    MaybeDestroy();
}

auto GeckoViewContentChannelArgs::operator=(const GeckoViewContentChannelOpenArgs& aRhs) -> GeckoViewContentChannelArgs&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_GeckoViewContentChannelOpenArgs()) GeckoViewContentChannelOpenArgs(aRhs);
    mType = TGeckoViewContentChannelOpenArgs;
    return (*(this));
}

auto GeckoViewContentChannelArgs::operator=(GeckoViewContentChannelOpenArgs&& aRhs) -> GeckoViewContentChannelArgs&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_GeckoViewContentChannelOpenArgs()) GeckoViewContentChannelOpenArgs(std::move(aRhs));
    mType = TGeckoViewContentChannelOpenArgs;
    return (*(this));
}

auto GeckoViewContentChannelArgs::operator=(const GeckoViewContentChannelConnectArgs& aRhs) -> GeckoViewContentChannelArgs&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_GeckoViewContentChannelConnectArgs()) GeckoViewContentChannelConnectArgs(aRhs);
    mType = TGeckoViewContentChannelConnectArgs;
    return (*(this));
}

auto GeckoViewContentChannelArgs::operator=(GeckoViewContentChannelConnectArgs&& aRhs) -> GeckoViewContentChannelArgs&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_GeckoViewContentChannelConnectArgs()) GeckoViewContentChannelConnectArgs(std::move(aRhs));
    mType = TGeckoViewContentChannelConnectArgs;
    return (*(this));
}

auto GeckoViewContentChannelArgs::operator=(const GeckoViewContentChannelArgs& aRhs) -> GeckoViewContentChannelArgs&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case TGeckoViewContentChannelOpenArgs:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_GeckoViewContentChannelOpenArgs()) GeckoViewContentChannelOpenArgs((aRhs).get_GeckoViewContentChannelOpenArgs());
            break;
        }
    case TGeckoViewContentChannelConnectArgs:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_GeckoViewContentChannelConnectArgs()) GeckoViewContentChannelConnectArgs((aRhs).get_GeckoViewContentChannelConnectArgs());
            break;
        }
    case T__None:
        {
            MaybeDestroy();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            break;
        }
    }
    mType = t;
    return (*(this));
}

auto GeckoViewContentChannelArgs::operator=(GeckoViewContentChannelArgs&& aRhs) -> GeckoViewContentChannelArgs&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case TGeckoViewContentChannelOpenArgs:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_GeckoViewContentChannelOpenArgs()) GeckoViewContentChannelOpenArgs(std::move((aRhs).get_GeckoViewContentChannelOpenArgs()));
            (aRhs).MaybeDestroy();
            break;
        }
    case TGeckoViewContentChannelConnectArgs:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_GeckoViewContentChannelConnectArgs()) GeckoViewContentChannelConnectArgs(std::move((aRhs).get_GeckoViewContentChannelConnectArgs()));
            (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::GeckoViewContentChannelArgs>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    typedef ::mozilla::net::GeckoViewContentChannelArgs union__;
    int type = (aVar).type();
    IPC::WriteParam(aWriter, type);
    // Sentinel = 'GeckoViewContentChannelArgs'
    (aWriter)->WriteSentinel(2473462438);

    switch (type) {
    case union__::TGeckoViewContentChannelOpenArgs:
        {
            IPC::WriteParam(aWriter, (aVar).get_GeckoViewContentChannelOpenArgs());
            // Sentinel = 'TGeckoViewContentChannelOpenArgs'
            (aWriter)->WriteSentinel(3428781196);
            return;
        }
    case union__::TGeckoViewContentChannelConnectArgs:
        {
            IPC::WriteParam(aWriter, (aVar).get_GeckoViewContentChannelConnectArgs());
            // Sentinel = 'TGeckoViewContentChannelConnectArgs'
            (aWriter)->WriteSentinel(4101508548);
            return;
        }
    default:
        {
            aWriter->FatalError("unknown variant of union GeckoViewContentChannelArgs");
            return;
        }
    }
}

auto ParamTraits<::mozilla::net::GeckoViewContentChannelArgs>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    typedef ::mozilla::net::GeckoViewContentChannelArgs union__;
    auto maybe__type = IPC::ReadParam<int>(aReader);
    if (!maybe__type) {
        aReader->FatalError("Error deserializing type of union GeckoViewContentChannelArgs");
        return {};

    }
    auto& type = *maybe__type;
    // Sentinel = 'GeckoViewContentChannelArgs'
    if ((!((aReader)->ReadSentinel(2473462438)))) {
        mozilla::ipc::SentinelReadError("Error deserializing type of union GeckoViewContentChannelArgs");
        return {};
    }

    switch (type) {
    case union__::TGeckoViewContentChannelOpenArgs:
        {
            auto maybe__tmp = IPC::ReadParam<::mozilla::net::GeckoViewContentChannelOpenArgs>(aReader);
            if (!maybe__tmp) {
                aReader->FatalError("Error deserializing variant TGeckoViewContentChannelOpenArgs of union GeckoViewContentChannelArgs");
                return {};

            }
            auto& tmp = *maybe__tmp;
            // Sentinel = 'TGeckoViewContentChannelOpenArgs'
            if ((!((aReader)->ReadSentinel(3428781196)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TGeckoViewContentChannelOpenArgs of union GeckoViewContentChannelArgs");
                return {};
            }
            return std::move(tmp);
        }
    case union__::TGeckoViewContentChannelConnectArgs:
        {
            auto maybe__tmp = IPC::ReadParam<::mozilla::net::GeckoViewContentChannelConnectArgs>(aReader);
            if (!maybe__tmp) {
                aReader->FatalError("Error deserializing variant TGeckoViewContentChannelConnectArgs of union GeckoViewContentChannelArgs");
                return {};

            }
            auto& tmp = *maybe__tmp;
            // Sentinel = 'TGeckoViewContentChannelConnectArgs'
            if ((!((aReader)->ReadSentinel(4101508548)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TGeckoViewContentChannelConnectArgs of union GeckoViewContentChannelArgs");
                return {};
            }
            return std::move(tmp);
        }
    default:
        {
            aReader->FatalError("unknown variant of union GeckoViewContentChannelArgs");
            return {};
        }
    }
}

} // 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
