//

// Automatically generated by ipdlc.

// Edit at your own risk

//

#include "mozilla/net/PHttpChannelParent.h"

#include "mozilla/net/TimingStruct.h"

#include "nsHttpHeaderArray.h"

#include "mozilla/net/PNeckoParent.h"

#include "mozilla/extensions/PStreamFilterParent.h"

#include "nsIFile.h"

#include "GeckoProfiler.h"

namespace mozilla {

namespace net {

auto PHttpChannelParent::Recv__delete__() -> mozilla::ipc::IPCResult

{

    return IPC_OK();

}

auto PHttpChannelParent::ActorDestroy(ActorDestroyReason aWhy) -> void

{

}

MOZ_IMPLICIT PHttpChannelParent::PHttpChannelParent() :

    mozilla::ipc::IProtocol(mozilla::ipc::ParentSide),

    mLivenessState(mozilla::ipc::LivenessState::Dead)

{

    MOZ_COUNT_CTOR(PHttpChannelParent);

}

PHttpChannelParent::~PHttpChannelParent()

{

    MOZ_COUNT_DTOR(PHttpChannelParent);

}

auto PHttpChannelParent::Manager() const -> PNeckoParent*

{

    return static_cast<PNeckoParent*>(IProtocol::Manager());

}

auto PHttpChannelParent::SendOnStartRequest(

        const nsresult& channelStatus,

        const nsHttpResponseHead& responseHead,

        const bool& useResponseHead,

        const nsHttpHeaderArray& requestHeaders,

        const ParentLoadInfoForwarderArgs& loadInfoForwarder,

        const bool& isFromCache,

        const bool& cacheEntryAvailable,

        const uint64_t& cacheEntryId,

        const int32_t& cacheFetchCount,

        const uint32_t& cacheExpirationTime,

        const nsCString& cachedCharset,

        const nsCString& securityInfoSerialization,

        const NetAddr& selfAddr,

        const NetAddr& peerAddr,

        const int16_t& redirectCount,

        const uint32_t& cacheKey,

        const nsCString& altDataType,

        const int64_t& altDataLength,

        const bool& applyConversion,

        const ResourceTimingStruct& timing) -> bool

{

    IPC::Message* msg__ = PHttpChannel::Msg_OnStartRequest(Id());

    WriteIPDLParam(msg__, this, channelStatus);

    // Sentinel = 'channelStatus'

    (msg__)->WriteSentinel(3148019746);

    WriteIPDLParam(msg__, this, responseHead);

    // Sentinel = 'responseHead'

    (msg__)->WriteSentinel(3038698187);

    WriteIPDLParam(msg__, this, useResponseHead);

    // Sentinel = 'useResponseHead'

    (msg__)->WriteSentinel(2994626489);

    WriteIPDLParam(msg__, this, requestHeaders);

    // Sentinel = 'requestHeaders'

    (msg__)->WriteSentinel(2055989545);

    WriteIPDLParam(msg__, this, loadInfoForwarder);

    // Sentinel = 'loadInfoForwarder'

    (msg__)->WriteSentinel(2195128043);

    WriteIPDLParam(msg__, this, isFromCache);

    // Sentinel = 'isFromCache'

    (msg__)->WriteSentinel(4089953117);

    WriteIPDLParam(msg__, this, cacheEntryAvailable);

    // Sentinel = 'cacheEntryAvailable'

    (msg__)->WriteSentinel(2363064);

    WriteIPDLParam(msg__, this, cacheEntryId);

    // Sentinel = 'cacheEntryId'

    (msg__)->WriteSentinel(3383493417);

    WriteIPDLParam(msg__, this, cacheFetchCount);

    // Sentinel = 'cacheFetchCount'

    (msg__)->WriteSentinel(2824496928);

    WriteIPDLParam(msg__, this, cacheExpirationTime);

    // Sentinel = 'cacheExpirationTime'

    (msg__)->WriteSentinel(439162213);

    WriteIPDLParam(msg__, this, cachedCharset);

    // Sentinel = 'cachedCharset'

    (msg__)->WriteSentinel(1570160399);

    WriteIPDLParam(msg__, this, securityInfoSerialization);

    // Sentinel = 'securityInfoSerialization'

    (msg__)->WriteSentinel(985832975);

    WriteIPDLParam(msg__, this, selfAddr);

    // Sentinel = 'selfAddr'

    (msg__)->WriteSentinel(463888251);

    WriteIPDLParam(msg__, this, peerAddr);

    // Sentinel = 'peerAddr'

    (msg__)->WriteSentinel(1373265573);

    WriteIPDLParam(msg__, this, redirectCount);

    // Sentinel = 'redirectCount'

    (msg__)->WriteSentinel(1874411984);

    WriteIPDLParam(msg__, this, cacheKey);

    // Sentinel = 'cacheKey'

    (msg__)->WriteSentinel(249191363);

    WriteIPDLParam(msg__, this, altDataType);

    // Sentinel = 'altDataType'

    (msg__)->WriteSentinel(2339988114);

    WriteIPDLParam(msg__, this, altDataLength);

    // Sentinel = 'altDataLength'

    (msg__)->WriteSentinel(2685793220);

    WriteIPDLParam(msg__, this, applyConversion);

    // Sentinel = 'applyConversion'

    (msg__)->WriteSentinel(2539641483);

    WriteIPDLParam(msg__, this, timing);

    // Sentinel = 'timing'

    (msg__)->WriteSentinel(3852786776);

    if (mozilla::ipc::LoggingEnabledFor("PHttpChannelParent")) {

        mozilla::ipc::LogMessageForProtocol("PHttpChannelParent", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);

    }

    AUTO_PROFILER_LABEL("PHttpChannel::Msg_OnStartRequest", OTHER);

    if ((!(StateTransition(false, (&(mLivenessState)))))) {

        mozilla::ipc::LogicError("Transition error");

    }

    bool sendok__ = (GetIPCChannel())->Send(msg__);

    return sendok__;

}

auto PHttpChannelParent::SendFailedAsyncOpen(const nsresult& status) -> bool

{

    IPC::Message* msg__ = PHttpChannel::Msg_FailedAsyncOpen(Id());

    WriteIPDLParam(msg__, this, status);

    // Sentinel = 'status'

    (msg__)->WriteSentinel(3714608576);

    if (mozilla::ipc::LoggingEnabledFor("PHttpChannelParent")) {

        mozilla::ipc::LogMessageForProtocol("PHttpChannelParent", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);

    }

    AUTO_PROFILER_LABEL("PHttpChannel::Msg_FailedAsyncOpen", OTHER);

    if ((!(StateTransition(false, (&(mLivenessState)))))) {

        mozilla::ipc::LogicError("Transition error");

    }

    bool sendok__ = (GetIPCChannel())->Send(msg__);

    return sendok__;

}

auto PHttpChannelParent::SendRedirect1Begin(

        const uint32_t& registrarId,

        const URIParams& newOriginalUri,

        const uint32_t& newLoadFlags,

        const uint32_t& redirectFlags,

        const ParentLoadInfoForwarderArgs& loadInfoForwarder,

        const nsHttpResponseHead& responseHead,

        const nsCString& securityInfoSerialization,

        const uint64_t& channelId,

        const NetAddr& oldPeerAddr) -> bool

{

    IPC::Message* msg__ = PHttpChannel::Msg_Redirect1Begin(Id());

    WriteIPDLParam(msg__, this, registrarId);

    // Sentinel = 'registrarId'

    (msg__)->WriteSentinel(3202787989);

    WriteIPDLParam(msg__, this, newOriginalUri);

    // Sentinel = 'newOriginalUri'

    (msg__)->WriteSentinel(361019297);

    WriteIPDLParam(msg__, this, newLoadFlags);

    // Sentinel = 'newLoadFlags'

    (msg__)->WriteSentinel(2873639103);

    WriteIPDLParam(msg__, this, redirectFlags);

    // Sentinel = 'redirectFlags'

    (msg__)->WriteSentinel(286770900);

    WriteIPDLParam(msg__, this, loadInfoForwarder);

    // Sentinel = 'loadInfoForwarder'

    (msg__)->WriteSentinel(2195128043);

    WriteIPDLParam(msg__, this, responseHead);

    // Sentinel = 'responseHead'

    (msg__)->WriteSentinel(3038698187);

    WriteIPDLParam(msg__, this, securityInfoSerialization);

    // Sentinel = 'securityInfoSerialization'

    (msg__)->WriteSentinel(985832975);

    WriteIPDLParam(msg__, this, channelId);

    // Sentinel = 'channelId'

    (msg__)->WriteSentinel(6854027);

    WriteIPDLParam(msg__, this, oldPeerAddr);

    // Sentinel = 'oldPeerAddr'

    (msg__)->WriteSentinel(1696652009);

    if (mozilla::ipc::LoggingEnabledFor("PHttpChannelParent")) {

        mozilla::ipc::LogMessageForProtocol("PHttpChannelParent", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);

    }

    AUTO_PROFILER_LABEL("PHttpChannel::Msg_Redirect1Begin", OTHER);

    if ((!(StateTransition(false, (&(mLivenessState)))))) {

        mozilla::ipc::LogicError("Transition error");

    }

    bool sendok__ = (GetIPCChannel())->Send(msg__);

    return sendok__;

}

auto PHttpChannelParent::SendRedirect3Complete() -> bool

{

    IPC::Message* msg__ = PHttpChannel::Msg_Redirect3Complete(Id());

    if (mozilla::ipc::LoggingEnabledFor("PHttpChannelParent")) {

        mozilla::ipc::LogMessageForProtocol("PHttpChannelParent", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);

    }

    AUTO_PROFILER_LABEL("PHttpChannel::Msg_Redirect3Complete", OTHER);

    if ((!(StateTransition(false, (&(mLivenessState)))))) {

        mozilla::ipc::LogicError("Transition error");

    }

    bool sendok__ = (GetIPCChannel())->Send(msg__);

    return sendok__;

}

auto PHttpChannelParent::SendAssociateApplicationCache(

        const nsCString& groupID,

        const nsCString& clientID) -> bool

{

    IPC::Message* msg__ = PHttpChannel::Msg_AssociateApplicationCache(Id());

    WriteIPDLParam(msg__, this, groupID);

    // Sentinel = 'groupID'

    (msg__)->WriteSentinel(2673822077);

    WriteIPDLParam(msg__, this, clientID);

    // Sentinel = 'clientID'

    (msg__)->WriteSentinel(3831418318);

    if (mozilla::ipc::LoggingEnabledFor("PHttpChannelParent")) {

        mozilla::ipc::LogMessageForProtocol("PHttpChannelParent", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);

    }

    AUTO_PROFILER_LABEL("PHttpChannel::Msg_AssociateApplicationCache", OTHER);

    if ((!(StateTransition(false, (&(mLivenessState)))))) {

        mozilla::ipc::LogicError("Transition error");

    }

    bool sendok__ = (GetIPCChannel())->Send(msg__);

    return sendok__;

}

auto PHttpChannelParent::SendReportSecurityMessage(

        const nsString& messageTag,

        const nsString& messageCategory) -> bool

{

    IPC::Message* msg__ = PHttpChannel::Msg_ReportSecurityMessage(Id());

    WriteIPDLParam(msg__, this, messageTag);

    // Sentinel = 'messageTag'

    (msg__)->WriteSentinel(1576364117);

    WriteIPDLParam(msg__, this, messageCategory);

    // Sentinel = 'messageCategory'

    (msg__)->WriteSentinel(3375428022);

    if (mozilla::ipc::LoggingEnabledFor("PHttpChannelParent")) {

        mozilla::ipc::LogMessageForProtocol("PHttpChannelParent", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);

    }

    AUTO_PROFILER_LABEL("PHttpChannel::Msg_ReportSecurityMessage", OTHER);

    if ((!(StateTransition(false, (&(mLivenessState)))))) {

        mozilla::ipc::LogicError("Transition error");

    }

    bool sendok__ = (GetIPCChannel())->Send(msg__);

    return sendok__;

}

auto PHttpChannelParent::SendCancelRedirected() -> bool

{

    IPC::Message* msg__ = PHttpChannel::Msg_CancelRedirected(Id());

    if (mozilla::ipc::LoggingEnabledFor("PHttpChannelParent")) {

        mozilla::ipc::LogMessageForProtocol("PHttpChannelParent", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);

    }

    AUTO_PROFILER_LABEL("PHttpChannel::Msg_CancelRedirected", OTHER);

    if ((!(StateTransition(false, (&(mLivenessState)))))) {

        mozilla::ipc::LogicError("Transition error");

    }

    bool sendok__ = (GetIPCChannel())->Send(msg__);

    return sendok__;

}

auto PHttpChannelParent::SendDeleteSelf() -> bool

{

    IPC::Message* msg__ = PHttpChannel::Msg_DeleteSelf(Id());

    if (mozilla::ipc::LoggingEnabledFor("PHttpChannelParent")) {

        mozilla::ipc::LogMessageForProtocol("PHttpChannelParent", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);

    }

    AUTO_PROFILER_LABEL("PHttpChannel::Msg_DeleteSelf", OTHER);

    if ((!(StateTransition(false, (&(mLivenessState)))))) {

        mozilla::ipc::LogicError("Transition error");

    }

    bool sendok__ = (GetIPCChannel())->Send(msg__);

    return sendok__;

}

auto PHttpChannelParent::SendIssueDeprecationWarning(

        const uint32_t& warning,

        const bool& asError) -> bool

{

    IPC::Message* msg__ = PHttpChannel::Msg_IssueDeprecationWarning(Id());

    WriteIPDLParam(msg__, this, warning);

    // Sentinel = 'warning'

    (msg__)->WriteSentinel(3208968083);

    WriteIPDLParam(msg__, this, asError);

    // Sentinel = 'asError'

    (msg__)->WriteSentinel(4187201829);

    if (mozilla::ipc::LoggingEnabledFor("PHttpChannelParent")) {

        mozilla::ipc::LogMessageForProtocol("PHttpChannelParent", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);

    }

    AUTO_PROFILER_LABEL("PHttpChannel::Msg_IssueDeprecationWarning", OTHER);

    if ((!(StateTransition(false, (&(mLivenessState)))))) {

        mozilla::ipc::LogicError("Transition error");

    }

    bool sendok__ = (GetIPCChannel())->Send(msg__);

    return sendok__;

}

auto PHttpChannelParent::SendLogBlockedCORSRequest(

        const nsString& message,

        const nsCString& category) -> bool

{

    IPC::Message* msg__ = PHttpChannel::Msg_LogBlockedCORSRequest(Id());

    WriteIPDLParam(msg__, this, message);

    // Sentinel = 'message'

    (msg__)->WriteSentinel(1366108954);

    WriteIPDLParam(msg__, this, category);

    // Sentinel = 'category'

    (msg__)->WriteSentinel(1962932896);

    if (mozilla::ipc::LoggingEnabledFor("PHttpChannelParent")) {

        mozilla::ipc::LogMessageForProtocol("PHttpChannelParent", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);

    }

    AUTO_PROFILER_LABEL("PHttpChannel::Msg_LogBlockedCORSRequest", OTHER);

    if ((!(StateTransition(false, (&(mLivenessState)))))) {

        mozilla::ipc::LogicError("Transition error");

    }

    bool sendok__ = (GetIPCChannel())->Send(msg__);

    return sendok__;

}

auto PHttpChannelParent::SendAttachStreamFilter(const Endpoint<mozilla::extensions::PStreamFilterParent>& aEndpoint) -> bool

{

    IPC::Message* msg__ = PHttpChannel::Msg_AttachStreamFilter(Id());

    WriteIPDLParam(msg__, this, aEndpoint);

    // Sentinel = 'aEndpoint'

    (msg__)->WriteSentinel(2457438235);

    if (mozilla::ipc::LoggingEnabledFor("PHttpChannelParent")) {

        mozilla::ipc::LogMessageForProtocol("PHttpChannelParent", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);

    }

    AUTO_PROFILER_LABEL("PHttpChannel::Msg_AttachStreamFilter", OTHER);

    if ((!(StateTransition(false, (&(mLivenessState)))))) {

        mozilla::ipc::LogicError("Transition error");

    }

    bool sendok__ = (GetIPCChannel())->Send(msg__);

    return sendok__;

}

auto PHttpChannelParent::SendCancelDiversion() -> bool

{

    IPC::Message* msg__ = PHttpChannel::Msg_CancelDiversion(Id());

    if (mozilla::ipc::LoggingEnabledFor("PHttpChannelParent")) {

        mozilla::ipc::LogMessageForProtocol("PHttpChannelParent", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);

    }

    AUTO_PROFILER_LABEL("PHttpChannel::Msg_CancelDiversion", OTHER);

    if ((!(StateTransition(false, (&(mLivenessState)))))) {

        mozilla::ipc::LogicError("Transition error");

    }

    bool sendok__ = (GetIPCChannel())->Send(msg__);

    return sendok__;

}

auto PHttpChannelParent::SendFinishInterceptedRedirect() -> bool

{

    IPC::Message* msg__ = PHttpChannel::Msg_FinishInterceptedRedirect(Id());

    if (mozilla::ipc::LoggingEnabledFor("PHttpChannelParent")) {

        mozilla::ipc::LogMessageForProtocol("PHttpChannelParent", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);

    }

    AUTO_PROFILER_LABEL("PHttpChannel::Msg_FinishInterceptedRedirect", OTHER);

    if ((!(StateTransition(false, (&(mLivenessState)))))) {

        mozilla::ipc::LogicError("Transition error");

    }

    bool sendok__ = (GetIPCChannel())->Send(msg__);

    return sendok__;

}

auto PHttpChannelParent::SendSetPriority(const int16_t& priority) -> bool

{

    IPC::Message* msg__ = PHttpChannel::Msg_SetPriority(Id());

    WriteIPDLParam(msg__, this, priority);

    // Sentinel = 'priority'

    (msg__)->WriteSentinel(558136112);

    if (mozilla::ipc::LoggingEnabledFor("PHttpChannelParent")) {

        mozilla::ipc::LogMessageForProtocol("PHttpChannelParent", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);

    }

    AUTO_PROFILER_LABEL("PHttpChannel::Msg_SetPriority", OTHER);

    if ((!(StateTransition(false, (&(mLivenessState)))))) {

        mozilla::ipc::LogicError("Transition error");

    }

    bool sendok__ = (GetIPCChannel())->Send(msg__);

    return sendok__;

}

auto PHttpChannelParent::RemoveManagee(

        int32_t aProtocolId,

        IProtocol* aListener) -> void

{

    FatalError("unreached");

    return;

}

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

{

    switch ((msg__).type()) {

    case PHttpChannel::Msg_SetClassOfService__ID:

        {

            if (mozilla::ipc::LoggingEnabledFor("PHttpChannelParent")) {

                mozilla::ipc::LogMessageForProtocol("PHttpChannelParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);

            }

            AUTO_PROFILER_LABEL("PHttpChannel::Msg_SetClassOfService", OTHER);

            PickleIterator iter__(msg__);

            uint32_t cos;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(cos)))))) {

                FatalError("Error deserializing 'uint32_t'");

                return MsgValueError;

            }

            // Sentinel = 'cos'

            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 403875042)))) {

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

                return MsgValueError;

            }

            (msg__).EndRead(iter__, (msg__).type());

            if ((!(StateTransition(false, (&(mLivenessState)))))) {

                FatalError("Transition error");

                return MsgValueError;

            }

            if ((!(RecvSetClassOfService(cos)))) {

                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");

                // Error handled in mozilla::ipc::IPCResult

                return MsgProcessingError;

            }

            return MsgProcessed;

        }

    case PHttpChannel::Msg_SetCacheTokenCachedCharset__ID:

        {

            if (mozilla::ipc::LoggingEnabledFor("PHttpChannelParent")) {

                mozilla::ipc::LogMessageForProtocol("PHttpChannelParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);

            }

            AUTO_PROFILER_LABEL("PHttpChannel::Msg_SetCacheTokenCachedCharset", OTHER);

            PickleIterator iter__(msg__);

            nsCString charset;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(charset)))))) {

                FatalError("Error deserializing 'nsCString'");

                return MsgValueError;

            }

            // Sentinel = 'charset'

            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 1551550891)))) {

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

                return MsgValueError;

            }

            (msg__).EndRead(iter__, (msg__).type());

            if ((!(StateTransition(false, (&(mLivenessState)))))) {

                FatalError("Transition error");

                return MsgValueError;

            }

            if ((!(RecvSetCacheTokenCachedCharset(charset)))) {

                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");

                // Error handled in mozilla::ipc::IPCResult

                return MsgProcessingError;

            }

            return MsgProcessed;

        }

    case PHttpChannel::Msg_Suspend__ID:

        {

            if (mozilla::ipc::LoggingEnabledFor("PHttpChannelParent")) {

                mozilla::ipc::LogMessageForProtocol("PHttpChannelParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);

            }

            AUTO_PROFILER_LABEL("PHttpChannel::Msg_Suspend", OTHER);

            if ((!(StateTransition(false, (&(mLivenessState)))))) {

                FatalError("Transition error");

                return MsgValueError;

            }

            if ((!(RecvSuspend()))) {

                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");

                // Error handled in mozilla::ipc::IPCResult

                return MsgProcessingError;

            }

            return MsgProcessed;

        }

    case PHttpChannel::Msg_Resume__ID:

        {

            if (mozilla::ipc::LoggingEnabledFor("PHttpChannelParent")) {

                mozilla::ipc::LogMessageForProtocol("PHttpChannelParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);

            }

            AUTO_PROFILER_LABEL("PHttpChannel::Msg_Resume", OTHER);

            if ((!(StateTransition(false, (&(mLivenessState)))))) {

                FatalError("Transition error");

                return MsgValueError;

            }

            if ((!(RecvResume()))) {

                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");

                // Error handled in mozilla::ipc::IPCResult

                return MsgProcessingError;

            }

            return MsgProcessed;

        }

    case PHttpChannel::Msg_Cancel__ID:

        {

            if (mozilla::ipc::LoggingEnabledFor("PHttpChannelParent")) {

                mozilla::ipc::LogMessageForProtocol("PHttpChannelParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);

            }

            AUTO_PROFILER_LABEL("PHttpChannel::Msg_Cancel", OTHER);

            PickleIterator iter__(msg__);

            nsresult status;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(status)))))) {

                FatalError("Error deserializing 'nsresult'");

                return MsgValueError;

            }

            // Sentinel = 'status'

            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 3714608576)))) {

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

                return MsgValueError;

            }

            (msg__).EndRead(iter__, (msg__).type());

            if ((!(StateTransition(false, (&(mLivenessState)))))) {

                FatalError("Transition error");

                return MsgValueError;

            }

            if ((!(RecvCancel(status)))) {

                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");

                // Error handled in mozilla::ipc::IPCResult

                return MsgProcessingError;

            }

            return MsgProcessed;

        }

    case PHttpChannel::Msg_Redirect2Verify__ID:

        {

            if (mozilla::ipc::LoggingEnabledFor("PHttpChannelParent")) {

                mozilla::ipc::LogMessageForProtocol("PHttpChannelParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);

            }

            AUTO_PROFILER_LABEL("PHttpChannel::Msg_Redirect2Verify", OTHER);

            PickleIterator iter__(msg__);

            nsresult result;

            RequestHeaderTuples changedHeaders;

            ChildLoadInfoForwarderArgs loadInfoForwarder;

            uint32_t loadFlags;

            uint32_t referrerPolicy;

            OptionalURIParams referrerUri;

            OptionalURIParams apiRedirectTo;

            OptionalCorsPreflightArgs corsPreflightArgs;

            bool chooseAppcache;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(result)))))) {

                FatalError("Error deserializing 'nsresult'");

                return MsgValueError;

            }

            // Sentinel = 'result'

            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 3991766165)))) {

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

                return MsgValueError;

            }

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(changedHeaders)))))) {

                FatalError("Error deserializing 'RequestHeaderTuples'");

                return MsgValueError;

            }

            // Sentinel = 'changedHeaders'

            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 1574138284)))) {

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

                return MsgValueError;

            }

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(loadInfoForwarder)))))) {

                FatalError("Error deserializing 'ChildLoadInfoForwarderArgs'");

                return MsgValueError;

            }

            // Sentinel = 'loadInfoForwarder'

            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 2195128043)))) {

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

                return MsgValueError;

            }

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(loadFlags)))))) {

                FatalError("Error deserializing 'uint32_t'");

                return MsgValueError;

            }

            // Sentinel = 'loadFlags'

            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 2391120444)))) {

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

                return MsgValueError;

            }

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(referrerPolicy)))))) {

                FatalError("Error deserializing 'uint32_t'");

                return MsgValueError;

            }

            // Sentinel = 'referrerPolicy'

            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 2269890057)))) {

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

                return MsgValueError;

            }

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(referrerUri)))))) {

                FatalError("Error deserializing 'OptionalURIParams'");

                return MsgValueError;

            }

            // Sentinel = 'referrerUri'

            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 622910354)))) {

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

                return MsgValueError;

            }

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(apiRedirectTo)))))) {

                FatalError("Error deserializing 'OptionalURIParams'");

                return MsgValueError;

            }

            // Sentinel = 'apiRedirectTo'

            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 3162811030)))) {

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

                return MsgValueError;

            }

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(corsPreflightArgs)))))) {

                FatalError("Error deserializing 'OptionalCorsPreflightArgs'");

                return MsgValueError;

            }

            // Sentinel = 'corsPreflightArgs'

            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 1890063766)))) {

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

                return MsgValueError;

            }

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(chooseAppcache)))))) {

                FatalError("Error deserializing 'bool'");

                return MsgValueError;

            }

            // Sentinel = 'chooseAppcache'

            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 868254728)))) {

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

                return MsgValueError;

            }

            (msg__).EndRead(iter__, (msg__).type());

            if ((!(StateTransition(false, (&(mLivenessState)))))) {

                FatalError("Transition error");

                return MsgValueError;

            }

            if ((!(RecvRedirect2Verify(result, changedHeaders, loadInfoForwarder, loadFlags, referrerPolicy, referrerUri, apiRedirectTo, corsPreflightArgs, chooseAppcache)))) {

                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");

                // Error handled in mozilla::ipc::IPCResult

                return MsgProcessingError;

            }

            return MsgProcessed;

        }

    case PHttpChannel::Msg_CrossProcessRedirectDone__ID:

        {

            if (mozilla::ipc::LoggingEnabledFor("PHttpChannelParent")) {

                mozilla::ipc::LogMessageForProtocol("PHttpChannelParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);

            }

            AUTO_PROFILER_LABEL("PHttpChannel::Msg_CrossProcessRedirectDone", OTHER);

            PickleIterator iter__(msg__);

            nsresult result;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(result)))))) {

                FatalError("Error deserializing 'nsresult'");

                return MsgValueError;

            }

            // Sentinel = 'result'

            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 3991766165)))) {

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

                return MsgValueError;

            }

            (msg__).EndRead(iter__, (msg__).type());

            if ((!(StateTransition(false, (&(mLivenessState)))))) {

                FatalError("Transition error");

                return MsgValueError;

            }

            if ((!(RecvCrossProcessRedirectDone(result)))) {

                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");

                // Error handled in mozilla::ipc::IPCResult

                return MsgProcessingError;

            }

            return MsgProcessed;

        }

    case PHttpChannel::Msg_DocumentChannelCleanup__ID:

        {

            if (mozilla::ipc::LoggingEnabledFor("PHttpChannelParent")) {

                mozilla::ipc::LogMessageForProtocol("PHttpChannelParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);

            }

            AUTO_PROFILER_LABEL("PHttpChannel::Msg_DocumentChannelCleanup", OTHER);

            PickleIterator iter__(msg__);

            bool clearCacheEntry;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(clearCacheEntry)))))) {

                FatalError("Error deserializing 'bool'");

                return MsgValueError;

            }

            // Sentinel = 'clearCacheEntry'

            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 2700914662)))) {

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

                return MsgValueError;

            }

            (msg__).EndRead(iter__, (msg__).type());

            if ((!(StateTransition(false, (&(mLivenessState)))))) {

                FatalError("Transition error");

                return MsgValueError;

            }

            if ((!(RecvDocumentChannelCleanup(clearCacheEntry)))) {

                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");

                // Error handled in mozilla::ipc::IPCResult

                return MsgProcessingError;

            }

            return MsgProcessed;

        }

    case PHttpChannel::Msg_MarkOfflineCacheEntryAsForeign__ID:

        {

            if (mozilla::ipc::LoggingEnabledFor("PHttpChannelParent")) {

                mozilla::ipc::LogMessageForProtocol("PHttpChannelParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);

            }

            AUTO_PROFILER_LABEL("PHttpChannel::Msg_MarkOfflineCacheEntryAsForeign", OTHER);

            if ((!(StateTransition(false, (&(mLivenessState)))))) {

                FatalError("Transition error");

                return MsgValueError;

            }

            if ((!(RecvMarkOfflineCacheEntryAsForeign()))) {

                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");

                // Error handled in mozilla::ipc::IPCResult

                return MsgProcessingError;

            }

            return MsgProcessed;

        }

    case PHttpChannel::Msg_DivertOnDataAvailable__ID:

        {

            if (mozilla::ipc::LoggingEnabledFor("PHttpChannelParent")) {

                mozilla::ipc::LogMessageForProtocol("PHttpChannelParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);

            }

            AUTO_PROFILER_LABEL("PHttpChannel::Msg_DivertOnDataAvailable", OTHER);

            PickleIterator iter__(msg__);

            nsCString data;

            uint64_t offset;

            uint32_t count;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(data)))))) {

                FatalError("Error deserializing 'nsCString'");

                return MsgValueError;

            }

            // Sentinel = 'data'

            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 843352540)))) {

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

                return MsgValueError;

            }

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(offset)))))) {

                FatalError("Error deserializing 'uint64_t'");

                return MsgValueError;

            }

            // Sentinel = 'offset'

            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 1369947863)))) {

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

                return MsgValueError;

            }

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(count)))))) {

                FatalError("Error deserializing 'uint32_t'");

                return MsgValueError;

            }

            // Sentinel = 'count'

            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 2126421856)))) {

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

                return MsgValueError;

            }

            (msg__).EndRead(iter__, (msg__).type());

            if ((!(StateTransition(false, (&(mLivenessState)))))) {

                FatalError("Transition error");