PHttpTransactionChild.cpp

mozilla-central/__GENERATED__/ipc/ipdl/PHttpTransactionChild.cpp (file symbol)

Enable keyboard shortcuts

Copy as Markdown

Other Tools

//

// 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/DomSecurityIPCUtils.h"

#include "mozilla/dom/FeaturePolicyUtils.h"

#include "mozilla/dom/FetchIPCTypes.h"

#include "mozilla/dom/PropertyBagUtils.h"

#include "mozilla/dom/ReferrerInfoUtils.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/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,

        const int32_t& proxyConnectResponseCode,

        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) -> 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__)), proxyConnectResponseCode);

    // Sentinel = 'proxyConnectResponseCode'

    ((&(writer__)))->WriteSentinel(2099382743);

    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);

    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 uint32_t& count,

        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__)), count);

    // Sentinel = 'count'

    ((&(writer__)))->WriteSentinel(106889770);

    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 HttpConnectionInfoCloneArgs& connInfoArgs,

        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__)), connInfoArgs);

    // Sentinel = 'connInfoArgs'

    ((&(writer__)))->WriteSentinel(521340104);

    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::SendOnH2PushStream(

        const uint32_t& pushedStreamId,

        const nsACString& resourceUrl,

        const nsACString& requestString) -> bool

    UniquePtr<IPC::Message> msg__ = PHttpTransaction::Msg_OnH2PushStream(Id());

    IPC::MessageWriter writer__{

            (*(msg__)),

            this};

    IPC::WriteParam((&(writer__)), pushedStreamId);

    // Sentinel = 'pushedStreamId'

    ((&(writer__)))->WriteSentinel(731579811);

    IPC::WriteParam((&(writer__)), resourceUrl);

    // Sentinel = 'resourceUrl'

    ((&(writer__)))->WriteSentinel(471270556);

    IPC::WriteParam((&(writer__)), requestString);

    // Sentinel = 'requestString'

    ((&(writer__)))->WriteSentinel(650970497);

    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_OnH2PushStream", 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(

        int32_t aProtocolId,

        IProtocol* aListener) -> void

    FatalError("unreached");

    return;

auto PHttpTransactionChild::OnMessageReceived(const Message& msg__) -> PHttpTransactionChild::Result

    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);

            mozilla::ipc::IPCResult __ok = (static_cast<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__reqBodyIncludesHeaders = IPC::ReadParam<bool>((&(reader__)));

            if (!maybe__reqBodyIncludesHeaders) {

                FatalError("Error deserializing 'bool'");

                return MsgValueError;

            auto& reqBodyIncludesHeaders = *maybe__reqBodyIncludesHeaders;

            // Sentinel = 'reqBodyIncludesHeaders'

            if ((!(((&(reader__)))->ReadSentinel(1689127114)))) {

                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<uint8_t>((&(reader__)));

            if (!maybe__httpTrafficCategory) {

                FatalError("Error deserializing 'uint8_t'");

                return MsgValueError;

            auto& httpTrafficCategory = *maybe__httpTrafficCategory;

            // Sentinel = 'httpTrafficCategory'

            if ((!(((&(reader__)))->ReadSentinel(1295058878)))) {

                mozilla::ipc::SentinelReadError("Error deserializing 'uint8_t'");

                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__pushedStreamArg = IPC::ReadParam<mozilla::Maybe<H2PushedStreamArg>>((&(reader__)));

            if (!maybe__pushedStreamArg) {

                FatalError("Error deserializing 'H2PushedStreamArg?'");

                return MsgValueError;

            auto& pushedStreamArg = *maybe__pushedStreamArg;

            // Sentinel = 'pushedStreamArg'

            if ((!(((&(reader__)))->ReadSentinel(833160720)))) {

                mozilla::ipc::SentinelReadError("Error deserializing 'H2PushedStreamArg?'");

                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__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<HttpTransactionChild*>(this))->RecvInit(std::move(caps), std::move(aArgs), std::move(reqHeaders), std::move(requestBody), std::move(reqContentLength), std::move(reqBodyIncludesHeaders), 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(pushedStreamArg), std::move(throttleQueue), std::move(aIsDocumentLoad), 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<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<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<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<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<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<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

    return MsgNotKnown;

} // namespace net

} // namespace mozilla

namespace IPC {

auto ParamTraits<::mozilla::net::PHttpTransactionChild*>::Write(

        IPC::MessageWriter* aWriter,

        const paramType& aVar) -> void

    MOZ_RELEASE_ASSERT(

        aWriter->GetActor(),

        "Cannot serialize managed actors without an actor");

    int32_t id;

    if (!aVar) {

        id = 0;  // kNullActorId

    } else {

        id = aVar->Id();

        if (id == 1) {  // kFreedActorId

            aVar->FatalError("Actor has been |delete|d");

        MOZ_RELEASE_ASSERT(

            aWriter->GetActor()->GetIPCChannel() == aVar->GetIPCChannel(),

            "Actor must be from the same channel as the"

            " actor it's being sent over");

        MOZ_RELEASE_ASSERT(

            aVar->CanSend(),

            "Actor must still be open when sending");

    IPC::WriteParam(aWriter, id);

auto ParamTraits<::mozilla::net::PHttpTransactionChild*>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>

    MOZ_RELEASE_ASSERT(

        aReader->GetActor(),

        "Cannot deserialize managed actors without an actor");

    mozilla::Maybe<mozilla::ipc::IProtocol*> actor = aReader->GetActor()

        ->ReadActor(aReader, true, "PHttpTransaction", PHttpTransactionMsgStart);

    if (actor.isSome()) {

        return static_cast<::mozilla::net::PHttpTransactionChild*>(actor.ref());

    return {};

} // namespace IPC