//
// Automatically generated by ipdlc.
// Edit at your own risk
//


#include "mozilla/dom/ReferrerInfoUtils.h"
#include "mozilla/ipc/TransportSecurityInfoUtils.h"
#include "mozilla/net/NeckoMessageUtils.h"
#include "mozilla/dom/ServiceWorkerIPCUtils.h"
#include "mozilla/dom/WorkerIPCUtils.h"
#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/HttpChannelParams.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 HttpChannelOnStartRequestArgs|
//
namespace mozilla {
namespace net {
auto HttpChannelOnStartRequestArgs::StaticAssertions() const -> void
{
    static_assert(
        (offsetof(HttpChannelOnStartRequestArgs, altDataLength_) - offsetof(HttpChannelOnStartRequestArgs, cacheEntryId_)) == 8,
        "Bad assumptions about field layout!");
    static_assert(
        (offsetof(HttpChannelOnStartRequestArgs, cacheKey_) - offsetof(HttpChannelOnStartRequestArgs, cacheFetchCount_)) == 8,
        "Bad assumptions about field layout!");
}

} // namespace net
} // namespace mozilla

namespace IPC {
auto ParamTraits<::mozilla::net::HttpChannelOnStartRequestArgs>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).securityInfo());
    // Sentinel = 'securityInfo'
    (aWriter)->WriteSentinel(552535301);
    IPC::WriteParam(aWriter, (aVar).overrideReferrerInfo());
    // Sentinel = 'overrideReferrerInfo'
    (aWriter)->WriteSentinel(1454704682);
    IPC::WriteParam(aWriter, (aVar).altDataType());
    // Sentinel = 'altDataType'
    (aWriter)->WriteSentinel(434504798);
    IPC::WriteParam(aWriter, (aVar).cookieChanges());
    // Sentinel = 'cookieChanges'
    (aWriter)->WriteSentinel(610796852);
    IPC::WriteParam(aWriter, (aVar).selfAddr());
    // Sentinel = 'selfAddr'
    (aWriter)->WriteSentinel(240321318);
    IPC::WriteParam(aWriter, (aVar).peerAddr());
    // Sentinel = 'peerAddr'
    (aWriter)->WriteSentinel(239928104);
    IPC::WriteParam(aWriter, (aVar).timing());
    // Sentinel = 'timing'
    (aWriter)->WriteSentinel(150798985);
    IPC::WriteParam(aWriter, (aVar).loadInfoForwarder());
    // Sentinel = 'loadInfoForwarder'
    (aWriter)->WriteSentinel(1020528345);
    IPC::WriteParam(aWriter, (aVar).channelStatus());
    // Sentinel = 'channelStatus'
    (aWriter)->WriteSentinel(618136926);
    IPC::WriteParam(aWriter, (aVar).effectiveTRRMode());
    // Sentinel = 'effectiveTRRMode'
    (aWriter)->WriteSentinel(899089967);
    IPC::WriteParam(aWriter, (aVar).trrSkipReason());
    // Sentinel = 'trrSkipReason'
    (aWriter)->WriteSentinel(630588760);
    IPC::WriteParam(aWriter, (aVar).multiPartID());
    // Sentinel = 'multiPartID'
    (aWriter)->WriteSentinel(458622032);
    IPC::WriteParam(aWriter, (aVar).isFromCache());
    // Sentinel = 'isFromCache'
    (aWriter)->WriteSentinel(433718341);
    IPC::WriteParam(aWriter, (aVar).isRacing());
    // Sentinel = 'isRacing'
    (aWriter)->WriteSentinel(240124721);
    IPC::WriteParam(aWriter, (aVar).cacheEntryAvailable());
    // Sentinel = 'cacheEntryAvailable'
    (aWriter)->WriteSentinel(1254164360);
    IPC::WriteParam(aWriter, (aVar).deliveringAltData());
    // Sentinel = 'deliveringAltData'
    (aWriter)->WriteSentinel(1039533765);
    IPC::WriteParam(aWriter, (aVar).applyConversion());
    // Sentinel = 'applyConversion'
    (aWriter)->WriteSentinel(837486157);
    IPC::WriteParam(aWriter, (aVar).isResolvedByTRR());
    // Sentinel = 'isResolvedByTRR'
    (aWriter)->WriteSentinel(811861460);
    IPC::WriteParam(aWriter, (aVar).allRedirectsSameOrigin());
    // Sentinel = 'allRedirectsSameOrigin'
    (aWriter)->WriteSentinel(1689716941);
    IPC::WriteParam(aWriter, (aVar).isFirstPartOfMultiPart());
    // Sentinel = 'isFirstPartOfMultiPart'
    (aWriter)->WriteSentinel(1696532691);
    IPC::WriteParam(aWriter, (aVar).isLastPartOfMultiPart());
    // Sentinel = 'isLastPartOfMultiPart'
    (aWriter)->WriteSentinel(1534134367);
    IPC::WriteParam(aWriter, (aVar).openerPolicy());
    // Sentinel = 'openerPolicy'
    (aWriter)->WriteSentinel(542835962);
    IPC::WriteParam(aWriter, (aVar).shouldWaitForOnStartRequestSent());
    // Sentinel = 'shouldWaitForOnStartRequestSent'
    (aWriter)->WriteSentinel(3372354714);
    IPC::WriteParam(aWriter, (aVar).dataFromSocketProcess());
    // Sentinel = 'dataFromSocketProcess'
    (aWriter)->WriteSentinel(1537869943);
    IPC::WriteParam(aWriter, (aVar).hasHTTPSRR());
    // Sentinel = 'hasHTTPSRR'
    (aWriter)->WriteSentinel(333316980);
    IPC::WriteParam(aWriter, (aVar).isProxyUsed());
    // Sentinel = 'isProxyUsed'
    (aWriter)->WriteSentinel(461178000);
    IPC::WriteParam(aWriter, (aVar).protocolVersion());
    // Sentinel = 'protocolVersion'
    (aWriter)->WriteSentinel(857540185);
    IPC::WriteParam(aWriter, (aVar).cacheDisposition());
    // Sentinel = 'cacheDisposition'
    (aWriter)->WriteSentinel(906823306);
    (aWriter)->WriteBytes((&((aVar).cacheEntryId())), 16);
    // Sentinel = 'cacheEntryId | altDataLength'
    (aWriter)->WriteSentinel(2550139533);
    (aWriter)->WriteBytes((&((aVar).cacheFetchCount())), 12);
    // Sentinel = 'cacheFetchCount | cacheExpirationTime | cacheKey'
    (aWriter)->WriteSentinel(3181515299);
    (aWriter)->WriteBytes((&((aVar).redirectCount())), 1);
    // Sentinel = 'redirectCount'
    (aWriter)->WriteSentinel(625608028);
}

auto ParamTraits<::mozilla::net::HttpChannelOnStartRequestArgs>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___securityInfo = IPC::ReadParam<RefPtr<::nsITransportSecurityInfo>>(aReader);
    if (!maybe___securityInfo) {
        aReader->FatalError("Error deserializing 'securityInfo' (nsITransportSecurityInfo) member of 'HttpChannelOnStartRequestArgs'");
        return {};

    }
    auto& _securityInfo = *maybe___securityInfo;
    // Sentinel = 'securityInfo'
    if ((!((aReader)->ReadSentinel(552535301)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'securityInfo' (nsITransportSecurityInfo) member of 'HttpChannelOnStartRequestArgs'");
        return {};
    }
    auto maybe___overrideReferrerInfo = IPC::ReadParam<RefPtr<::nsIReferrerInfo>>(aReader);
    if (!maybe___overrideReferrerInfo) {
        aReader->FatalError("Error deserializing 'overrideReferrerInfo' (nsIReferrerInfo) member of 'HttpChannelOnStartRequestArgs'");
        return {};

    }
    auto& _overrideReferrerInfo = *maybe___overrideReferrerInfo;
    // Sentinel = 'overrideReferrerInfo'
    if ((!((aReader)->ReadSentinel(1454704682)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'overrideReferrerInfo' (nsIReferrerInfo) member of 'HttpChannelOnStartRequestArgs'");
        return {};
    }
    auto maybe___altDataType = IPC::ReadParam<::nsCString>(aReader);
    if (!maybe___altDataType) {
        aReader->FatalError("Error deserializing 'altDataType' (nsCString) member of 'HttpChannelOnStartRequestArgs'");
        return {};

    }
    auto& _altDataType = *maybe___altDataType;
    // Sentinel = 'altDataType'
    if ((!((aReader)->ReadSentinel(434504798)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'altDataType' (nsCString) member of 'HttpChannelOnStartRequestArgs'");
        return {};
    }
    auto maybe___cookieChanges = IPC::ReadParam<nsTArray<::mozilla::net::CookieChange>>(aReader);
    if (!maybe___cookieChanges) {
        aReader->FatalError("Error deserializing 'cookieChanges' (CookieChange[]) member of 'HttpChannelOnStartRequestArgs'");
        return {};

    }
    auto& _cookieChanges = *maybe___cookieChanges;
    // Sentinel = 'cookieChanges'
    if ((!((aReader)->ReadSentinel(610796852)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'cookieChanges' (CookieChange[]) member of 'HttpChannelOnStartRequestArgs'");
        return {};
    }
    auto maybe___selfAddr = IPC::ReadParam<::mozilla::net::NetAddr>(aReader);
    if (!maybe___selfAddr) {
        aReader->FatalError("Error deserializing 'selfAddr' (NetAddr) member of 'HttpChannelOnStartRequestArgs'");
        return {};

    }
    auto& _selfAddr = *maybe___selfAddr;
    // Sentinel = 'selfAddr'
    if ((!((aReader)->ReadSentinel(240321318)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'selfAddr' (NetAddr) member of 'HttpChannelOnStartRequestArgs'");
        return {};
    }
    auto maybe___peerAddr = IPC::ReadParam<::mozilla::net::NetAddr>(aReader);
    if (!maybe___peerAddr) {
        aReader->FatalError("Error deserializing 'peerAddr' (NetAddr) member of 'HttpChannelOnStartRequestArgs'");
        return {};

    }
    auto& _peerAddr = *maybe___peerAddr;
    // Sentinel = 'peerAddr'
    if ((!((aReader)->ReadSentinel(239928104)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'peerAddr' (NetAddr) member of 'HttpChannelOnStartRequestArgs'");
        return {};
    }
    auto maybe___timing = IPC::ReadParam<::mozilla::net::ResourceTimingStructArgs>(aReader);
    if (!maybe___timing) {
        aReader->FatalError("Error deserializing 'timing' (ResourceTimingStructArgs) member of 'HttpChannelOnStartRequestArgs'");
        return {};

    }
    auto& _timing = *maybe___timing;
    // Sentinel = 'timing'
    if ((!((aReader)->ReadSentinel(150798985)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'timing' (ResourceTimingStructArgs) member of 'HttpChannelOnStartRequestArgs'");
        return {};
    }
    auto maybe___loadInfoForwarder = IPC::ReadParam<::mozilla::net::ParentLoadInfoForwarderArgs>(aReader);
    if (!maybe___loadInfoForwarder) {
        aReader->FatalError("Error deserializing 'loadInfoForwarder' (ParentLoadInfoForwarderArgs) member of 'HttpChannelOnStartRequestArgs'");
        return {};

    }
    auto& _loadInfoForwarder = *maybe___loadInfoForwarder;
    // Sentinel = 'loadInfoForwarder'
    if ((!((aReader)->ReadSentinel(1020528345)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'loadInfoForwarder' (ParentLoadInfoForwarderArgs) member of 'HttpChannelOnStartRequestArgs'");
        return {};
    }
    auto maybe___channelStatus = IPC::ReadParam<::nsresult>(aReader);
    if (!maybe___channelStatus) {
        aReader->FatalError("Error deserializing 'channelStatus' (nsresult) member of 'HttpChannelOnStartRequestArgs'");
        return {};

    }
    auto& _channelStatus = *maybe___channelStatus;
    // Sentinel = 'channelStatus'
    if ((!((aReader)->ReadSentinel(618136926)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'channelStatus' (nsresult) member of 'HttpChannelOnStartRequestArgs'");
        return {};
    }
    auto maybe___effectiveTRRMode = IPC::ReadParam<::nsIRequest::TRRMode>(aReader);
    if (!maybe___effectiveTRRMode) {
        aReader->FatalError("Error deserializing 'effectiveTRRMode' (TRRMode) member of 'HttpChannelOnStartRequestArgs'");
        return {};

    }
    auto& _effectiveTRRMode = *maybe___effectiveTRRMode;
    // Sentinel = 'effectiveTRRMode'
    if ((!((aReader)->ReadSentinel(899089967)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'effectiveTRRMode' (TRRMode) member of 'HttpChannelOnStartRequestArgs'");
        return {};
    }
    auto maybe___trrSkipReason = IPC::ReadParam<::mozilla::net::TRRSkippedReason>(aReader);
    if (!maybe___trrSkipReason) {
        aReader->FatalError("Error deserializing 'trrSkipReason' (TRRSkippedReason) member of 'HttpChannelOnStartRequestArgs'");
        return {};

    }
    auto& _trrSkipReason = *maybe___trrSkipReason;
    // Sentinel = 'trrSkipReason'
    if ((!((aReader)->ReadSentinel(630588760)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'trrSkipReason' (TRRSkippedReason) member of 'HttpChannelOnStartRequestArgs'");
        return {};
    }
    auto maybe___multiPartID = IPC::ReadParam<mozilla::Maybe<::uint32_t>>(aReader);
    if (!maybe___multiPartID) {
        aReader->FatalError("Error deserializing 'multiPartID' (uint32_t?) member of 'HttpChannelOnStartRequestArgs'");
        return {};

    }
    auto& _multiPartID = *maybe___multiPartID;
    // Sentinel = 'multiPartID'
    if ((!((aReader)->ReadSentinel(458622032)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'multiPartID' (uint32_t?) member of 'HttpChannelOnStartRequestArgs'");
        return {};
    }
    auto maybe___isFromCache = IPC::ReadParam<bool>(aReader);
    if (!maybe___isFromCache) {
        aReader->FatalError("Error deserializing 'isFromCache' (bool) member of 'HttpChannelOnStartRequestArgs'");
        return {};

    }
    auto& _isFromCache = *maybe___isFromCache;
    // Sentinel = 'isFromCache'
    if ((!((aReader)->ReadSentinel(433718341)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'isFromCache' (bool) member of 'HttpChannelOnStartRequestArgs'");
        return {};
    }
    auto maybe___isRacing = IPC::ReadParam<bool>(aReader);
    if (!maybe___isRacing) {
        aReader->FatalError("Error deserializing 'isRacing' (bool) member of 'HttpChannelOnStartRequestArgs'");
        return {};

    }
    auto& _isRacing = *maybe___isRacing;
    // Sentinel = 'isRacing'
    if ((!((aReader)->ReadSentinel(240124721)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'isRacing' (bool) member of 'HttpChannelOnStartRequestArgs'");
        return {};
    }
    auto maybe___cacheEntryAvailable = IPC::ReadParam<bool>(aReader);
    if (!maybe___cacheEntryAvailable) {
        aReader->FatalError("Error deserializing 'cacheEntryAvailable' (bool) member of 'HttpChannelOnStartRequestArgs'");
        return {};

    }
    auto& _cacheEntryAvailable = *maybe___cacheEntryAvailable;
    // Sentinel = 'cacheEntryAvailable'
    if ((!((aReader)->ReadSentinel(1254164360)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'cacheEntryAvailable' (bool) member of 'HttpChannelOnStartRequestArgs'");
        return {};
    }
    auto maybe___deliveringAltData = IPC::ReadParam<bool>(aReader);
    if (!maybe___deliveringAltData) {
        aReader->FatalError("Error deserializing 'deliveringAltData' (bool) member of 'HttpChannelOnStartRequestArgs'");
        return {};

    }
    auto& _deliveringAltData = *maybe___deliveringAltData;
    // Sentinel = 'deliveringAltData'
    if ((!((aReader)->ReadSentinel(1039533765)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'deliveringAltData' (bool) member of 'HttpChannelOnStartRequestArgs'");
        return {};
    }
    auto maybe___applyConversion = IPC::ReadParam<bool>(aReader);
    if (!maybe___applyConversion) {
        aReader->FatalError("Error deserializing 'applyConversion' (bool) member of 'HttpChannelOnStartRequestArgs'");
        return {};

    }
    auto& _applyConversion = *maybe___applyConversion;
    // Sentinel = 'applyConversion'
    if ((!((aReader)->ReadSentinel(837486157)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'applyConversion' (bool) member of 'HttpChannelOnStartRequestArgs'");
        return {};
    }
    auto maybe___isResolvedByTRR = IPC::ReadParam<bool>(aReader);
    if (!maybe___isResolvedByTRR) {
        aReader->FatalError("Error deserializing 'isResolvedByTRR' (bool) member of 'HttpChannelOnStartRequestArgs'");
        return {};

    }
    auto& _isResolvedByTRR = *maybe___isResolvedByTRR;
    // Sentinel = 'isResolvedByTRR'
    if ((!((aReader)->ReadSentinel(811861460)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'isResolvedByTRR' (bool) member of 'HttpChannelOnStartRequestArgs'");
        return {};
    }
    auto maybe___allRedirectsSameOrigin = IPC::ReadParam<bool>(aReader);
    if (!maybe___allRedirectsSameOrigin) {
        aReader->FatalError("Error deserializing 'allRedirectsSameOrigin' (bool) member of 'HttpChannelOnStartRequestArgs'");
        return {};

    }
    auto& _allRedirectsSameOrigin = *maybe___allRedirectsSameOrigin;
    // Sentinel = 'allRedirectsSameOrigin'
    if ((!((aReader)->ReadSentinel(1689716941)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'allRedirectsSameOrigin' (bool) member of 'HttpChannelOnStartRequestArgs'");
        return {};
    }
    auto maybe___isFirstPartOfMultiPart = IPC::ReadParam<bool>(aReader);
    if (!maybe___isFirstPartOfMultiPart) {
        aReader->FatalError("Error deserializing 'isFirstPartOfMultiPart' (bool) member of 'HttpChannelOnStartRequestArgs'");
        return {};

    }
    auto& _isFirstPartOfMultiPart = *maybe___isFirstPartOfMultiPart;
    // Sentinel = 'isFirstPartOfMultiPart'
    if ((!((aReader)->ReadSentinel(1696532691)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'isFirstPartOfMultiPart' (bool) member of 'HttpChannelOnStartRequestArgs'");
        return {};
    }
    auto maybe___isLastPartOfMultiPart = IPC::ReadParam<bool>(aReader);
    if (!maybe___isLastPartOfMultiPart) {
        aReader->FatalError("Error deserializing 'isLastPartOfMultiPart' (bool) member of 'HttpChannelOnStartRequestArgs'");
        return {};

    }
    auto& _isLastPartOfMultiPart = *maybe___isLastPartOfMultiPart;
    // Sentinel = 'isLastPartOfMultiPart'
    if ((!((aReader)->ReadSentinel(1534134367)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'isLastPartOfMultiPart' (bool) member of 'HttpChannelOnStartRequestArgs'");
        return {};
    }
    auto maybe___openerPolicy = IPC::ReadParam<::nsILoadInfo::CrossOriginOpenerPolicy>(aReader);
    if (!maybe___openerPolicy) {
        aReader->FatalError("Error deserializing 'openerPolicy' (CrossOriginOpenerPolicy) member of 'HttpChannelOnStartRequestArgs'");
        return {};

    }
    auto& _openerPolicy = *maybe___openerPolicy;
    // Sentinel = 'openerPolicy'
    if ((!((aReader)->ReadSentinel(542835962)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'openerPolicy' (CrossOriginOpenerPolicy) member of 'HttpChannelOnStartRequestArgs'");
        return {};
    }
    auto maybe___shouldWaitForOnStartRequestSent = IPC::ReadParam<bool>(aReader);
    if (!maybe___shouldWaitForOnStartRequestSent) {
        aReader->FatalError("Error deserializing 'shouldWaitForOnStartRequestSent' (bool) member of 'HttpChannelOnStartRequestArgs'");
        return {};

    }
    auto& _shouldWaitForOnStartRequestSent = *maybe___shouldWaitForOnStartRequestSent;
    // Sentinel = 'shouldWaitForOnStartRequestSent'
    if ((!((aReader)->ReadSentinel(3372354714)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'shouldWaitForOnStartRequestSent' (bool) member of 'HttpChannelOnStartRequestArgs'");
        return {};
    }
    auto maybe___dataFromSocketProcess = IPC::ReadParam<bool>(aReader);
    if (!maybe___dataFromSocketProcess) {
        aReader->FatalError("Error deserializing 'dataFromSocketProcess' (bool) member of 'HttpChannelOnStartRequestArgs'");
        return {};

    }
    auto& _dataFromSocketProcess = *maybe___dataFromSocketProcess;
    // Sentinel = 'dataFromSocketProcess'
    if ((!((aReader)->ReadSentinel(1537869943)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'dataFromSocketProcess' (bool) member of 'HttpChannelOnStartRequestArgs'");
        return {};
    }
    auto maybe___hasHTTPSRR = IPC::ReadParam<bool>(aReader);
    if (!maybe___hasHTTPSRR) {
        aReader->FatalError("Error deserializing 'hasHTTPSRR' (bool) member of 'HttpChannelOnStartRequestArgs'");
        return {};

    }
    auto& _hasHTTPSRR = *maybe___hasHTTPSRR;
    // Sentinel = 'hasHTTPSRR'
    if ((!((aReader)->ReadSentinel(333316980)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'hasHTTPSRR' (bool) member of 'HttpChannelOnStartRequestArgs'");
        return {};
    }
    auto maybe___isProxyUsed = IPC::ReadParam<bool>(aReader);
    if (!maybe___isProxyUsed) {
        aReader->FatalError("Error deserializing 'isProxyUsed' (bool) member of 'HttpChannelOnStartRequestArgs'");
        return {};

    }
    auto& _isProxyUsed = *maybe___isProxyUsed;
    // Sentinel = 'isProxyUsed'
    if ((!((aReader)->ReadSentinel(461178000)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'isProxyUsed' (bool) member of 'HttpChannelOnStartRequestArgs'");
        return {};
    }
    auto maybe___protocolVersion = IPC::ReadParam<::nsCString>(aReader);
    if (!maybe___protocolVersion) {
        aReader->FatalError("Error deserializing 'protocolVersion' (nsCString) member of 'HttpChannelOnStartRequestArgs'");
        return {};

    }
    auto& _protocolVersion = *maybe___protocolVersion;
    // Sentinel = 'protocolVersion'
    if ((!((aReader)->ReadSentinel(857540185)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'protocolVersion' (nsCString) member of 'HttpChannelOnStartRequestArgs'");
        return {};
    }
    auto maybe___cacheDisposition = IPC::ReadParam<::nsICacheInfoChannel::CacheDisposition>(aReader);
    if (!maybe___cacheDisposition) {
        aReader->FatalError("Error deserializing 'cacheDisposition' (CacheDisposition) member of 'HttpChannelOnStartRequestArgs'");
        return {};

    }
    auto& _cacheDisposition = *maybe___cacheDisposition;
    // Sentinel = 'cacheDisposition'
    if ((!((aReader)->ReadSentinel(906823306)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'cacheDisposition' (CacheDisposition) member of 'HttpChannelOnStartRequestArgs'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_securityInfo),
            std::move(_overrideReferrerInfo),
            ::uint64_t{0},
            ::int64_t{0},
            std::move(_altDataType),
            std::move(_cookieChanges),
            std::move(_selfAddr),
            std::move(_peerAddr),
            std::move(_timing),
            std::move(_loadInfoForwarder),
            std::move(_channelStatus),
            std::move(_effectiveTRRMode),
            std::move(_trrSkipReason),
            ::uint32_t{0},
            ::uint32_t{0},
            ::uint32_t{0},
            std::move(_multiPartID),
            std::move(_isFromCache),
            std::move(_isRacing),
            std::move(_cacheEntryAvailable),
            std::move(_deliveringAltData),
            std::move(_applyConversion),
            std::move(_isResolvedByTRR),
            std::move(_allRedirectsSameOrigin),
            std::move(_isFirstPartOfMultiPart),
            std::move(_isLastPartOfMultiPart),
            std::move(_openerPolicy),
            std::move(_shouldWaitForOnStartRequestSent),
            std::move(_dataFromSocketProcess),
            std::move(_hasHTTPSRR),
            std::move(_isProxyUsed),
            ::uint8_t{0},
            std::move(_protocolVersion),
            std::move(_cacheDisposition)};
    if ((!((aReader)->ReadBytesInto((&((result__)->cacheEntryId())), 16)))) {
        aReader->FatalError("Error bulk reading fields from uint64_t");
        return {};
    }
    // Sentinel = 'cacheEntryId | altDataLength'
    if ((!((aReader)->ReadSentinel(2550139533)))) {
        mozilla::ipc::SentinelReadError("Error bulk reading fields from uint64_t");
        return {};
    }
    if ((!((aReader)->ReadBytesInto((&((result__)->cacheFetchCount())), 12)))) {
        aReader->FatalError("Error bulk reading fields from uint32_t");
        return {};
    }
    // Sentinel = 'cacheFetchCount | cacheExpirationTime | cacheKey'
    if ((!((aReader)->ReadSentinel(3181515299)))) {
        mozilla::ipc::SentinelReadError("Error bulk reading fields from uint32_t");
        return {};
    }
    if ((!((aReader)->ReadBytesInto((&((result__)->redirectCount())), 1)))) {
        aReader->FatalError("Error bulk reading fields from uint8_t");
        return {};
    }
    // Sentinel = 'redirectCount'
    if ((!((aReader)->ReadSentinel(625608028)))) {
        mozilla::ipc::SentinelReadError("Error bulk reading fields from uint8_t");
        return {};
    }
    return result__;
}

} // namespace IPC

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct HttpChannelAltDataStream|
//
namespace mozilla {
namespace net {
} // namespace net
} // namespace mozilla

namespace IPC {
auto ParamTraits<::mozilla::net::HttpChannelAltDataStream>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).altDataInputStream());
    // Sentinel = 'altDataInputStream'
    (aWriter)->WriteSentinel(1134102328);
}

auto ParamTraits<::mozilla::net::HttpChannelAltDataStream>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___altDataInputStream = IPC::ReadParam<mozilla::Maybe<::mozilla::ipc::IPCStream>>(aReader);
    if (!maybe___altDataInputStream) {
        aReader->FatalError("Error deserializing 'altDataInputStream' (IPCStream?) member of 'HttpChannelAltDataStream'");
        return {};

    }
    auto& _altDataInputStream = *maybe___altDataInputStream;
    // Sentinel = 'altDataInputStream'
    if ((!((aReader)->ReadSentinel(1134102328)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'altDataInputStream' (IPCStream?) member of 'HttpChannelAltDataStream'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_altDataInputStream)};
    return result__;
}

} // namespace IPC
