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


#include "mozilla/net/PHttpTransactionChild.h"
#include "mozilla/AntiTrackingIPCUtils.h"
#include "mozilla/ProfilerLabels.h"
#include "mozilla/TimeStamp.h"
#include "mozilla/dom/ConsoleReportIPCUtils.h"
#include "mozilla/dom/DomSecurityIPCUtils.h"
#include "mozilla/dom/FetchIPCTypes.h"
#include "mozilla/dom/NavigationAPIIPCUtils.h"
#include "mozilla/dom/PermissionsPolicyUtils.h"
#include "mozilla/dom/PropertyBagUtils.h"
#include "mozilla/dom/ReferrerInfoUtils.h"
#include "mozilla/dom/RemoteType.h"
#include "mozilla/dom/SessionHistoryEntry.h"
#include "mozilla/ipc/TransportSecurityInfoUtils.h"
#include "mozilla/ipc/URIUtils.h"
#include "mozilla/net/CacheInfoIPCTypes.h"
#include "mozilla/net/ClassOfService.h"
#include "mozilla/net/HttpTransactionChild.h"
#include "mozilla/net/HttpTransactionShell.h"
#include "mozilla/net/NeckoMessageUtils.h"
#include "nsDOMNavigationTiming.h"
#include "nsDocShellLoadState.h"
#include "nsHttp.h"
#include "nsHttpHeaderArray.h"
#include "nsHttpRequestHead.h"
#include "nsHttpResponseHead.h"
#include "nsIPropertyBag2.h"
#include "nsITransportSecurityInfo.h"

#include "mozilla/net/PSocketProcessChild.h"
#include "mozilla/net/PInputChannelThrottleQueueChild.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"

namespace mozilla {
namespace net {


auto PHttpTransactionChild::Recv__delete__() -> mozilla::ipc::IPCResult
{
    return IPC_OK();
}

MOZ_IMPLICIT PHttpTransactionChild::PHttpTransactionChild() :
    mozilla::ipc::IRefCountedProtocol(kProtocolId, mozilla::ipc::ChildSide)
{
    MOZ_COUNT_CTOR(PHttpTransactionChild);
}

PHttpTransactionChild::~PHttpTransactionChild()
{
    MOZ_COUNT_DTOR(PHttpTransactionChild);
}

auto PHttpTransactionChild::ActorAlloc() -> void
{
    AddRef();
}

auto PHttpTransactionChild::ActorDealloc() -> void
{
    Release();
}

auto PHttpTransactionChild::OtherPid() const -> ::base::ProcessId
{
    ::base::ProcessId pid =
        ::mozilla::ipc::IProtocol::ToplevelProtocol()->OtherPidMaybeInvalid();
    MOZ_RELEASE_ASSERT(pid != ::base::kInvalidProcessId);
    return pid;
}

auto PHttpTransactionChild::OtherChildID() const -> ::GeckoChildID
{
    ::GeckoChildID childID =
        ::mozilla::ipc::IProtocol::ToplevelProtocol()->OtherChildIDMaybeInvalid();
    MOZ_RELEASE_ASSERT(childID != -1);
    return childID;
}

auto PHttpTransactionChild::OtherEndpointProcInfo() const -> ::mozilla::ipc::EndpointProcInfo
{
    return ::mozilla::ipc::EndpointProcInfo{OtherPid(), OtherChildID()};
}

auto PHttpTransactionChild::Manager() const -> PSocketProcessChild*
{
    return static_cast<PSocketProcessChild*>(IProtocol::Manager());
}

auto PHttpTransactionChild::ManagedProtocolIds() const -> mozilla::Span<mozilla::ipc::ProtocolId const>
{
    return {};
}

auto PHttpTransactionChild::GetManagedActors(mozilla::ipc::ProtocolId aProtocol) -> UntypedManagedContainer*
{
    switch (aProtocol) {
    default:
        return nullptr;
    }
}

auto PHttpTransactionChild::SendOnStartRequest(
        const nsresult& status,
        mozilla::Maybe<nsHttpResponseHead>&& responseHead,
        nsITransportSecurityInfo* securityInfo,
        const bool& proxyConnectFailed,
        const TimingStructArgs& timings,
        mozilla::Maybe<nsHttpResponseHead>&& proxyConnectResponseHead,
        mozilla::Span<uint8_t const> dataForSniffer,
        const mozilla::Maybe<nsCString>& altSvcUsed,
        const bool& dataToChildProcess,
        const bool& restarted,
        const uint32_t& HTTPSSVCReceivedStage,
        const bool& supportsHttp3,
        const TRRMode& trrMode,
        const TRRSkippedReason& trrSkipReason,
        const uint32_t& caps,
        const TimeStamp& onStartRequestStart,
        const HttpConnectionInfoCloneArgs& connInfoArgs,
        const IPAddressSpace& targetIpAddressSpace) -> bool
{
    UniquePtr<IPC::Message> msg__ = PHttpTransaction::Msg_OnStartRequest(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), status);
    // Sentinel = 'status'
    ((&(writer__)))->WriteSentinel(154731173);
    IPC::WriteParam((&(writer__)), std::move(responseHead));
    // Sentinel = 'responseHead'
    ((&(writer__)))->WriteSentinel(549651682);
    IPC::WriteParam((&(writer__)), securityInfo);
    // Sentinel = 'securityInfo'
    ((&(writer__)))->WriteSentinel(552535301);
    IPC::WriteParam((&(writer__)), proxyConnectFailed);
    // Sentinel = 'proxyConnectFailed'
    ((&(writer__)))->WriteSentinel(1194002258);
    IPC::WriteParam((&(writer__)), timings);
    // Sentinel = 'timings'
    ((&(writer__)))->WriteSentinel(200868604);
    IPC::WriteParam((&(writer__)), std::move(proxyConnectResponseHead));
    // Sentinel = 'proxyConnectResponseHead'
    ((&(writer__)))->WriteSentinel(2098268622);
    IPC::WriteParam((&(writer__)), dataForSniffer);
    // Sentinel = 'dataForSniffer'
    ((&(writer__)))->WriteSentinel(690816399);
    IPC::WriteParam((&(writer__)), altSvcUsed);
    // Sentinel = 'altSvcUsed'
    ((&(writer__)))->WriteSentinel(370344959);
    IPC::WriteParam((&(writer__)), dataToChildProcess);
    // Sentinel = 'dataToChildProcess'
    ((&(writer__)))->WriteSentinel(1114769185);
    IPC::WriteParam((&(writer__)), restarted);
    // Sentinel = 'restarted'
    ((&(writer__)))->WriteSentinel(323421135);
    IPC::WriteParam((&(writer__)), HTTPSSVCReceivedStage);
    // Sentinel = 'HTTPSSVCReceivedStage'
    ((&(writer__)))->WriteSentinel(1328154523);
    IPC::WriteParam((&(writer__)), supportsHttp3);
    // Sentinel = 'supportsHttp3'
    ((&(writer__)))->WriteSentinel(663487844);
    IPC::WriteParam((&(writer__)), trrMode);
    // Sentinel = 'trrMode'
    ((&(writer__)))->WriteSentinel(197591774);
    IPC::WriteParam((&(writer__)), trrSkipReason);
    // Sentinel = 'trrSkipReason'
    ((&(writer__)))->WriteSentinel(630588760);
    IPC::WriteParam((&(writer__)), caps);
    // Sentinel = 'caps'
    ((&(writer__)))->WriteSentinel(67502504);
    IPC::WriteParam((&(writer__)), onStartRequestStart);
    // Sentinel = 'onStartRequestStart'
    ((&(writer__)))->WriteSentinel(1313015779);
    IPC::WriteParam((&(writer__)), connInfoArgs);
    // Sentinel = 'connInfoArgs'
    ((&(writer__)))->WriteSentinel(521340104);
    IPC::WriteParam((&(writer__)), targetIpAddressSpace);
    // Sentinel = 'targetIpAddressSpace'
    ((&(writer__)))->WriteSentinel(1407846387);


    if (mozilla::ipc::LoggingEnabledFor("PHttpTransaction", mozilla::ipc::ChildSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PHttpTransactionChild",
            this->ToplevelProtocol()->OtherPidMaybeInvalid(),
            "Sending ",
            msg__->type(),
            mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PHttpTransaction::Msg_OnStartRequest", OTHER);

    bool sendok__ = ChannelSend(std::move(msg__));
    return sendok__;
}

auto PHttpTransactionChild::SendOnTransportStatus(
        const nsresult& status,
        const int64_t& progress,
        const int64_t& progressMax,
        const mozilla::Maybe<NetworkAddressArg>& networkAddressArg) -> bool
{
    UniquePtr<IPC::Message> msg__ = PHttpTransaction::Msg_OnTransportStatus(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), status);
    // Sentinel = 'status'
    ((&(writer__)))->WriteSentinel(154731173);
    IPC::WriteParam((&(writer__)), progress);
    // Sentinel = 'progress'
    ((&(writer__)))->WriteSentinel(261292918);
    IPC::WriteParam((&(writer__)), progressMax);
    // Sentinel = 'progressMax'
    ((&(writer__)))->WriteSentinel(471205020);
    IPC::WriteParam((&(writer__)), networkAddressArg);
    // Sentinel = 'networkAddressArg'
    ((&(writer__)))->WriteSentinel(1062471403);


    if (mozilla::ipc::LoggingEnabledFor("PHttpTransaction", mozilla::ipc::ChildSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PHttpTransactionChild",
            this->ToplevelProtocol()->OtherPidMaybeInvalid(),
            "Sending ",
            msg__->type(),
            mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PHttpTransaction::Msg_OnTransportStatus", OTHER);

    bool sendok__ = ChannelSend(std::move(msg__));
    return sendok__;
}

auto PHttpTransactionChild::SendOnDataAvailable(
        const nsACString& data,
        const uint64_t& offset,
        const TimeStamp& onDataAvailableStart) -> bool
{
    UniquePtr<IPC::Message> msg__ = PHttpTransaction::Msg_OnDataAvailable(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), data);
    // Sentinel = 'data'
    ((&(writer__)))->WriteSentinel(67109275);
    IPC::WriteParam((&(writer__)), offset);
    // Sentinel = 'offset'
    ((&(writer__)))->WriteSentinel(147653256);
    IPC::WriteParam((&(writer__)), onDataAvailableStart);
    // Sentinel = 'onDataAvailableStart'
    ((&(writer__)))->WriteSentinel(1369049063);


    if (mozilla::ipc::LoggingEnabledFor("PHttpTransaction", mozilla::ipc::ChildSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PHttpTransactionChild",
            this->ToplevelProtocol()->OtherPidMaybeInvalid(),
            "Sending ",
            msg__->type(),
            mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PHttpTransaction::Msg_OnDataAvailable", OTHER);

    bool sendok__ = ChannelSend(std::move(msg__));
    return sendok__;
}

auto PHttpTransactionChild::SendOnStopRequest(
        const nsresult& status,
        const bool& responseIsComplete,
        const int64_t& transferSize,
        const TimingStructArgs& timings,
        const mozilla::Maybe<nsHttpHeaderArray>& responseTrailers,
        const mozilla::Maybe<TransactionObserverResult>& transactionObserverResult,
        const TimeStamp& lastActiveTabOptimization,
        const TimeStamp& onStopRequestStart) -> bool
{
    UniquePtr<IPC::Message> msg__ = PHttpTransaction::Msg_OnStopRequest(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), status);
    // Sentinel = 'status'
    ((&(writer__)))->WriteSentinel(154731173);
    IPC::WriteParam((&(writer__)), responseIsComplete);
    // Sentinel = 'responseIsComplete'
    ((&(writer__)))->WriteSentinel(1188956005);
    IPC::WriteParam((&(writer__)), transferSize);
    // Sentinel = 'transferSize'
    ((&(writer__)))->WriteSentinel(551814401);
    IPC::WriteParam((&(writer__)), timings);
    // Sentinel = 'timings'
    ((&(writer__)))->WriteSentinel(200868604);
    IPC::WriteParam((&(writer__)), responseTrailers);
    // Sentinel = 'responseTrailers'
    ((&(writer__)))->WriteSentinel(961873590);
    IPC::WriteParam((&(writer__)), transactionObserverResult);
    // Sentinel = 'transactionObserverResult'
    ((&(writer__)))->WriteSentinel(2271873646);
    IPC::WriteParam((&(writer__)), lastActiveTabOptimization);
    // Sentinel = 'lastActiveTabOptimization'
    ((&(writer__)))->WriteSentinel(2190412335);
    IPC::WriteParam((&(writer__)), onStopRequestStart);
    // Sentinel = 'onStopRequestStart'
    ((&(writer__)))->WriteSentinel(1183909755);


    if (mozilla::ipc::LoggingEnabledFor("PHttpTransaction", mozilla::ipc::ChildSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PHttpTransactionChild",
            this->ToplevelProtocol()->OtherPidMaybeInvalid(),
            "Sending ",
            msg__->type(),
            mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PHttpTransaction::Msg_OnStopRequest", OTHER);

    bool sendok__ = ChannelSend(std::move(msg__));
    return sendok__;
}

auto PHttpTransactionChild::SendOnInitFailed(const nsresult& status) -> bool
{
    UniquePtr<IPC::Message> msg__ = PHttpTransaction::Msg_OnInitFailed(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), status);
    // Sentinel = 'status'
    ((&(writer__)))->WriteSentinel(154731173);


    if (mozilla::ipc::LoggingEnabledFor("PHttpTransaction", mozilla::ipc::ChildSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PHttpTransactionChild",
            this->ToplevelProtocol()->OtherPidMaybeInvalid(),
            "Sending ",
            msg__->type(),
            mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PHttpTransaction::Msg_OnInitFailed", OTHER);

    bool sendok__ = ChannelSend(std::move(msg__));
    return sendok__;
}

auto PHttpTransactionChild::SendEarlyHint(
        const nsACString& linkHeader,
        const nsACString& referrerPolicy,
        const nsACString& cspHeader) -> bool
{
    UniquePtr<IPC::Message> msg__ = PHttpTransaction::Msg_EarlyHint(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), linkHeader);
    // Sentinel = 'linkHeader'
    ((&(writer__)))->WriteSentinel(367330296);
    IPC::WriteParam((&(writer__)), referrerPolicy);
    // Sentinel = 'referrerPolicy'
    ((&(writer__)))->WriteSentinel(729482702);
    IPC::WriteParam((&(writer__)), cspHeader);
    // Sentinel = 'cspHeader'
    ((&(writer__)))->WriteSentinel(297862032);


    if (mozilla::ipc::LoggingEnabledFor("PHttpTransaction", mozilla::ipc::ChildSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PHttpTransactionChild",
            this->ToplevelProtocol()->OtherPidMaybeInvalid(),
            "Sending ",
            msg__->type(),
            mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PHttpTransaction::Msg_EarlyHint", OTHER);

    bool sendok__ = ChannelSend(std::move(msg__));
    return sendok__;
}

auto PHttpTransactionChild::DeallocManagee(
        mozilla::ipc::ProtocolId aProtocolId,
        IProtocol* aListener) -> void
{
    FatalError("unreached");
    return;
}

auto PHttpTransactionChild::OnMessageReceived(const Message& msg__) -> PHttpTransactionChild::Result
{
    if (!CanSend()) {
        if (mozilla::ipc::LoggingEnabledFor("PHttpTransaction", mozilla::ipc::ChildSide)) {
            mozilla::ipc::LogMessageForProtocol(
                "PHttpTransactionChild",
                this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                "Ignored message for dead actor",
                (&(msg__))->type(),
                mozilla::ipc::MessageDirection::eSending);
        }
        return MsgProcessed;

    }
    switch (msg__.type()) {
    case MANAGED_ENDPOINT_BOUND_MESSAGE_TYPE:
        {
            if (!mAwaitingManagedEndpointBind) {
                NS_WARNING("Unexpected managed endpoint lifecycle message after actor bound!");
                return MsgNotAllowed;
            }
            mAwaitingManagedEndpointBind = false;
            return MsgProcessed;
        }
    case MANAGED_ENDPOINT_DROPPED_MESSAGE_TYPE:
        {
            if (!mAwaitingManagedEndpointBind) {
                NS_WARNING("Unexpected managed endpoint lifecycle message after actor bound!");
                return MsgNotAllowed;
            }
            mAwaitingManagedEndpointBind = false;
            this->ActorDisconnected(ManagedEndpointDropped);
            return MsgProcessed;
        }
    case PHttpTransaction::Msg___delete____ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PHttpTransaction", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PHttpTransactionChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PHttpTransaction::Msg___delete__", OTHER);

            DoomSubtree();
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::net::HttpTransactionChild*>(this))->Recv__delete__();
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }


            this->ActorDisconnected(Deletion);

            return MsgProcessed;
        }
    case PHttpTransaction::Msg_Init__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PHttpTransaction", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PHttpTransactionChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PHttpTransaction::Msg_Init", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

            auto maybe__caps = IPC::ReadParam<uint32_t>((&(reader__)));
            if (!maybe__caps) {
                FatalError("Error deserializing 'uint32_t'");
                return MsgValueError;

            }
            auto& caps = *maybe__caps;
            // Sentinel = 'caps'
            if ((!(((&(reader__)))->ReadSentinel(67502504)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            auto maybe__aArgs = IPC::ReadParam<HttpConnectionInfoCloneArgs>((&(reader__)));
            if (!maybe__aArgs) {
                FatalError("Error deserializing 'HttpConnectionInfoCloneArgs'");
                return MsgValueError;

            }
            auto& aArgs = *maybe__aArgs;
            // Sentinel = 'aArgs'
            if ((!(((&(reader__)))->ReadSentinel(92602863)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'HttpConnectionInfoCloneArgs'");
                return MsgValueError;
            }
            auto maybe__reqHeaders = IPC::ReadParam<nsHttpRequestHead>((&(reader__)));
            if (!maybe__reqHeaders) {
                FatalError("Error deserializing 'nsHttpRequestHead'");
                return MsgValueError;

            }
            auto& reqHeaders = *maybe__reqHeaders;
            // Sentinel = 'reqHeaders'
            if ((!(((&(reader__)))->ReadSentinel(367264773)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsHttpRequestHead'");
                return MsgValueError;
            }
            auto maybe__requestBody = IPC::ReadParam<mozilla::Maybe<IPCStream>>((&(reader__)));
            if (!maybe__requestBody) {
                FatalError("Error deserializing 'IPCStream?'");
                return MsgValueError;

            }
            auto& requestBody = *maybe__requestBody;
            // Sentinel = 'requestBody'
            if ((!(((&(reader__)))->ReadSentinel(466814104)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'IPCStream?'");
                return MsgValueError;
            }
            auto maybe__reqContentLength = IPC::ReadParam<uint64_t>((&(reader__)));
            if (!maybe__reqContentLength) {
                FatalError("Error deserializing 'uint64_t'");
                return MsgValueError;

            }
            auto& reqContentLength = *maybe__reqContentLength;
            // Sentinel = 'reqContentLength'
            if ((!(((&(reader__)))->ReadSentinel(927794822)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
                return MsgValueError;
            }
            auto maybe__requestBodyIsStreaming = IPC::ReadParam<bool>((&(reader__)));
            if (!maybe__requestBodyIsStreaming) {
                FatalError("Error deserializing 'bool'");
                return MsgValueError;

            }
            auto& requestBodyIsStreaming = *maybe__requestBodyIsStreaming;
            // Sentinel = 'requestBodyIsStreaming'
            if ((!(((&(reader__)))->ReadSentinel(1746536702)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
                return MsgValueError;
            }
            auto maybe__topLevelOuterContentWindowId = IPC::ReadParam<uint64_t>((&(reader__)));
            if (!maybe__topLevelOuterContentWindowId) {
                FatalError("Error deserializing 'uint64_t'");
                return MsgValueError;

            }
            auto& topLevelOuterContentWindowId = *maybe__topLevelOuterContentWindowId;
            // Sentinel = 'topLevelOuterContentWindowId'
            if ((!(((&(reader__)))->ReadSentinel(2779974491)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
                return MsgValueError;
            }
            auto maybe__httpTrafficCategory = IPC::ReadParam<HttpTrafficCategory>((&(reader__)));
            if (!maybe__httpTrafficCategory) {
                FatalError("Error deserializing 'HttpTrafficCategory'");
                return MsgValueError;

            }
            auto& httpTrafficCategory = *maybe__httpTrafficCategory;
            // Sentinel = 'httpTrafficCategory'
            if ((!(((&(reader__)))->ReadSentinel(1295058878)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'HttpTrafficCategory'");
                return MsgValueError;
            }
            auto maybe__requestContextID = IPC::ReadParam<uint64_t>((&(reader__)));
            if (!maybe__requestContextID) {
                FatalError("Error deserializing 'uint64_t'");
                return MsgValueError;

            }
            auto& requestContextID = *maybe__requestContextID;
            // Sentinel = 'requestContextID'
            if ((!(((&(reader__)))->ReadSentinel(956761724)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
                return MsgValueError;
            }
            auto maybe__classOfService = IPC::ReadParam<ClassOfService>((&(reader__)));
            if (!maybe__classOfService) {
                FatalError("Error deserializing 'ClassOfService'");
                return MsgValueError;

            }
            auto& classOfService = *maybe__classOfService;
            // Sentinel = 'classOfService'
            if ((!(((&(reader__)))->ReadSentinel(704710045)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'ClassOfService'");
                return MsgValueError;
            }
            auto maybe__initialRwin = IPC::ReadParam<uint32_t>((&(reader__)));
            if (!maybe__initialRwin) {
                FatalError("Error deserializing 'uint32_t'");
                return MsgValueError;

            }
            auto& initialRwin = *maybe__initialRwin;
            // Sentinel = 'initialRwin'
            if ((!(((&(reader__)))->ReadSentinel(458818699)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            auto maybe__responseTimeoutEnabled = IPC::ReadParam<bool>((&(reader__)));
            if (!maybe__responseTimeoutEnabled) {
                FatalError("Error deserializing 'bool'");
                return MsgValueError;

            }
            auto& responseTimeoutEnabled = *maybe__responseTimeoutEnabled;
            // Sentinel = 'responseTimeoutEnabled'
            if ((!(((&(reader__)))->ReadSentinel(1769408770)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
                return MsgValueError;
            }
            auto maybe__channelId = IPC::ReadParam<uint64_t>((&(reader__)));
            if (!maybe__channelId) {
                FatalError("Error deserializing 'uint64_t'");
                return MsgValueError;

            }
            auto& channelId = *maybe__channelId;
            // Sentinel = 'channelId'
            if ((!(((&(reader__)))->ReadSentinel(301138823)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
                return MsgValueError;
            }
            auto maybe__hasTransactionObserver = IPC::ReadParam<bool>((&(reader__)));
            if (!maybe__hasTransactionObserver) {
                FatalError("Error deserializing 'bool'");
                return MsgValueError;

            }
            auto& hasTransactionObserver = *maybe__hasTransactionObserver;
            // Sentinel = 'hasTransactionObserver'
            if ((!(((&(reader__)))->ReadSentinel(1727531275)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
                return MsgValueError;
            }
            auto maybe__throttleQueue = IPC::ReadParam<mozilla::Maybe<mozilla::NotNull<PInputChannelThrottleQueueChild*>>>((&(reader__)));
            if (!maybe__throttleQueue) {
                FatalError("Error deserializing 'NotNull<PInputChannelThrottleQueue>?'");
                return MsgValueError;

            }
            auto& throttleQueue = *maybe__throttleQueue;
            // Sentinel = 'throttleQueue'
            if ((!(((&(reader__)))->ReadSentinel(653919612)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'NotNull<PInputChannelThrottleQueue>?'");
                return MsgValueError;
            }
            auto maybe__aIsDocumentLoad = IPC::ReadParam<bool>((&(reader__)));
            if (!maybe__aIsDocumentLoad) {
                FatalError("Error deserializing 'bool'");
                return MsgValueError;

            }
            auto& aIsDocumentLoad = *maybe__aIsDocumentLoad;
            // Sentinel = 'aIsDocumentLoad'
            if ((!(((&(reader__)))->ReadSentinel(774440413)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
                return MsgValueError;
            }
            auto maybe__aParentIPAddressSpace = IPC::ReadParam<IPAddressSpace>((&(reader__)));
            if (!maybe__aParentIPAddressSpace) {
                FatalError("Error deserializing 'IPAddressSpace'");
                return MsgValueError;

            }
            auto& aParentIPAddressSpace = *maybe__aParentIPAddressSpace;
            // Sentinel = 'aParentIPAddressSpace'
            if ((!(((&(reader__)))->ReadSentinel(1474168855)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'IPAddressSpace'");
                return MsgValueError;
            }
            auto maybe__aLnaPermissionStatus = IPC::ReadParam<LNAPerms>((&(reader__)));
            if (!maybe__aLnaPermissionStatus) {
                FatalError("Error deserializing 'LNAPerms'");
                return MsgValueError;

            }
            auto& aLnaPermissionStatus = *maybe__aLnaPermissionStatus;
            // Sentinel = 'aLnaPermissionStatus'
            if ((!(((&(reader__)))->ReadSentinel(1394739242)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'LNAPerms'");
                return MsgValueError;
            }
            auto maybe__aRedirectStart = IPC::ReadParam<TimeStamp>((&(reader__)));
            if (!maybe__aRedirectStart) {
                FatalError("Error deserializing 'TimeStamp'");
                return MsgValueError;

            }
            auto& aRedirectStart = *maybe__aRedirectStart;
            // Sentinel = 'aRedirectStart'
            if ((!(((&(reader__)))->ReadSentinel(690554274)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'TimeStamp'");
                return MsgValueError;
            }
            auto maybe__aRedirectEnd = IPC::ReadParam<TimeStamp>((&(reader__)));
            if (!maybe__aRedirectEnd) {
                FatalError("Error deserializing 'TimeStamp'");
                return MsgValueError;

            }
            auto& aRedirectEnd = *maybe__aRedirectEnd;
            // Sentinel = 'aRedirectEnd'
            if ((!(((&(reader__)))->ReadSentinel(505808043)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'TimeStamp'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::net::HttpTransactionChild*>(this))->RecvInit(std::move(caps), std::move(aArgs), std::move(reqHeaders), std::move(requestBody), std::move(reqContentLength), std::move(requestBodyIsStreaming), std::move(topLevelOuterContentWindowId), std::move(httpTrafficCategory), std::move(requestContextID), std::move(classOfService), std::move(initialRwin), std::move(responseTimeoutEnabled), std::move(channelId), std::move(hasTransactionObserver), std::move(throttleQueue), std::move(aIsDocumentLoad), std::move(aParentIPAddressSpace), std::move(aLnaPermissionStatus), std::move(aRedirectStart), std::move(aRedirectEnd));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PHttpTransaction::Msg_CancelPump__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PHttpTransaction", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PHttpTransactionChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PHttpTransaction::Msg_CancelPump", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

            auto maybe__status = IPC::ReadParam<nsresult>((&(reader__)));
            if (!maybe__status) {
                FatalError("Error deserializing 'nsresult'");
                return MsgValueError;

            }
            auto& status = *maybe__status;
            // Sentinel = 'status'
            if ((!(((&(reader__)))->ReadSentinel(154731173)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsresult'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::net::HttpTransactionChild*>(this))->RecvCancelPump(std::move(status));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PHttpTransaction::Msg_SuspendPump__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PHttpTransaction", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PHttpTransactionChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PHttpTransaction::Msg_SuspendPump", OTHER);

            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::net::HttpTransactionChild*>(this))->RecvSuspendPump();
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PHttpTransaction::Msg_ResumePump__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PHttpTransaction", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PHttpTransactionChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PHttpTransaction::Msg_ResumePump", OTHER);

            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::net::HttpTransactionChild*>(this))->RecvResumePump();
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PHttpTransaction::Msg_SetDNSWasRefreshed__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PHttpTransaction", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PHttpTransactionChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PHttpTransaction::Msg_SetDNSWasRefreshed", OTHER);

            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::net::HttpTransactionChild*>(this))->RecvSetDNSWasRefreshed();
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PHttpTransaction::Msg_DontReuseConnection__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PHttpTransaction", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PHttpTransactionChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PHttpTransaction::Msg_DontReuseConnection", OTHER);

            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::net::HttpTransactionChild*>(this))->RecvDontReuseConnection();
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PHttpTransaction::Msg_SetH2WSConnRefTaken__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PHttpTransaction", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PHttpTransactionChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PHttpTransaction::Msg_SetH2WSConnRefTaken", OTHER);

            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::net::HttpTransactionChild*>(this))->RecvSetH2WSConnRefTaken();
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    default:
        return MsgNotKnown;
    }
}

auto PHttpTransactionChild::OnMessageReceived(
        const Message& msg__,
        UniquePtr<Message>& reply__) -> PHttpTransactionChild::Result
{
    if (!CanSend()) {
        return MsgDropped;

    }
    return MsgNotKnown;
}



} // namespace net
} // namespace mozilla