/work/obj-fuzz/ipc/ipdl/PNeckoChild.cpp

Source (jump to first uncovered line)
//
// Automatically generated by ipdlc.
// Edit at your own risk
//


#include "mozilla/net/PNeckoChild.h"
#include "SerializedLoadContext.h"
#include "mozilla/dom/PermissionMessageUtils.h"
#include "mozilla/ipc/IPCStreamUtils.h"
#include "mozilla/ipc/URIUtils.h"

#include "mozilla/dom/PContentChild.h"
#include "mozilla/net/PHttpChannelChild.h"
#include "mozilla/net/PCookieServiceChild.h"
#include "mozilla/dom/PBrowserChild.h"
#include "mozilla/net/PWyciwygChannelChild.h"
#include "mozilla/net/PFTPChannelChild.h"
#include "mozilla/net/PWebSocketChild.h"
#include "mozilla/net/PWebSocketEventListenerChild.h"
#include "mozilla/net/PTCPSocketChild.h"
#include "mozilla/net/PTCPServerSocketChild.h"
#include "mozilla/net/PUDPSocketChild.h"
#include "mozilla/net/PDNSRequestChild.h"
#include "mozilla/net/PChannelDiverterChild.h"
#include "mozilla/ipc/PFileDescriptorSetChild.h"
#include "mozilla/net/PDataChannelChild.h"
#include "mozilla/net/PSimpleChannelChild.h"
#include "mozilla/net/PTransportProviderChild.h"
#include "mozilla/ipc/PChildToParentStreamChild.h"
#include "mozilla/ipc/PParentToChildStreamChild.h"
#include "mozilla/net/PStunAddrsRequestChild.h"
#include "mozilla/net/PFileChannelChild.h"
#include "mozilla/net/PAltDataOutputStreamChild.h"

#include "nsIFile.h"
#include "GeckoProfiler.h"

namespace mozilla {
namespace net {


auto PNeckoChild::RecvPTransportProviderConstructor(PTransportProviderChild* actor) -> mozilla::ipc::IPCResult
{
    return IPC_OK();
}

auto PNeckoChild::RecvPTCPSocketConstructor(
        PTCPSocketChild* actor,
        const nsString& host,
        const uint16_t& port) -> mozilla::ipc::IPCResult
{
    return IPC_OK();
}

auto PNeckoChild::ActorDestroy(ActorDestroyReason aWhy) -> void
{
}

MOZ_IMPLICIT PNeckoChild::PNeckoChild() :
    mozilla::ipc::IProtocol(mozilla::ipc::ChildSide),
    mLivenessState(mozilla::ipc::LivenessState::Dead)
{
    MOZ_COUNT_CTOR(PNeckoChild);
}

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

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

auto PNeckoChild::ManagedPHttpChannelChild(nsTArray<PHttpChannelChild*>& aArr) const -> void
{
    (mManagedPHttpChannelChild).ToArray(aArr);
}

auto PNeckoChild::ManagedPHttpChannelChild() const -> const ManagedContainer<PHttpChannelChild>&
{
    return mManagedPHttpChannelChild;
}

auto PNeckoChild::ManagedPCookieServiceChild(nsTArray<PCookieServiceChild*>& aArr) const -> void
{
    (mManagedPCookieServiceChild).ToArray(aArr);
}

auto PNeckoChild::ManagedPCookieServiceChild() const -> const ManagedContainer<PCookieServiceChild>&
{
    return mManagedPCookieServiceChild;
}

auto PNeckoChild::ManagedPWyciwygChannelChild(nsTArray<PWyciwygChannelChild*>& aArr) const -> void
{
    (mManagedPWyciwygChannelChild).ToArray(aArr);
}

auto PNeckoChild::ManagedPWyciwygChannelChild() const -> const ManagedContainer<PWyciwygChannelChild>&
{
    return mManagedPWyciwygChannelChild;
}

auto PNeckoChild::ManagedPFTPChannelChild(nsTArray<PFTPChannelChild*>& aArr) const -> void
{
    (mManagedPFTPChannelChild).ToArray(aArr);
}

auto PNeckoChild::ManagedPFTPChannelChild() const -> const ManagedContainer<PFTPChannelChild>&
{
    return mManagedPFTPChannelChild;
}

auto PNeckoChild::ManagedPWebSocketChild(nsTArray<PWebSocketChild*>& aArr) const -> void
{
    (mManagedPWebSocketChild).ToArray(aArr);
}

auto PNeckoChild::ManagedPWebSocketChild() const -> const ManagedContainer<PWebSocketChild>&
{
    return mManagedPWebSocketChild;
}

auto PNeckoChild::ManagedPWebSocketEventListenerChild(nsTArray<PWebSocketEventListenerChild*>& aArr) const -> void
{
    (mManagedPWebSocketEventListenerChild).ToArray(aArr);
}

auto PNeckoChild::ManagedPWebSocketEventListenerChild() const -> const ManagedContainer<PWebSocketEventListenerChild>&
{
    return mManagedPWebSocketEventListenerChild;
}

auto PNeckoChild::ManagedPTCPSocketChild(nsTArray<PTCPSocketChild*>& aArr) const -> void
{
    (mManagedPTCPSocketChild).ToArray(aArr);
}

auto PNeckoChild::ManagedPTCPSocketChild() const -> const ManagedContainer<PTCPSocketChild>&
{
    return mManagedPTCPSocketChild;
}

auto PNeckoChild::ManagedPTCPServerSocketChild(nsTArray<PTCPServerSocketChild*>& aArr) const -> void
{
    (mManagedPTCPServerSocketChild).ToArray(aArr);
}

auto PNeckoChild::ManagedPTCPServerSocketChild() const -> const ManagedContainer<PTCPServerSocketChild>&
{
    return mManagedPTCPServerSocketChild;
}

auto PNeckoChild::ManagedPUDPSocketChild(nsTArray<PUDPSocketChild*>& aArr) const -> void
{
    (mManagedPUDPSocketChild).ToArray(aArr);
}

auto PNeckoChild::ManagedPUDPSocketChild() const -> const ManagedContainer<PUDPSocketChild>&
{
    return mManagedPUDPSocketChild;
}

auto PNeckoChild::ManagedPDNSRequestChild(nsTArray<PDNSRequestChild*>& aArr) const -> void
{
    (mManagedPDNSRequestChild).ToArray(aArr);
}

auto PNeckoChild::ManagedPDNSRequestChild() const -> const ManagedContainer<PDNSRequestChild>&
{
    return mManagedPDNSRequestChild;
}

auto PNeckoChild::ManagedPDataChannelChild(nsTArray<PDataChannelChild*>& aArr) const -> void
{
    (mManagedPDataChannelChild).ToArray(aArr);
}

auto PNeckoChild::ManagedPDataChannelChild() const -> const ManagedContainer<PDataChannelChild>&
{
    return mManagedPDataChannelChild;
}

auto PNeckoChild::ManagedPSimpleChannelChild(nsTArray<PSimpleChannelChild*>& aArr) const -> void
{
    (mManagedPSimpleChannelChild).ToArray(aArr);
}

auto PNeckoChild::ManagedPSimpleChannelChild() const -> const ManagedContainer<PSimpleChannelChild>&
{
    return mManagedPSimpleChannelChild;
}

auto PNeckoChild::ManagedPFileChannelChild(nsTArray<PFileChannelChild*>& aArr) const -> void
{
    (mManagedPFileChannelChild).ToArray(aArr);
}

auto PNeckoChild::ManagedPFileChannelChild() const -> const ManagedContainer<PFileChannelChild>&
{
    return mManagedPFileChannelChild;
}

auto PNeckoChild::ManagedPChannelDiverterChild(nsTArray<PChannelDiverterChild*>& aArr) const -> void
{
    (mManagedPChannelDiverterChild).ToArray(aArr);
}

auto PNeckoChild::ManagedPChannelDiverterChild() const -> const ManagedContainer<PChannelDiverterChild>&
{
    return mManagedPChannelDiverterChild;
}

auto PNeckoChild::ManagedPTransportProviderChild(nsTArray<PTransportProviderChild*>& aArr) const -> void
{
    (mManagedPTransportProviderChild).ToArray(aArr);
}

auto PNeckoChild::ManagedPTransportProviderChild() const -> const ManagedContainer<PTransportProviderChild>&
{
    return mManagedPTransportProviderChild;
}

auto PNeckoChild::ManagedPAltDataOutputStreamChild(nsTArray<PAltDataOutputStreamChild*>& aArr) const -> void
{
    (mManagedPAltDataOutputStreamChild).ToArray(aArr);
}

auto PNeckoChild::ManagedPAltDataOutputStreamChild() const -> const ManagedContainer<PAltDataOutputStreamChild>&
{
    return mManagedPAltDataOutputStreamChild;
}

auto PNeckoChild::ManagedPStunAddrsRequestChild(nsTArray<PStunAddrsRequestChild*>& aArr) const -> void
{
    (mManagedPStunAddrsRequestChild).ToArray(aArr);
}

auto PNeckoChild::ManagedPStunAddrsRequestChild() const -> const ManagedContainer<PStunAddrsRequestChild>&
{
    return mManagedPStunAddrsRequestChild;
}

auto PNeckoChild::Send__delete__(PNeckoChild* actor) -> bool
{
    if ((!(actor))) {
        return false;
    }

    IPC::Message* msg__ = PNecko::Msg___delete__((actor)->Id());

    MOZ_RELEASE_ASSERT(actor, "NULL actor value passed to non-nullable param");
    WriteIPDLParam(msg__, actor, actor);
    // Sentinel = 'actor'
    (msg__)->WriteSentinel(875202478);



    if (mozilla::ipc::LoggingEnabledFor("PNeckoChild")) {
        mozilla::ipc::LogMessageForProtocol("PNeckoChild", (actor)->OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PNecko::Msg___delete__", OTHER);
    if ((!(StateTransition(true, (&((actor)->mLivenessState)))))) {
        mozilla::ipc::LogicError("Transition error");
    }

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

    IProtocol* mgr = (actor)->Manager();
    (actor)->DestroySubtree(Deletion);
    (actor)->DeallocSubtree();
    (mgr)->RemoveManagee(PNeckoMsgStart, actor);
    return sendok__;
}

auto PNeckoChild::SendPCookieServiceConstructor() -> PCookieServiceChild*
{
    return SendPCookieServiceConstructor(AllocPCookieServiceChild());
}

auto PNeckoChild::SendPCookieServiceConstructor(PCookieServiceChild* actor) -> PCookieServiceChild*
{
    if ((!(actor))) {
        NS_WARNING("Error constructing actor PCookieServiceChild");
        return nullptr;
    }
    (actor)->SetManagerAndRegister(this);
    (mManagedPCookieServiceChild).PutEntry(actor);
    (actor)->mLivenessState = mozilla::ipc::LivenessState::Start;

    IPC::Message* msg__ = PNecko::Msg_PCookieServiceConstructor(Id());

    MOZ_RELEASE_ASSERT(actor, "NULL actor value passed to non-nullable param");
    WriteIPDLParam(msg__, this, actor);
    // Sentinel = 'actor'
    (msg__)->WriteSentinel(875202478);



    if (mozilla::ipc::LoggingEnabledFor("PNeckoChild")) {
        mozilla::ipc::LogMessageForProtocol("PNeckoChild", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PNecko::Msg_PCookieServiceConstructor", OTHER);
    if ((!(StateTransition(false, (&(mLivenessState)))))) {
        mozilla::ipc::LogicError("Transition error");
    }

    bool sendok__ = (GetIPCChannel())->Send(msg__);
    if ((!(sendok__))) {
        FatalError("constructor for actor failed");
        return nullptr;
    }
    return actor;
}

auto PNeckoChild::SendPHttpChannelConstructor(
        const PBrowserOrId& browser,
        const SerializedLoadContext& loadContext,
        const HttpChannelCreationArgs& args) -> PHttpChannelChild*
{
    return SendPHttpChannelConstructor(AllocPHttpChannelChild(browser, loadContext, args), browser, loadContext, args);
}

auto PNeckoChild::SendPHttpChannelConstructor(
        PHttpChannelChild* actor,
        const PBrowserOrId& browser,
        const SerializedLoadContext& loadContext,
        const HttpChannelCreationArgs& args) -> PHttpChannelChild*
{
    if ((!(actor))) {
        NS_WARNING("Error constructing actor PHttpChannelChild");
        return nullptr;
    }
    (actor)->SetManagerAndRegister(this);
    (mManagedPHttpChannelChild).PutEntry(actor);
    (actor)->mLivenessState = mozilla::ipc::LivenessState::Start;

    IPC::Message* msg__ = PNecko::Msg_PHttpChannelConstructor(Id());

    MOZ_RELEASE_ASSERT(actor, "NULL actor value passed to non-nullable param");
    WriteIPDLParam(msg__, this, actor);
    // Sentinel = 'actor'
    (msg__)->WriteSentinel(875202478);
    WriteIPDLParam(msg__, this, browser);
    // Sentinel = 'browser'
    (msg__)->WriteSentinel(2836343679);
    WriteIPDLParam(msg__, this, loadContext);
    // Sentinel = 'loadContext'
    (msg__)->WriteSentinel(2917317838);
    WriteIPDLParam(msg__, this, args);
    // Sentinel = 'args'
    (msg__)->WriteSentinel(2823760587);



    if (mozilla::ipc::LoggingEnabledFor("PNeckoChild")) {
        mozilla::ipc::LogMessageForProtocol("PNeckoChild", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PNecko::Msg_PHttpChannelConstructor", OTHER);
    if ((!(StateTransition(false, (&(mLivenessState)))))) {
        mozilla::ipc::LogicError("Transition error");
    }

    bool sendok__ = (GetIPCChannel())->Send(msg__);
    if ((!(sendok__))) {
        FatalError("constructor for actor failed");
        return nullptr;
    }
    return actor;
}

auto PNeckoChild::SendPWyciwygChannelConstructor() -> PWyciwygChannelChild*
{
    return SendPWyciwygChannelConstructor(AllocPWyciwygChannelChild());
}

auto PNeckoChild::SendPWyciwygChannelConstructor(PWyciwygChannelChild* actor) -> PWyciwygChannelChild*
{
    if ((!(actor))) {
        NS_WARNING("Error constructing actor PWyciwygChannelChild");
        return nullptr;
    }
    (actor)->SetManagerAndRegister(this);
    (mManagedPWyciwygChannelChild).PutEntry(actor);
    (actor)->mLivenessState = mozilla::ipc::LivenessState::Start;

    IPC::Message* msg__ = PNecko::Msg_PWyciwygChannelConstructor(Id());

    MOZ_RELEASE_ASSERT(actor, "NULL actor value passed to non-nullable param");
    WriteIPDLParam(msg__, this, actor);
    // Sentinel = 'actor'
    (msg__)->WriteSentinel(875202478);



    if (mozilla::ipc::LoggingEnabledFor("PNeckoChild")) {
        mozilla::ipc::LogMessageForProtocol("PNeckoChild", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PNecko::Msg_PWyciwygChannelConstructor", OTHER);
    if ((!(StateTransition(false, (&(mLivenessState)))))) {
        mozilla::ipc::LogicError("Transition error");
    }

    bool sendok__ = (GetIPCChannel())->Send(msg__);
    if ((!(sendok__))) {
        FatalError("constructor for actor failed");
        return nullptr;
    }
    return actor;
}

auto PNeckoChild::SendPFTPChannelConstructor(
        const PBrowserOrId& browser,
        const SerializedLoadContext& loadContext,
        const FTPChannelCreationArgs& args) -> PFTPChannelChild*
{
    return SendPFTPChannelConstructor(AllocPFTPChannelChild(browser, loadContext, args), browser, loadContext, args);
}

auto PNeckoChild::SendPFTPChannelConstructor(
        PFTPChannelChild* actor,
        const PBrowserOrId& browser,
        const SerializedLoadContext& loadContext,
        const FTPChannelCreationArgs& args) -> PFTPChannelChild*
{
    if ((!(actor))) {
        NS_WARNING("Error constructing actor PFTPChannelChild");
        return nullptr;
    }
    (actor)->SetManagerAndRegister(this);
    (mManagedPFTPChannelChild).PutEntry(actor);
    (actor)->mLivenessState = mozilla::ipc::LivenessState::Start;

    IPC::Message* msg__ = PNecko::Msg_PFTPChannelConstructor(Id());

    MOZ_RELEASE_ASSERT(actor, "NULL actor value passed to non-nullable param");
    WriteIPDLParam(msg__, this, actor);
    // Sentinel = 'actor'
    (msg__)->WriteSentinel(875202478);
    WriteIPDLParam(msg__, this, browser);
    // Sentinel = 'browser'
    (msg__)->WriteSentinel(2836343679);
    WriteIPDLParam(msg__, this, loadContext);
    // Sentinel = 'loadContext'
    (msg__)->WriteSentinel(2917317838);
    WriteIPDLParam(msg__, this, args);
    // Sentinel = 'args'
    (msg__)->WriteSentinel(2823760587);



    if (mozilla::ipc::LoggingEnabledFor("PNeckoChild")) {
        mozilla::ipc::LogMessageForProtocol("PNeckoChild", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PNecko::Msg_PFTPChannelConstructor", OTHER);
    if ((!(StateTransition(false, (&(mLivenessState)))))) {
        mozilla::ipc::LogicError("Transition error");
    }

    bool sendok__ = (GetIPCChannel())->Send(msg__);
    if ((!(sendok__))) {
        FatalError("constructor for actor failed");
        return nullptr;
    }
    return actor;
}

auto PNeckoChild::SendPWebSocketConstructor(
        const PBrowserOrId& browser,
        const SerializedLoadContext& loadContext,
        const uint32_t& aSerialID) -> PWebSocketChild*
{
    return SendPWebSocketConstructor(AllocPWebSocketChild(browser, loadContext, aSerialID), browser, loadContext, aSerialID);
}

auto PNeckoChild::SendPWebSocketConstructor(
        PWebSocketChild* actor,
        const PBrowserOrId& browser,
        const SerializedLoadContext& loadContext,
        const uint32_t& aSerialID) -> PWebSocketChild*
{
    if ((!(actor))) {
        NS_WARNING("Error constructing actor PWebSocketChild");
        return nullptr;
    }
    (actor)->SetManagerAndRegister(this);
    (mManagedPWebSocketChild).PutEntry(actor);
    (actor)->mLivenessState = mozilla::ipc::LivenessState::Start;

    IPC::Message* msg__ = PNecko::Msg_PWebSocketConstructor(Id());

    MOZ_RELEASE_ASSERT(actor, "NULL actor value passed to non-nullable param");
    WriteIPDLParam(msg__, this, actor);
    // Sentinel = 'actor'
    (msg__)->WriteSentinel(875202478);
    WriteIPDLParam(msg__, this, browser);
    // Sentinel = 'browser'
    (msg__)->WriteSentinel(2836343679);
    WriteIPDLParam(msg__, this, loadContext);
    // Sentinel = 'loadContext'
    (msg__)->WriteSentinel(2917317838);
    WriteIPDLParam(msg__, this, aSerialID);
    // Sentinel = 'aSerialID'
    (msg__)->WriteSentinel(1337008615);



    if (mozilla::ipc::LoggingEnabledFor("PNeckoChild")) {
        mozilla::ipc::LogMessageForProtocol("PNeckoChild", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PNecko::Msg_PWebSocketConstructor", OTHER);
    if ((!(StateTransition(false, (&(mLivenessState)))))) {
        mozilla::ipc::LogicError("Transition error");
    }

    bool sendok__ = (GetIPCChannel())->Send(msg__);
    if ((!(sendok__))) {
        FatalError("constructor for actor failed");
        return nullptr;
    }
    return actor;
}

auto PNeckoChild::SendPTCPServerSocketConstructor(
        const uint16_t& localPort,
        const uint16_t& backlog,
        const bool& useArrayBuffers) -> PTCPServerSocketChild*
{
    return SendPTCPServerSocketConstructor(AllocPTCPServerSocketChild(localPort, backlog, useArrayBuffers), localPort, backlog, useArrayBuffers);
}

auto PNeckoChild::SendPTCPServerSocketConstructor(
        PTCPServerSocketChild* actor,
        const uint16_t& localPort,
        const uint16_t& backlog,
        const bool& useArrayBuffers) -> PTCPServerSocketChild*
{
    if ((!(actor))) {
        NS_WARNING("Error constructing actor PTCPServerSocketChild");
        return nullptr;
    }
    (actor)->SetManagerAndRegister(this);
    (mManagedPTCPServerSocketChild).PutEntry(actor);
    (actor)->mLivenessState = mozilla::ipc::LivenessState::Start;

    IPC::Message* msg__ = PNecko::Msg_PTCPServerSocketConstructor(Id());

    MOZ_RELEASE_ASSERT(actor, "NULL actor value passed to non-nullable param");
    WriteIPDLParam(msg__, this, actor);
    // Sentinel = 'actor'
    (msg__)->WriteSentinel(875202478);
    WriteIPDLParam(msg__, this, localPort);
    // Sentinel = 'localPort'
    (msg__)->WriteSentinel(2930268933);
    WriteIPDLParam(msg__, this, backlog);
    // Sentinel = 'backlog'
    (msg__)->WriteSentinel(403095166);
    WriteIPDLParam(msg__, this, useArrayBuffers);
    // Sentinel = 'useArrayBuffers'
    (msg__)->WriteSentinel(1444022734);



    if (mozilla::ipc::LoggingEnabledFor("PNeckoChild")) {
        mozilla::ipc::LogMessageForProtocol("PNeckoChild", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PNecko::Msg_PTCPServerSocketConstructor", OTHER);
    if ((!(StateTransition(false, (&(mLivenessState)))))) {
        mozilla::ipc::LogicError("Transition error");
    }

    bool sendok__ = (GetIPCChannel())->Send(msg__);
    if ((!(sendok__))) {
        FatalError("constructor for actor failed");
        return nullptr;
    }
    return actor;
}

auto PNeckoChild::SendPUDPSocketConstructor(
        const Principal& principal,
        const nsCString& filter) -> PUDPSocketChild*
{
    return SendPUDPSocketConstructor(AllocPUDPSocketChild(principal, filter), principal, filter);
}

auto PNeckoChild::SendPUDPSocketConstructor(
        PUDPSocketChild* actor,
        const Principal& principal,
        const nsCString& filter) -> PUDPSocketChild*
{
    if ((!(actor))) {
        NS_WARNING("Error constructing actor PUDPSocketChild");
        return nullptr;
    }
    (actor)->SetManagerAndRegister(this);
    (mManagedPUDPSocketChild).PutEntry(actor);
    (actor)->mLivenessState = mozilla::ipc::LivenessState::Start;

    IPC::Message* msg__ = PNecko::Msg_PUDPSocketConstructor(Id());

    MOZ_RELEASE_ASSERT(actor, "NULL actor value passed to non-nullable param");
    WriteIPDLParam(msg__, this, actor);
    // Sentinel = 'actor'
    (msg__)->WriteSentinel(875202478);
    WriteIPDLParam(msg__, this, principal);
    // Sentinel = 'principal'
    (msg__)->WriteSentinel(732240927);
    WriteIPDLParam(msg__, this, filter);
    // Sentinel = 'filter'
    (msg__)->WriteSentinel(2236769008);



    if (mozilla::ipc::LoggingEnabledFor("PNeckoChild")) {
        mozilla::ipc::LogMessageForProtocol("PNeckoChild", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PNecko::Msg_PUDPSocketConstructor", OTHER);
    if ((!(StateTransition(false, (&(mLivenessState)))))) {
        mozilla::ipc::LogicError("Transition error");
    }

    bool sendok__ = (GetIPCChannel())->Send(msg__);
    if ((!(sendok__))) {
        FatalError("constructor for actor failed");
        return nullptr;
    }
    return actor;
}

auto PNeckoChild::SendPDNSRequestConstructor(
        const nsCString& hostName,
        const OriginAttributes& originAttributes,
        const uint32_t& flags) -> PDNSRequestChild*
{
    return SendPDNSRequestConstructor(AllocPDNSRequestChild(hostName, originAttributes, flags), hostName, originAttributes, flags);
}

auto PNeckoChild::SendPDNSRequestConstructor(
        PDNSRequestChild* actor,
        const nsCString& hostName,
        const OriginAttributes& originAttributes,
        const uint32_t& flags) -> PDNSRequestChild*
{
    if ((!(actor))) {
        NS_WARNING("Error constructing actor PDNSRequestChild");
        return nullptr;
    }
    (actor)->SetManagerAndRegister(this);
    (mManagedPDNSRequestChild).PutEntry(actor);
    (actor)->mLivenessState = mozilla::ipc::LivenessState::Start;

    IPC::Message* msg__ = PNecko::Msg_PDNSRequestConstructor(Id());

    MOZ_RELEASE_ASSERT(actor, "NULL actor value passed to non-nullable param");
    WriteIPDLParam(msg__, this, actor);
    // Sentinel = 'actor'
    (msg__)->WriteSentinel(875202478);
    WriteIPDLParam(msg__, this, hostName);
    // Sentinel = 'hostName'
    (msg__)->WriteSentinel(1367899915);
    WriteIPDLParam(msg__, this, originAttributes);
    // Sentinel = 'originAttributes'
    (msg__)->WriteSentinel(2655275965);
    WriteIPDLParam(msg__, this, flags);
    // Sentinel = 'flags'
    (msg__)->WriteSentinel(2550519284);



    if (mozilla::ipc::LoggingEnabledFor("PNeckoChild")) {
        mozilla::ipc::LogMessageForProtocol("PNeckoChild", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PNecko::Msg_PDNSRequestConstructor", OTHER);
    if ((!(StateTransition(false, (&(mLivenessState)))))) {
        mozilla::ipc::LogicError("Transition error");
    }

    bool sendok__ = (GetIPCChannel())->Send(msg__);
    if ((!(sendok__))) {
        FatalError("constructor for actor failed");
        return nullptr;
    }
    return actor;
}

auto PNeckoChild::SendPWebSocketEventListenerConstructor(const uint64_t& aInnerWindowID) -> PWebSocketEventListenerChild*
{
    return SendPWebSocketEventListenerConstructor(AllocPWebSocketEventListenerChild(aInnerWindowID), aInnerWindowID);
}

auto PNeckoChild::SendPWebSocketEventListenerConstructor(
        PWebSocketEventListenerChild* actor,
        const uint64_t& aInnerWindowID) -> PWebSocketEventListenerChild*
{
    if ((!(actor))) {
        NS_WARNING("Error constructing actor PWebSocketEventListenerChild");
        return nullptr;
    }
    (actor)->SetManagerAndRegister(this);
    (mManagedPWebSocketEventListenerChild).PutEntry(actor);
    (actor)->mLivenessState = mozilla::ipc::LivenessState::Start;

    IPC::Message* msg__ = PNecko::Msg_PWebSocketEventListenerConstructor(Id());

    MOZ_RELEASE_ASSERT(actor, "NULL actor value passed to non-nullable param");
    WriteIPDLParam(msg__, this, actor);
    // Sentinel = 'actor'
    (msg__)->WriteSentinel(875202478);
    WriteIPDLParam(msg__, this, aInnerWindowID);
    // Sentinel = 'aInnerWindowID'
    (msg__)->WriteSentinel(3059251422);



    if (mozilla::ipc::LoggingEnabledFor("PNeckoChild")) {
        mozilla::ipc::LogMessageForProtocol("PNeckoChild", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PNecko::Msg_PWebSocketEventListenerConstructor", OTHER);
    if ((!(StateTransition(false, (&(mLivenessState)))))) {
        mozilla::ipc::LogicError("Transition error");
    }

    bool sendok__ = (GetIPCChannel())->Send(msg__);
    if ((!(sendok__))) {
        FatalError("constructor for actor failed");
        return nullptr;
    }
    return actor;
}

auto PNeckoChild::SendPredPredict(
        const OptionalURIParams& targetURI,
        const OptionalURIParams& sourceURI,
        const uint32_t& reason,
        const OriginAttributes& originAttributes,
        const bool& hasVerifier) -> bool
{
    IPC::Message* msg__ = PNecko::Msg_PredPredict(Id());

    WriteIPDLParam(msg__, this, targetURI);
    // Sentinel = 'targetURI'
    (msg__)->WriteSentinel(1361914354);
    WriteIPDLParam(msg__, this, sourceURI);
    // Sentinel = 'sourceURI'
    (msg__)->WriteSentinel(3017222278);
    WriteIPDLParam(msg__, this, reason);
    // Sentinel = 'reason'
    (msg__)->WriteSentinel(4151390930);
    WriteIPDLParam(msg__, this, originAttributes);
    // Sentinel = 'originAttributes'
    (msg__)->WriteSentinel(2655275965);
    WriteIPDLParam(msg__, this, hasVerifier);
    // Sentinel = 'hasVerifier'
    (msg__)->WriteSentinel(1905198201);




    if (mozilla::ipc::LoggingEnabledFor("PNeckoChild")) {
        mozilla::ipc::LogMessageForProtocol("PNeckoChild", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PNecko::Msg_PredPredict", OTHER);
    if ((!(StateTransition(false, (&(mLivenessState)))))) {
        mozilla::ipc::LogicError("Transition error");
    }

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

auto PNeckoChild::SendPredLearn(
        const URIParams& targetURI,
        const OptionalURIParams& sourceURI,
        const uint32_t& reason,
        const OriginAttributes& originAttributes) -> bool
{
    IPC::Message* msg__ = PNecko::Msg_PredLearn(Id());

    WriteIPDLParam(msg__, this, targetURI);
    // Sentinel = 'targetURI'
    (msg__)->WriteSentinel(1361914354);
    WriteIPDLParam(msg__, this, sourceURI);
    // Sentinel = 'sourceURI'
    (msg__)->WriteSentinel(3017222278);
    WriteIPDLParam(msg__, this, reason);
    // Sentinel = 'reason'
    (msg__)->WriteSentinel(4151390930);
    WriteIPDLParam(msg__, this, originAttributes);
    // Sentinel = 'originAttributes'
    (msg__)->WriteSentinel(2655275965);




    if (mozilla::ipc::LoggingEnabledFor("PNeckoChild")) {
        mozilla::ipc::LogMessageForProtocol("PNeckoChild", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PNecko::Msg_PredLearn", OTHER);
    if ((!(StateTransition(false, (&(mLivenessState)))))) {
        mozilla::ipc::LogicError("Transition error");
    }

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

auto PNeckoChild::SendPredReset() -> bool
{
    IPC::Message* msg__ = PNecko::Msg_PredReset(Id());





    if (mozilla::ipc::LoggingEnabledFor("PNeckoChild")) {
        mozilla::ipc::LogMessageForProtocol("PNeckoChild", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PNecko::Msg_PredReset", OTHER);
    if ((!(StateTransition(false, (&(mLivenessState)))))) {
        mozilla::ipc::LogicError("Transition error");
    }

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

auto PNeckoChild::SendSpeculativeConnect(
        const URIParams& uri,
        const Principal& principal,
        const bool& anonymous) -> bool
{
    IPC::Message* msg__ = PNecko::Msg_SpeculativeConnect(Id());

    WriteIPDLParam(msg__, this, uri);
    // Sentinel = 'uri'
    (msg__)->WriteSentinel(1453210605);
    WriteIPDLParam(msg__, this, principal);
    // Sentinel = 'principal'
    (msg__)->WriteSentinel(732240927);
    WriteIPDLParam(msg__, this, anonymous);
    // Sentinel = 'anonymous'
    (msg__)->WriteSentinel(479504470);




    if (mozilla::ipc::LoggingEnabledFor("PNeckoChild")) {
        mozilla::ipc::LogMessageForProtocol("PNeckoChild", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PNecko::Msg_SpeculativeConnect", OTHER);
    if ((!(StateTransition(false, (&(mLivenessState)))))) {
        mozilla::ipc::LogicError("Transition error");
    }

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

auto PNeckoChild::SendHTMLDNSPrefetch(
        const nsString& hostname,
        const bool& isHttps,
        const OriginAttributes& originAttributes,
        const uint16_t& flags) -> bool
{
    IPC::Message* msg__ = PNecko::Msg_HTMLDNSPrefetch(Id());

    WriteIPDLParam(msg__, this, hostname);
    // Sentinel = 'hostname'
    (msg__)->WriteSentinel(4013034923);
    WriteIPDLParam(msg__, this, isHttps);
    // Sentinel = 'isHttps'
    (msg__)->WriteSentinel(2454022204);
    WriteIPDLParam(msg__, this, originAttributes);
    // Sentinel = 'originAttributes'
    (msg__)->WriteSentinel(2655275965);
    WriteIPDLParam(msg__, this, flags);
    // Sentinel = 'flags'
    (msg__)->WriteSentinel(2550519284);




    if (mozilla::ipc::LoggingEnabledFor("PNeckoChild")) {
        mozilla::ipc::LogMessageForProtocol("PNeckoChild", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PNecko::Msg_HTMLDNSPrefetch", OTHER);
    if ((!(StateTransition(false, (&(mLivenessState)))))) {
        mozilla::ipc::LogicError("Transition error");
    }

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

auto PNeckoChild::SendCancelHTMLDNSPrefetch(
        const nsString& hostname,
        const bool& isHttps,
        const OriginAttributes& originAttributes,
        const uint16_t& flags,
        const nsresult& reason) -> bool
{
    IPC::Message* msg__ = PNecko::Msg_CancelHTMLDNSPrefetch(Id());

    WriteIPDLParam(msg__, this, hostname);
    // Sentinel = 'hostname'
    (msg__)->WriteSentinel(4013034923);
    WriteIPDLParam(msg__, this, isHttps);
    // Sentinel = 'isHttps'
    (msg__)->WriteSentinel(2454022204);
    WriteIPDLParam(msg__, this, originAttributes);
    // Sentinel = 'originAttributes'
    (msg__)->WriteSentinel(2655275965);
    WriteIPDLParam(msg__, this, flags);
    // Sentinel = 'flags'
    (msg__)->WriteSentinel(2550519284);
    WriteIPDLParam(msg__, this, reason);
    // Sentinel = 'reason'
    (msg__)->WriteSentinel(4151390930);




    if (mozilla::ipc::LoggingEnabledFor("PNeckoChild")) {
        mozilla::ipc::LogMessageForProtocol("PNeckoChild", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PNecko::Msg_CancelHTMLDNSPrefetch", OTHER);
    if ((!(StateTransition(false, (&(mLivenessState)))))) {
        mozilla::ipc::LogicError("Transition error");
    }

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

auto PNeckoChild::SendPDataChannelConstructor(const uint32_t& channelId) -> PDataChannelChild*
{
    return SendPDataChannelConstructor(AllocPDataChannelChild(channelId), channelId);
}

auto PNeckoChild::SendPDataChannelConstructor(
        PDataChannelChild* actor,
        const uint32_t& channelId) -> PDataChannelChild*
{
    if ((!(actor))) {
        NS_WARNING("Error constructing actor PDataChannelChild");
        return nullptr;
    }
    (actor)->SetManagerAndRegister(this);
    (mManagedPDataChannelChild).PutEntry(actor);
    (actor)->mLivenessState = mozilla::ipc::LivenessState::Start;

    IPC::Message* msg__ = PNecko::Msg_PDataChannelConstructor(Id());

    MOZ_RELEASE_ASSERT(actor, "NULL actor value passed to non-nullable param");
    WriteIPDLParam(msg__, this, actor);
    // Sentinel = 'actor'
    (msg__)->WriteSentinel(875202478);
    WriteIPDLParam(msg__, this, channelId);
    // Sentinel = 'channelId'
    (msg__)->WriteSentinel(6854027);



    if (mozilla::ipc::LoggingEnabledFor("PNeckoChild")) {
        mozilla::ipc::LogMessageForProtocol("PNeckoChild", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PNecko::Msg_PDataChannelConstructor", OTHER);
    if ((!(StateTransition(false, (&(mLivenessState)))))) {
        mozilla::ipc::LogicError("Transition error");
    }

    bool sendok__ = (GetIPCChannel())->Send(msg__);
    if ((!(sendok__))) {
        FatalError("constructor for actor failed");
        return nullptr;
    }
    return actor;
}

auto PNeckoChild::SendPSimpleChannelConstructor(const uint32_t& channelId) -> PSimpleChannelChild*
{
    return SendPSimpleChannelConstructor(AllocPSimpleChannelChild(channelId), channelId);
}

auto PNeckoChild::SendPSimpleChannelConstructor(
        PSimpleChannelChild* actor,
        const uint32_t& channelId) -> PSimpleChannelChild*
{
    if ((!(actor))) {
        NS_WARNING("Error constructing actor PSimpleChannelChild");
        return nullptr;
    }
    (actor)->SetManagerAndRegister(this);
    (mManagedPSimpleChannelChild).PutEntry(actor);
    (actor)->mLivenessState = mozilla::ipc::LivenessState::Start;

    IPC::Message* msg__ = PNecko::Msg_PSimpleChannelConstructor(Id());

    MOZ_RELEASE_ASSERT(actor, "NULL actor value passed to non-nullable param");
    WriteIPDLParam(msg__, this, actor);
    // Sentinel = 'actor'
    (msg__)->WriteSentinel(875202478);
    WriteIPDLParam(msg__, this, channelId);
    // Sentinel = 'channelId'
    (msg__)->WriteSentinel(6854027);



    if (mozilla::ipc::LoggingEnabledFor("PNeckoChild")) {
        mozilla::ipc::LogMessageForProtocol("PNeckoChild", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PNecko::Msg_PSimpleChannelConstructor", OTHER);
    if ((!(StateTransition(false, (&(mLivenessState)))))) {
        mozilla::ipc::LogicError("Transition error");
    }

    bool sendok__ = (GetIPCChannel())->Send(msg__);
    if ((!(sendok__))) {
        FatalError("constructor for actor failed");
        return nullptr;
    }
    return actor;
}

auto PNeckoChild::SendPFileChannelConstructor(const uint32_t& channelId) -> PFileChannelChild*
{
    return SendPFileChannelConstructor(AllocPFileChannelChild(channelId), channelId);
}

auto PNeckoChild::SendPFileChannelConstructor(
        PFileChannelChild* actor,
        const uint32_t& channelId) -> PFileChannelChild*
{
    if ((!(actor))) {
        NS_WARNING("Error constructing actor PFileChannelChild");
        return nullptr;
    }
    (actor)->SetManagerAndRegister(this);
    (mManagedPFileChannelChild).PutEntry(actor);
    (actor)->mLivenessState = mozilla::ipc::LivenessState::Start;

    IPC::Message* msg__ = PNecko::Msg_PFileChannelConstructor(Id());

    MOZ_RELEASE_ASSERT(actor, "NULL actor value passed to non-nullable param");
    WriteIPDLParam(msg__, this, actor);
    // Sentinel = 'actor'
    (msg__)->WriteSentinel(875202478);
    WriteIPDLParam(msg__, this, channelId);
    // Sentinel = 'channelId'
    (msg__)->WriteSentinel(6854027);



    if (mozilla::ipc::LoggingEnabledFor("PNeckoChild")) {
        mozilla::ipc::LogMessageForProtocol("PNeckoChild", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PNecko::Msg_PFileChannelConstructor", OTHER);
    if ((!(StateTransition(false, (&(mLivenessState)))))) {
        mozilla::ipc::LogicError("Transition error");
    }

    bool sendok__ = (GetIPCChannel())->Send(msg__);
    if ((!(sendok__))) {
        FatalError("constructor for actor failed");
        return nullptr;
    }
    return actor;
}

auto PNeckoChild::SendPChannelDiverterConstructor(const ChannelDiverterArgs& channel) -> PChannelDiverterChild*
{
    return SendPChannelDiverterConstructor(AllocPChannelDiverterChild(channel), channel);
}

auto PNeckoChild::SendPChannelDiverterConstructor(
        PChannelDiverterChild* actor,
        const ChannelDiverterArgs& channel) -> PChannelDiverterChild*
{
    if ((!(actor))) {
        NS_WARNING("Error constructing actor PChannelDiverterChild");
        return nullptr;
    }
    (actor)->SetManagerAndRegister(this);
    (mManagedPChannelDiverterChild).PutEntry(actor);
    (actor)->mLivenessState = mozilla::ipc::LivenessState::Start;

    IPC::Message* msg__ = PNecko::Msg_PChannelDiverterConstructor(Id());

    MOZ_RELEASE_ASSERT(actor, "NULL actor value passed to non-nullable param");
    WriteIPDLParam(msg__, this, actor);
    // Sentinel = 'actor'
    (msg__)->WriteSentinel(875202478);
    WriteIPDLParam(msg__, this, channel);
    // Sentinel = 'channel'
    (msg__)->WriteSentinel(452840382);



    if (mozilla::ipc::LoggingEnabledFor("PNeckoChild")) {
        mozilla::ipc::LogMessageForProtocol("PNeckoChild", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PNecko::Msg_PChannelDiverterConstructor", OTHER);
    if ((!(StateTransition(false, (&(mLivenessState)))))) {
        mozilla::ipc::LogicError("Transition error");
    }

    bool sendok__ = (GetIPCChannel())->Send(msg__);
    if ((!(sendok__))) {
        FatalError("constructor for actor failed");
        return nullptr;
    }
    return actor;
}

auto PNeckoChild::SendOnAuthAvailable(
        const uint64_t& callbackId,
        const nsString& user,
        const nsString& password,
        const nsString& domain) -> bool
{
    IPC::Message* msg__ = PNecko::Msg_OnAuthAvailable(Id());

    WriteIPDLParam(msg__, this, callbackId);
    // Sentinel = 'callbackId'
    (msg__)->WriteSentinel(4163989448);
    WriteIPDLParam(msg__, this, user);
    // Sentinel = 'user'
    (msg__)->WriteSentinel(479507925);
    WriteIPDLParam(msg__, this, password);
    // Sentinel = 'password'
    (msg__)->WriteSentinel(2527534683);
    WriteIPDLParam(msg__, this, domain);
    // Sentinel = 'domain'
    (msg__)->WriteSentinel(702229122);




    if (mozilla::ipc::LoggingEnabledFor("PNeckoChild")) {
        mozilla::ipc::LogMessageForProtocol("PNeckoChild", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PNecko::Msg_OnAuthAvailable", OTHER);
    if ((!(StateTransition(false, (&(mLivenessState)))))) {
        mozilla::ipc::LogicError("Transition error");
    }

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

auto PNeckoChild::SendOnAuthCancelled(
        const uint64_t& callbackId,
        const bool& userCancel) -> bool
{
    IPC::Message* msg__ = PNecko::Msg_OnAuthCancelled(Id());

    WriteIPDLParam(msg__, this, callbackId);
    // Sentinel = 'callbackId'
    (msg__)->WriteSentinel(4163989448);
    WriteIPDLParam(msg__, this, userCancel);
    // Sentinel = 'userCancel'
    (msg__)->WriteSentinel(2063943853);




    if (mozilla::ipc::LoggingEnabledFor("PNeckoChild")) {
        mozilla::ipc::LogMessageForProtocol("PNeckoChild", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PNecko::Msg_OnAuthCancelled", OTHER);
    if ((!(StateTransition(false, (&(mLivenessState)))))) {
        mozilla::ipc::LogicError("Transition error");
    }

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

auto PNeckoChild::SendRequestContextLoadBegin(const uint64_t& rcid) -> bool
{
    IPC::Message* msg__ = PNecko::Msg_RequestContextLoadBegin(Id());

    WriteIPDLParam(msg__, this, rcid);
    // Sentinel = 'rcid'
    (msg__)->WriteSentinel(3280983874);




    if (mozilla::ipc::LoggingEnabledFor("PNeckoChild")) {
        mozilla::ipc::LogMessageForProtocol("PNeckoChild", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PNecko::Msg_RequestContextLoadBegin", OTHER);
    if ((!(StateTransition(false, (&(mLivenessState)))))) {
        mozilla::ipc::LogicError("Transition error");
    }

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

auto PNeckoChild::SendRequestContextAfterDOMContentLoaded(const uint64_t& rcid) -> bool
{
    IPC::Message* msg__ = PNecko::Msg_RequestContextAfterDOMContentLoaded(Id());

    WriteIPDLParam(msg__, this, rcid);
    // Sentinel = 'rcid'
    (msg__)->WriteSentinel(3280983874);




    if (mozilla::ipc::LoggingEnabledFor("PNeckoChild")) {
        mozilla::ipc::LogMessageForProtocol("PNeckoChild", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PNecko::Msg_RequestContextAfterDOMContentLoaded", OTHER);
    if ((!(StateTransition(false, (&(mLivenessState)))))) {
        mozilla::ipc::LogicError("Transition error");
    }

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

auto PNeckoChild::SendRemoveRequestContext(const uint64_t& rcid) -> bool
{
    IPC::Message* msg__ = PNecko::Msg_RemoveRequestContext(Id());

    WriteIPDLParam(msg__, this, rcid);
    // Sentinel = 'rcid'
    (msg__)->WriteSentinel(3280983874);




    if (mozilla::ipc::LoggingEnabledFor("PNeckoChild")) {
        mozilla::ipc::LogMessageForProtocol("PNeckoChild", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PNecko::Msg_RemoveRequestContext", OTHER);
    if ((!(StateTransition(false, (&(mLivenessState)))))) {
        mozilla::ipc::LogicError("Transition error");
    }

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

auto PNeckoChild::SendPAltDataOutputStreamConstructor(
        const nsCString& type,
        const int64_t& predictedSize,
        PHttpChannelChild* channel) -> PAltDataOutputStreamChild*
{
    return SendPAltDataOutputStreamConstructor(AllocPAltDataOutputStreamChild(type, predictedSize, channel), type, predictedSize, channel);
}

auto PNeckoChild::SendPAltDataOutputStreamConstructor(
        PAltDataOutputStreamChild* actor,
        const nsCString& type,
        const int64_t& predictedSize,
        PHttpChannelChild* channel) -> PAltDataOutputStreamChild*
{
    if ((!(actor))) {
        NS_WARNING("Error constructing actor PAltDataOutputStreamChild");
        return nullptr;
    }
    (actor)->SetManagerAndRegister(this);
    (mManagedPAltDataOutputStreamChild).PutEntry(actor);
    (actor)->mLivenessState = mozilla::ipc::LivenessState::Start;

    IPC::Message* msg__ = PNecko::Msg_PAltDataOutputStreamConstructor(Id());

    MOZ_RELEASE_ASSERT(actor, "NULL actor value passed to non-nullable param");
    WriteIPDLParam(msg__, this, actor);
    // Sentinel = 'actor'
    (msg__)->WriteSentinel(875202478);
    WriteIPDLParam(msg__, this, type);
    // Sentinel = 'type'
    (msg__)->WriteSentinel(2982068540);
    WriteIPDLParam(msg__, this, predictedSize);
    // Sentinel = 'predictedSize'
    (msg__)->WriteSentinel(1432646818);
    MOZ_RELEASE_ASSERT(channel, "NULL actor value passed to non-nullable param");
    WriteIPDLParam(msg__, this, channel);
    // Sentinel = 'channel'
    (msg__)->WriteSentinel(452840382);



    if (mozilla::ipc::LoggingEnabledFor("PNeckoChild")) {
        mozilla::ipc::LogMessageForProtocol("PNeckoChild", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PNecko::Msg_PAltDataOutputStreamConstructor", OTHER);
    if ((!(StateTransition(false, (&(mLivenessState)))))) {
        mozilla::ipc::LogicError("Transition error");
    }

    bool sendok__ = (GetIPCChannel())->Send(msg__);
    if ((!(sendok__))) {
        FatalError("constructor for actor failed");
        return nullptr;
    }
    return actor;
}

auto PNeckoChild::SendPStunAddrsRequestConstructor() -> PStunAddrsRequestChild*
{
    return SendPStunAddrsRequestConstructor(AllocPStunAddrsRequestChild());
}

auto PNeckoChild::SendPStunAddrsRequestConstructor(PStunAddrsRequestChild* actor) -> PStunAddrsRequestChild*
{
    if ((!(actor))) {
        NS_WARNING("Error constructing actor PStunAddrsRequestChild");
        return nullptr;
    }
    (actor)->SetManagerAndRegister(this);
    (mManagedPStunAddrsRequestChild).PutEntry(actor);
    (actor)->mLivenessState = mozilla::ipc::LivenessState::Start;

    IPC::Message* msg__ = PNecko::Msg_PStunAddrsRequestConstructor(Id());

    MOZ_RELEASE_ASSERT(actor, "NULL actor value passed to non-nullable param");
    WriteIPDLParam(msg__, this, actor);
    // Sentinel = 'actor'
    (msg__)->WriteSentinel(875202478);



    if (mozilla::ipc::LoggingEnabledFor("PNeckoChild")) {
        mozilla::ipc::LogMessageForProtocol("PNeckoChild", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PNecko::Msg_PStunAddrsRequestConstructor", OTHER);
    if ((!(StateTransition(false, (&(mLivenessState)))))) {
        mozilla::ipc::LogicError("Transition error");
    }

    bool sendok__ = (GetIPCChannel())->Send(msg__);
    if ((!(sendok__))) {
        FatalError("constructor for actor failed");
        return nullptr;
    }
    return actor;
}

auto PNeckoChild::SendGetExtensionStream(
        const URIParams& uri,
        mozilla::ipc::ResolveCallback<RefPtr<nsIInputStream>>&& aResolve,
        mozilla::ipc::RejectCallback&& aReject) -> void
{
    IPC::Message* msg__ = PNecko::Msg_GetExtensionStream(Id());

    WriteIPDLParam(msg__, this, uri);
    // Sentinel = 'uri'
    (msg__)->WriteSentinel(1453210605);




    if (mozilla::ipc::LoggingEnabledFor("PNeckoChild")) {
        mozilla::ipc::LogMessageForProtocol("PNeckoChild", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PNecko::Msg_GetExtensionStream", OTHER);
    if ((!(StateTransition(false, (&(mLivenessState)))))) {
        mozilla::ipc::LogicError("Transition error");
    }

    (GetIPCChannel())->Send(msg__, this, std::move(aResolve), std::move(aReject));
    return;
}

auto PNeckoChild::SendGetExtensionStream(const URIParams& uri) -> RefPtr<GetExtensionStreamPromise>
{

    RefPtr<MozPromise<RefPtr<nsIInputStream>, ResponseRejectReason, false>::Private> promise__ = new MozPromise<RefPtr<nsIInputStream>, ResponseRejectReason, false>::Private(__func__);

    SendGetExtensionStream(uri, [promise__](RefPtr<nsIInputStream>&& aValue) {
        (promise__)->Resolve(std::move(aValue), __func__);
    }, [promise__](ResponseRejectReason aReason) {
        (promise__)->Reject(aReason, __func__);
    });
    return promise__;
}

auto PNeckoChild::SendGetExtensionFD(
        const URIParams& uri,
        mozilla::ipc::ResolveCallback<FileDescriptor>&& aResolve,
        mozilla::ipc::RejectCallback&& aReject) -> void
{
    IPC::Message* msg__ = PNecko::Msg_GetExtensionFD(Id());

    WriteIPDLParam(msg__, this, uri);
    // Sentinel = 'uri'
    (msg__)->WriteSentinel(1453210605);




    if (mozilla::ipc::LoggingEnabledFor("PNeckoChild")) {
        mozilla::ipc::LogMessageForProtocol("PNeckoChild", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PNecko::Msg_GetExtensionFD", OTHER);
    if ((!(StateTransition(false, (&(mLivenessState)))))) {
        mozilla::ipc::LogicError("Transition error");
    }

    (GetIPCChannel())->Send(msg__, this, std::move(aResolve), std::move(aReject));
    return;
}

auto PNeckoChild::SendGetExtensionFD(const URIParams& uri) -> RefPtr<GetExtensionFDPromise>
{

    RefPtr<MozPromise<FileDescriptor, ResponseRejectReason, false>::Private> promise__ = new MozPromise<FileDescriptor, ResponseRejectReason, false>::Private(__func__);

    SendGetExtensionFD(uri, [promise__](FileDescriptor&& aValue) {
        (promise__)->Resolve(std::move(aValue), __func__);
    }, [promise__](ResponseRejectReason aReason) {
        (promise__)->Reject(aReason, __func__);
    });
    return promise__;
}

auto PNeckoChild::SendPTCPSocketConstructor(
        const nsString& host,
        const uint16_t& port) -> PTCPSocketChild*
{
    return SendPTCPSocketConstructor(AllocPTCPSocketChild(host, port), host, port);
}

auto PNeckoChild::SendPTCPSocketConstructor(
        PTCPSocketChild* actor,
        const nsString& host,
        const uint16_t& port) -> PTCPSocketChild*
{
    if ((!(actor))) {
        NS_WARNING("Error constructing actor PTCPSocketChild");
        return nullptr;
    }
    (actor)->SetManagerAndRegister(this);
    (mManagedPTCPSocketChild).PutEntry(actor);
    (actor)->mLivenessState = mozilla::ipc::LivenessState::Start;

    IPC::Message* msg__ = PNecko::Msg_PTCPSocketConstructor(Id());

    MOZ_RELEASE_ASSERT(actor, "NULL actor value passed to non-nullable param");
    WriteIPDLParam(msg__, this, actor);
    // Sentinel = 'actor'
    (msg__)->WriteSentinel(875202478);
    WriteIPDLParam(msg__, this, host);
    // Sentinel = 'host'
    (msg__)->WriteSentinel(4070301394);
    WriteIPDLParam(msg__, this, port);
    // Sentinel = 'port'
    (msg__)->WriteSentinel(3633211549);



    if (mozilla::ipc::LoggingEnabledFor("PNeckoChild")) {
        mozilla::ipc::LogMessageForProtocol("PNeckoChild", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PNecko::Msg_PTCPSocketConstructor", OTHER);
    if ((!(StateTransition(false, (&(mLivenessState)))))) {
        mozilla::ipc::LogicError("Transition error");
    }

    bool sendok__ = (GetIPCChannel())->Send(msg__);
    if ((!(sendok__))) {
        FatalError("constructor for actor failed");
        return nullptr;
    }
    return actor;
}

auto PNeckoChild::RemoveManagee(
        int32_t aProtocolId,
        IProtocol* aListener) -> void
{
    switch (aProtocolId) {
    case PHttpChannelMsgStart:
        {
            PHttpChannelChild* actor = static_cast<PHttpChannelChild*>(aListener);
            auto& container = mManagedPHttpChannelChild;
            MOZ_RELEASE_ASSERT((container).Contains(actor), "actor not managed by this!");

            (container).RemoveEntry(actor);
            DeallocPHttpChannelChild(actor);
            return;
        }
    case PCookieServiceMsgStart:
        {
            PCookieServiceChild* actor = static_cast<PCookieServiceChild*>(aListener);
            auto& container = mManagedPCookieServiceChild;
            MOZ_RELEASE_ASSERT((container).Contains(actor), "actor not managed by this!");

            (container).RemoveEntry(actor);
            DeallocPCookieServiceChild(actor);
            return;
        }
    case PWyciwygChannelMsgStart:
        {
            PWyciwygChannelChild* actor = static_cast<PWyciwygChannelChild*>(aListener);
            auto& container = mManagedPWyciwygChannelChild;
            MOZ_RELEASE_ASSERT((container).Contains(actor), "actor not managed by this!");

            (container).RemoveEntry(actor);
            DeallocPWyciwygChannelChild(actor);
            return;
        }
    case PFTPChannelMsgStart:
        {
            PFTPChannelChild* actor = static_cast<PFTPChannelChild*>(aListener);
            auto& container = mManagedPFTPChannelChild;
            MOZ_RELEASE_ASSERT((container).Contains(actor), "actor not managed by this!");

            (container).RemoveEntry(actor);
            DeallocPFTPChannelChild(actor);
            return;
        }
    case PWebSocketMsgStart:
        {
            PWebSocketChild* actor = static_cast<PWebSocketChild*>(aListener);
            auto& container = mManagedPWebSocketChild;
            MOZ_RELEASE_ASSERT((container).Contains(actor), "actor not managed by this!");

            (container).RemoveEntry(actor);
            DeallocPWebSocketChild(actor);
            return;
        }
    case PWebSocketEventListenerMsgStart:
        {
            PWebSocketEventListenerChild* actor = static_cast<PWebSocketEventListenerChild*>(aListener);
            auto& container = mManagedPWebSocketEventListenerChild;
            MOZ_RELEASE_ASSERT((container).Contains(actor), "actor not managed by this!");

            (container).RemoveEntry(actor);
            DeallocPWebSocketEventListenerChild(actor);
            return;
        }
    case PTCPSocketMsgStart:
        {
            PTCPSocketChild* actor = static_cast<PTCPSocketChild*>(aListener);
            auto& container = mManagedPTCPSocketChild;
            MOZ_RELEASE_ASSERT((container).Contains(actor), "actor not managed by this!");

            (container).RemoveEntry(actor);
            DeallocPTCPSocketChild(actor);
            return;
        }
    case PTCPServerSocketMsgStart:
        {
            PTCPServerSocketChild* actor = static_cast<PTCPServerSocketChild*>(aListener);
            auto& container = mManagedPTCPServerSocketChild;
            MOZ_RELEASE_ASSERT((container).Contains(actor), "actor not managed by this!");

            (container).RemoveEntry(actor);
            DeallocPTCPServerSocketChild(actor);
            return;
        }
    case PUDPSocketMsgStart:
        {
            PUDPSocketChild* actor = static_cast<PUDPSocketChild*>(aListener);
            auto& container = mManagedPUDPSocketChild;
            MOZ_RELEASE_ASSERT((container).Contains(actor), "actor not managed by this!");

            (container).RemoveEntry(actor);
            DeallocPUDPSocketChild(actor);
            return;
        }
    case PDNSRequestMsgStart:
        {
            PDNSRequestChild* actor = static_cast<PDNSRequestChild*>(aListener);
            auto& container = mManagedPDNSRequestChild;
            MOZ_RELEASE_ASSERT((container).Contains(actor), "actor not managed by this!");

            (container).RemoveEntry(actor);
            DeallocPDNSRequestChild(actor);
            return;
        }
    case PDataChannelMsgStart:
        {
            PDataChannelChild* actor = static_cast<PDataChannelChild*>(aListener);
            auto& container = mManagedPDataChannelChild;
            MOZ_RELEASE_ASSERT((container).Contains(actor), "actor not managed by this!");

            (container).RemoveEntry(actor);
            DeallocPDataChannelChild(actor);
            return;
        }
    case PSimpleChannelMsgStart:
        {
            PSimpleChannelChild* actor = static_cast<PSimpleChannelChild*>(aListener);
            auto& container = mManagedPSimpleChannelChild;
            MOZ_RELEASE_ASSERT((container).Contains(actor), "actor not managed by this!");

            (container).RemoveEntry(actor);
            DeallocPSimpleChannelChild(actor);
            return;
        }
    case PFileChannelMsgStart:
        {
            PFileChannelChild* actor = static_cast<PFileChannelChild*>(aListener);
            auto& container = mManagedPFileChannelChild;
            MOZ_RELEASE_ASSERT((container).Contains(actor), "actor not managed by this!");

            (container).RemoveEntry(actor);
            DeallocPFileChannelChild(actor);
            return;
        }
    case PChannelDiverterMsgStart:
        {
            PChannelDiverterChild* actor = static_cast<PChannelDiverterChild*>(aListener);
            auto& container = mManagedPChannelDiverterChild;
            MOZ_RELEASE_ASSERT((container).Contains(actor), "actor not managed by this!");

            (container).RemoveEntry(actor);
            DeallocPChannelDiverterChild(actor);
            return;
        }
    case PTransportProviderMsgStart:
        {
            PTransportProviderChild* actor = static_cast<PTransportProviderChild*>(aListener);
            auto& container = mManagedPTransportProviderChild;
            MOZ_RELEASE_ASSERT((container).Contains(actor), "actor not managed by this!");

            (container).RemoveEntry(actor);
            DeallocPTransportProviderChild(actor);
            return;
        }
    case PAltDataOutputStreamMsgStart:
        {
            PAltDataOutputStreamChild* actor = static_cast<PAltDataOutputStreamChild*>(aListener);
            auto& container = mManagedPAltDataOutputStreamChild;
            MOZ_RELEASE_ASSERT((container).Contains(actor), "actor not managed by this!");

            (container).RemoveEntry(actor);
            DeallocPAltDataOutputStreamChild(actor);
            return;
        }
    case PStunAddrsRequestMsgStart:
        {
            PStunAddrsRequestChild* actor = static_cast<PStunAddrsRequestChild*>(aListener);
            auto& container = mManagedPStunAddrsRequestChild;
            MOZ_RELEASE_ASSERT((container).Contains(actor), "actor not managed by this!");

            (container).RemoveEntry(actor);
            DeallocPStunAddrsRequestChild(actor);
            return;
        }
    default:
        {
            FatalError("unreached");
            return;
        }
    }
}

auto PNeckoChild::OnMessageReceived(const Message& msg__) -> PNeckoChild::Result
{
    switch ((msg__).type()) {
    case PNecko::Reply___delete____ID:
        {
            return MsgProcessed;
        }
    case PNecko::Reply_PCookieServiceConstructor__ID:
        {
            return MsgProcessed;
        }
    case PNecko::Reply_PHttpChannelConstructor__ID:
        {
            return MsgProcessed;
        }
    case PNecko::Reply_PWyciwygChannelConstructor__ID:
        {
            return MsgProcessed;
        }
    case PNecko::Reply_PFTPChannelConstructor__ID:
        {
            return MsgProcessed;
        }
    case PNecko::Reply_PWebSocketConstructor__ID:
        {
            return MsgProcessed;
        }
    case PNecko::Reply_PTCPServerSocketConstructor__ID:
        {
            return MsgProcessed;
        }
    case PNecko::Reply_PUDPSocketConstructor__ID:
        {
            return MsgProcessed;
        }
    case PNecko::Reply_PDNSRequestConstructor__ID:
        {
            return MsgProcessed;
        }
    case PNecko::Reply_PWebSocketEventListenerConstructor__ID:
        {
            return MsgProcessed;
        }
    case PNecko::Reply_PDataChannelConstructor__ID:
        {
            return MsgProcessed;
        }
    case PNecko::Reply_PSimpleChannelConstructor__ID:
        {
            return MsgProcessed;
        }
    case PNecko::Reply_PFileChannelConstructor__ID:
        {
            return MsgProcessed;
        }
    case PNecko::Reply_PChannelDiverterConstructor__ID:
        {
            return MsgProcessed;
        }
    case PNecko::Reply_PAltDataOutputStreamConstructor__ID:
        {
            return MsgProcessed;
        }
    case PNecko::Reply_PStunAddrsRequestConstructor__ID:
        {
            return MsgProcessed;
        }
    case PNecko::Reply_GetExtensionStream__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PNeckoChild")) {
                mozilla::ipc::LogMessageForProtocol("PNeckoChild", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PNecko::Msg_GetExtensionStream", OTHER);

            PickleIterator iter__(msg__);
            bool resolve__;
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(resolve__)))))) {
                FatalError("Error deserializing 'resolve__'");
                return MsgValueError;
            }
            // Sentinel = 'resolve__'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 3997392463)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'resolve__'");
                return MsgValueError;
            }

            UniquePtr<MessageChannel::UntypedCallbackHolder> untypedCallback = (GetIPCChannel())->PopCallback(msg__);
            MessageChannel::CallbackHolder<RefPtr<nsIInputStream>>* callback = static_cast<MessageChannel::CallbackHolder<RefPtr<nsIInputStream>>*>((untypedCallback).get());
            if ((!(callback))) {
                FatalError("Error unknown callback");
                return MsgProcessingError;
            }
            if (resolve__) {
                RefPtr<nsIInputStream> stream;

                if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(stream)))))) {
                    FatalError("Error deserializing 'RefPtr'");
                    return MsgValueError;
                }
                // Sentinel = 'stream'
                if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 4152748422)))) {
                    mozilla::ipc::SentinelReadError("Error deserializing 'RefPtr'");
                    return MsgValueError;
                }
                (msg__).EndRead(iter__, (msg__).type());
                (callback)->Resolve(std::move(stream));
            }
            else {
                ResponseRejectReason reason__;
                if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(reason__)))))) {
                    FatalError("Error deserializing 'reason__'");
                    return MsgValueError;
                }
                // Sentinel = 'reason__'
                if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 913452670)))) {
                    mozilla::ipc::SentinelReadError("Error deserializing 'reason__'");
                    return MsgValueError;
                }
                (msg__).EndRead(iter__, (msg__).type());
                (callback)->Reject(reason__);
            }
            return MsgProcessed;
        }
    case PNecko::Reply_GetExtensionFD__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PNeckoChild")) {
                mozilla::ipc::LogMessageForProtocol("PNeckoChild", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PNecko::Msg_GetExtensionFD", OTHER);

            PickleIterator iter__(msg__);
            bool resolve__;
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(resolve__)))))) {
                FatalError("Error deserializing 'resolve__'");
                return MsgValueError;
            }
            // Sentinel = 'resolve__'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 3997392463)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'resolve__'");
                return MsgValueError;
            }

            UniquePtr<MessageChannel::UntypedCallbackHolder> untypedCallback = (GetIPCChannel())->PopCallback(msg__);
            MessageChannel::CallbackHolder<FileDescriptor>* callback = static_cast<MessageChannel::CallbackHolder<FileDescriptor>*>((untypedCallback).get());
            if ((!(callback))) {
                FatalError("Error unknown callback");
                return MsgProcessingError;
            }
            if (resolve__) {
                FileDescriptor fd;

                if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(fd)))))) {
                    FatalError("Error deserializing 'FileDescriptor'");
                    return MsgValueError;
                }
                // Sentinel = 'fd'
                if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 628535764)))) {
                    mozilla::ipc::SentinelReadError("Error deserializing 'FileDescriptor'");
                    return MsgValueError;
                }
                (msg__).EndRead(iter__, (msg__).type());
                (callback)->Resolve(std::move(fd));
            }
            else {
                ResponseRejectReason reason__;
                if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(reason__)))))) {
                    FatalError("Error deserializing 'reason__'");
                    return MsgValueError;
                }
                // Sentinel = 'reason__'
                if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 913452670)))) {
                    mozilla::ipc::SentinelReadError("Error deserializing 'reason__'");
                    return MsgValueError;
                }
                (msg__).EndRead(iter__, (msg__).type());
                (callback)->Reject(reason__);
            }
            return MsgProcessed;
        }
    case PNecko::Msg_AsyncAuthPromptForNestedFrame__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PNeckoChild")) {
                mozilla::ipc::LogMessageForProtocol("PNeckoChild", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PNecko::Msg_AsyncAuthPromptForNestedFrame", OTHER);

            PickleIterator iter__(msg__);
            TabId nestedFrameId;
            nsCString uri;
            nsString realm;
            uint64_t callbackId;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(nestedFrameId)))))) {
                FatalError("Error deserializing 'TabId'");
                return MsgValueError;
            }
            // Sentinel = 'nestedFrameId'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 168911970)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'TabId'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(uri)))))) {
                FatalError("Error deserializing 'nsCString'");
                return MsgValueError;
            }
            // Sentinel = 'uri'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 1453210605)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsCString'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(realm)))))) {
                FatalError("Error deserializing 'nsString'");
                return MsgValueError;
            }
            // Sentinel = 'realm'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 1127162788)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsString'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(callbackId)))))) {
                FatalError("Error deserializing 'uint64_t'");
                return MsgValueError;
            }
            // Sentinel = 'callbackId'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 4163989448)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            if ((!(RecvAsyncAuthPromptForNestedFrame(nestedFrameId, uri, realm, callbackId)))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PNecko::Msg_PredOnPredictPrefetch__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PNeckoChild")) {
                mozilla::ipc::LogMessageForProtocol("PNeckoChild", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PNecko::Msg_PredOnPredictPrefetch", OTHER);

            PickleIterator iter__(msg__);
            URIParams uri;
            uint32_t httpStatus;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(uri)))))) {
                FatalError("Error deserializing 'URIParams'");
                return MsgValueError;
            }
            // Sentinel = 'uri'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 1453210605)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'URIParams'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(httpStatus)))))) {
                FatalError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            // Sentinel = 'httpStatus'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 2648726124)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            if ((!(RecvPredOnPredictPrefetch(uri, httpStatus)))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PNecko::Msg_PredOnPredictPreconnect__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PNeckoChild")) {
                mozilla::ipc::LogMessageForProtocol("PNeckoChild", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PNecko::Msg_PredOnPredictPreconnect", OTHER);

            PickleIterator iter__(msg__);
            URIParams uri;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(uri)))))) {
                FatalError("Error deserializing 'URIParams'");
                return MsgValueError;
            }
            // Sentinel = 'uri'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 1453210605)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'URIParams'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            if ((!(RecvPredOnPredictPreconnect(uri)))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PNecko::Msg_PredOnPredictDNS__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PNeckoChild")) {
                mozilla::ipc::LogMessageForProtocol("PNeckoChild", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PNecko::Msg_PredOnPredictDNS", OTHER);

            PickleIterator iter__(msg__);
            URIParams uri;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(uri)))))) {
                FatalError("Error deserializing 'URIParams'");
                return MsgValueError;
            }
            // Sentinel = 'uri'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 1453210605)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'URIParams'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            if ((!(RecvPredOnPredictDNS(uri)))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PNecko::Msg_SpeculativeConnectRequest__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PNeckoChild")) {
                mozilla::ipc::LogMessageForProtocol("PNeckoChild", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PNecko::Msg_SpeculativeConnectRequest", OTHER);

            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            if ((!(RecvSpeculativeConnectRequest()))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PNecko::Msg_NetworkChangeNotification__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PNeckoChild")) {
                mozilla::ipc::LogMessageForProtocol("PNeckoChild", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PNecko::Msg_NetworkChangeNotification", OTHER);

            PickleIterator iter__(msg__);
            nsCString type;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(type)))))) {
                FatalError("Error deserializing 'nsCString'");
                return MsgValueError;
            }
            // Sentinel = 'type'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 2982068540)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsCString'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            if ((!(RecvNetworkChangeNotification(type)))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PNecko::Msg_PTransportProviderConstructor__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PNeckoChild")) {
                mozilla::ipc::LogMessageForProtocol("PNeckoChild", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PNecko::Msg_PTransportProviderConstructor", OTHER);

            PickleIterator iter__(msg__);
            ActorHandle handle__;
            PTransportProviderChild* actor;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(handle__)))))) {
                FatalError("Error deserializing 'ActorHandle'");
                return MsgValueError;
            }
            // Sentinel = 'actor'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 875202478)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'ActorHandle'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            actor = AllocPTransportProviderChild();
            if ((!(actor))) {
                NS_WARNING("Error constructing actor PTransportProviderChild");
                return MsgValueError;
            }
            (actor)->SetManagerAndRegister(this, (handle__).mId);
            (mManagedPTransportProviderChild).PutEntry(actor);
            (actor)->mLivenessState = mozilla::ipc::LivenessState::Start;

            if ((!(RecvPTransportProviderConstructor(actor)))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PNecko::Msg_CrossProcessRedirect__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PNeckoChild")) {
                mozilla::ipc::LogMessageForProtocol("PNeckoChild", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PNecko::Msg_CrossProcessRedirect", OTHER);

            PickleIterator iter__(msg__);
            uint32_t aRegistrarId;
            RefPtr<nsIURI> aURI;
            uint32_t aNewLoadFlags;
            OptionalLoadInfoArgs aLoadInfo;
            uint64_t aChannelId;
            RefPtr<nsIURI> aOriginalURI;
            uint64_t aIdentifier;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aRegistrarId)))))) {
                FatalError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            // Sentinel = 'aRegistrarId'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 147707153)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aURI)))))) {
                FatalError("Error deserializing 'RefPtr'");
                return MsgValueError;
            }
            // Sentinel = 'aURI'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 2075506333)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'RefPtr'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aNewLoadFlags)))))) {
                FatalError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            // Sentinel = 'aNewLoadFlags'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 2417012963)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aLoadInfo)))))) {
                FatalError("Error deserializing 'OptionalLoadInfoArgs'");
                return MsgValueError;
            }
            // Sentinel = 'aLoadInfo'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 2922022260)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'OptionalLoadInfoArgs'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aChannelId)))))) {
                FatalError("Error deserializing 'uint64_t'");
                return MsgValueError;
            }
            // Sentinel = 'aChannelId'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 3807997239)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aOriginalURI)))))) {
                FatalError("Error deserializing 'RefPtr'");
                return MsgValueError;
            }
            // Sentinel = 'aOriginalURI'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 680917642)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'RefPtr'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aIdentifier)))))) {
                FatalError("Error deserializing 'uint64_t'");
                return MsgValueError;
            }
            // Sentinel = 'aIdentifier'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 3975378435)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            if ((!(RecvCrossProcessRedirect(aRegistrarId, aURI, aNewLoadFlags, aLoadInfo, aChannelId, aOriginalURI, aIdentifier)))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PNecko::Reply_PTCPSocketConstructor__ID:
        {
            return MsgProcessed;
        }
    case PNecko::Msg_PTCPSocketConstructor__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PNeckoChild")) {
                mozilla::ipc::LogMessageForProtocol("PNeckoChild", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PNecko::Msg_PTCPSocketConstructor", OTHER);

            PickleIterator iter__(msg__);
            ActorHandle handle__;
            PTCPSocketChild* actor;
            nsString host;
            uint16_t port;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(handle__)))))) {
                FatalError("Error deserializing 'ActorHandle'");
                return MsgValueError;
            }
            // Sentinel = 'actor'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 875202478)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'ActorHandle'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(host)))))) {
                FatalError("Error deserializing 'nsString'");
                return MsgValueError;
            }
            // Sentinel = 'host'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 4070301394)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsString'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(port)))))) {
                FatalError("Error deserializing 'uint16_t'");
                return MsgValueError;
            }
            // Sentinel = 'port'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 3633211549)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint16_t'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            actor = AllocPTCPSocketChild(host, port);
            if ((!(actor))) {
                NS_WARNING("Error constructing actor PTCPSocketChild");
                return MsgValueError;
            }
            (actor)->SetManagerAndRegister(this, (handle__).mId);
            (mManagedPTCPSocketChild).PutEntry(actor);
            (actor)->mLivenessState = mozilla::ipc::LivenessState::Start;

            if ((!(RecvPTCPSocketConstructor(actor, host, port)))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    default:
        {
            return MsgNotKnown;
        }
    }
}

auto PNeckoChild::OnMessageReceived(
        const Message& msg__,
        Message*& reply__) -> PNeckoChild::Result
{
    return MsgNotKnown;
}

auto PNeckoChild::OnCallReceived(
        const Message& msg__,
        Message*& reply__) -> PNeckoChild::Result
{
    MOZ_ASSERT_UNREACHABLE("message protocol not supported");
    return MsgNotKnown;
}

auto PNeckoChild::GetProtocolTypeId() -> int32_t
{
    return PNeckoMsgStart;
}

auto PNeckoChild::DestroySubtree(ActorDestroyReason why) -> void
{
    // Unregister from our manager.
    Unregister(Id());

    ActorDestroyReason subtreewhy = (((why) == (Deletion)) || ((why) == (FailedConstructor)) ? AncestorDeletion : why);

    {
        // Recursively shutting down PHttpChannel kids
        nsTArray<PHttpChannelChild*> kids;
        // Accumulate kids into a stable structure to iterate over
        ManagedPHttpChannelChild(kids);
        for (auto& kid : kids) {
            // Guarding against a child removing a sibling from the list during the iteration.
            if ((mManagedPHttpChannelChild).Contains(kid)) {
                (kid)->DestroySubtree(subtreewhy);
            }
        }
    }
    {
        // Recursively shutting down PCookieService kids
        nsTArray<PCookieServiceChild*> kids;
        // Accumulate kids into a stable structure to iterate over
        ManagedPCookieServiceChild(kids);
        for (auto& kid : kids) {
            // Guarding against a child removing a sibling from the list during the iteration.
            if ((mManagedPCookieServiceChild).Contains(kid)) {
                (kid)->DestroySubtree(subtreewhy);
            }
        }
    }
    {
        // Recursively shutting down PWyciwygChannel kids
        nsTArray<PWyciwygChannelChild*> kids;
        // Accumulate kids into a stable structure to iterate over
        ManagedPWyciwygChannelChild(kids);
        for (auto& kid : kids) {
            // Guarding against a child removing a sibling from the list during the iteration.
            if ((mManagedPWyciwygChannelChild).Contains(kid)) {
                (kid)->DestroySubtree(subtreewhy);
            }
        }
    }
    {
        // Recursively shutting down PFTPChannel kids
        nsTArray<PFTPChannelChild*> kids;
        // Accumulate kids into a stable structure to iterate over
        ManagedPFTPChannelChild(kids);
        for (auto& kid : kids) {
            // Guarding against a child removing a sibling from the list during the iteration.
            if ((mManagedPFTPChannelChild).Contains(kid)) {
                (kid)->DestroySubtree(subtreewhy);
            }
        }
    }
    {
        // Recursively shutting down PWebSocket kids
        nsTArray<PWebSocketChild*> kids;
        // Accumulate kids into a stable structure to iterate over
        ManagedPWebSocketChild(kids);
        for (auto& kid : kids) {
            // Guarding against a child removing a sibling from the list during the iteration.
            if ((mManagedPWebSocketChild).Contains(kid)) {
                (kid)->DestroySubtree(subtreewhy);
            }
        }
    }
    {
        // Recursively shutting down PWebSocketEventListener kids
        nsTArray<PWebSocketEventListenerChild*> kids;
        // Accumulate kids into a stable structure to iterate over
        ManagedPWebSocketEventListenerChild(kids);
        for (auto& kid : kids) {
            // Guarding against a child removing a sibling from the list during the iteration.
            if ((mManagedPWebSocketEventListenerChild).Contains(kid)) {
                (kid)->DestroySubtree(subtreewhy);
            }
        }
    }
    {
        // Recursively shutting down PTCPSocket kids
        nsTArray<PTCPSocketChild*> kids;
        // Accumulate kids into a stable structure to iterate over
        ManagedPTCPSocketChild(kids);
        for (auto& kid : kids) {
            // Guarding against a child removing a sibling from the list during the iteration.
            if ((mManagedPTCPSocketChild).Contains(kid)) {
                (kid)->DestroySubtree(subtreewhy);
            }
        }
    }
    {
        // Recursively shutting down PTCPServerSocket kids
        nsTArray<PTCPServerSocketChild*> kids;
        // Accumulate kids into a stable structure to iterate over
        ManagedPTCPServerSocketChild(kids);
        for (auto& kid : kids) {
            // Guarding against a child removing a sibling from the list during the iteration.
            if ((mManagedPTCPServerSocketChild).Contains(kid)) {
                (kid)->DestroySubtree(subtreewhy);
            }
        }
    }
    {
        // Recursively shutting down PUDPSocket kids
        nsTArray<PUDPSocketChild*> kids;
        // Accumulate kids into a stable structure to iterate over
        ManagedPUDPSocketChild(kids);
        for (auto& kid : kids) {
            // Guarding against a child removing a sibling from the list during the iteration.
            if ((mManagedPUDPSocketChild).Contains(kid)) {
                (kid)->DestroySubtree(subtreewhy);
            }
        }
    }
    {
        // Recursively shutting down PDNSRequest kids
        nsTArray<PDNSRequestChild*> kids;
        // Accumulate kids into a stable structure to iterate over
        ManagedPDNSRequestChild(kids);
        for (auto& kid : kids) {
            // Guarding against a child removing a sibling from the list during the iteration.
            if ((mManagedPDNSRequestChild).Contains(kid)) {
                (kid)->DestroySubtree(subtreewhy);
            }
        }
    }
    {
        // Recursively shutting down PDataChannel kids
        nsTArray<PDataChannelChild*> kids;
        // Accumulate kids into a stable structure to iterate over
        ManagedPDataChannelChild(kids);
        for (auto& kid : kids) {
            // Guarding against a child removing a sibling from the list during the iteration.
            if ((mManagedPDataChannelChild).Contains(kid)) {
                (kid)->DestroySubtree(subtreewhy);
            }
        }
    }
    {
        // Recursively shutting down PSimpleChannel kids
        nsTArray<PSimpleChannelChild*> kids;
        // Accumulate kids into a stable structure to iterate over
        ManagedPSimpleChannelChild(kids);
        for (auto& kid : kids) {
            // Guarding against a child removing a sibling from the list during the iteration.
            if ((mManagedPSimpleChannelChild).Contains(kid)) {
                (kid)->DestroySubtree(subtreewhy);
            }
        }
    }
    {
        // Recursively shutting down PFileChannel kids
        nsTArray<PFileChannelChild*> kids;
        // Accumulate kids into a stable structure to iterate over
        ManagedPFileChannelChild(kids);
        for (auto& kid : kids) {
            // Guarding against a child removing a sibling from the list during the iteration.
            if ((mManagedPFileChannelChild).Contains(kid)) {
                (kid)->DestroySubtree(subtreewhy);
            }
        }
    }
    {
        // Recursively shutting down PChannelDiverter kids
        nsTArray<PChannelDiverterChild*> kids;
        // Accumulate kids into a stable structure to iterate over
        ManagedPChannelDiverterChild(kids);
        for (auto& kid : kids) {
            // Guarding against a child removing a sibling from the list during the iteration.
            if ((mManagedPChannelDiverterChild).Contains(kid)) {
                (kid)->DestroySubtree(subtreewhy);
            }
        }
    }
    {
        // Recursively shutting down PTransportProvider kids
        nsTArray<PTransportProviderChild*> kids;
        // Accumulate kids into a stable structure to iterate over
        ManagedPTransportProviderChild(kids);
        for (auto& kid : kids) {
            // Guarding against a child removing a sibling from the list during the iteration.
            if ((mManagedPTransportProviderChild).Contains(kid)) {
                (kid)->DestroySubtree(subtreewhy);
            }
        }
    }
    {
        // Recursively shutting down PAltDataOutputStream kids
        nsTArray<PAltDataOutputStreamChild*> kids;
        // Accumulate kids into a stable structure to iterate over
        ManagedPAltDataOutputStreamChild(kids);
        for (auto& kid : kids) {
            // Guarding against a child removing a sibling from the list during the iteration.
            if ((mManagedPAltDataOutputStreamChild).Contains(kid)) {
                (kid)->DestroySubtree(subtreewhy);
            }
        }
    }
    {
        // Recursively shutting down PStunAddrsRequest kids
        nsTArray<PStunAddrsRequestChild*> kids;
        // Accumulate kids into a stable structure to iterate over
        ManagedPStunAddrsRequestChild(kids);
        for (auto& kid : kids) {
            // Guarding against a child removing a sibling from the list during the iteration.
            if ((mManagedPStunAddrsRequestChild).Contains(kid)) {
                (kid)->DestroySubtree(subtreewhy);
            }
        }
    }

    // Reject owning pending responses.
    (GetIPCChannel())->RejectPendingResponsesForActor(this);

    // Finally, destroy "us".
    ActorDestroy(why);
}

auto PNeckoChild::DeallocSubtree() -> void
{
    {
        // Recursively deleting PHttpChannel kids
        for (auto iter = (mManagedPHttpChannelChild).Iter(); (!((iter).Done())); (iter).Next()) {
            (((iter).Get())->GetKey())->DeallocSubtree();
        }

        for (auto iter = (mManagedPHttpChannelChild).Iter(); (!((iter).Done())); (iter).Next()) {
            DeallocPHttpChannelChild(((iter).Get())->GetKey());
        }
        (mManagedPHttpChannelChild).Clear();
    }
    {
        // Recursively deleting PCookieService kids
        for (auto iter = (mManagedPCookieServiceChild).Iter(); (!((iter).Done())); (iter).Next()) {
            (((iter).Get())->GetKey())->DeallocSubtree();
        }

        for (auto iter = (mManagedPCookieServiceChild).Iter(); (!((iter).Done())); (iter).Next()) {
            DeallocPCookieServiceChild(((iter).Get())->GetKey());
        }
        (mManagedPCookieServiceChild).Clear();
    }
    {
        // Recursively deleting PWyciwygChannel kids
        for (auto iter = (mManagedPWyciwygChannelChild).Iter(); (!((iter).Done())); (iter).Next()) {
            (((iter).Get())->GetKey())->DeallocSubtree();
        }

        for (auto iter = (mManagedPWyciwygChannelChild).Iter(); (!((iter).Done())); (iter).Next()) {
            DeallocPWyciwygChannelChild(((iter).Get())->GetKey());
        }
        (mManagedPWyciwygChannelChild).Clear();
    }
    {
        // Recursively deleting PFTPChannel kids
        for (auto iter = (mManagedPFTPChannelChild).Iter(); (!((iter).Done())); (iter).Next()) {
            (((iter).Get())->GetKey())->DeallocSubtree();
        }

        for (auto iter = (mManagedPFTPChannelChild).Iter(); (!((iter).Done())); (iter).Next()) {
            DeallocPFTPChannelChild(((iter).Get())->GetKey());
        }
        (mManagedPFTPChannelChild).Clear();
    }
    {
        // Recursively deleting PWebSocket kids
        for (auto iter = (mManagedPWebSocketChild).Iter(); (!((iter).Done())); (iter).Next()) {
            (((iter).Get())->GetKey())->DeallocSubtree();
        }

        for (auto iter = (mManagedPWebSocketChild).Iter(); (!((iter).Done())); (iter).Next()) {
            DeallocPWebSocketChild(((iter).Get())->GetKey());
        }
        (mManagedPWebSocketChild).Clear();
    }
    {
        // Recursively deleting PWebSocketEventListener kids
        for (auto iter = (mManagedPWebSocketEventListenerChild).Iter(); (!((iter).Done())); (iter).Next()) {
            (((iter).Get())->GetKey())->DeallocSubtree();
        }

        for (auto iter = (mManagedPWebSocketEventListenerChild).Iter(); (!((iter).Done())); (iter).Next()) {
            DeallocPWebSocketEventListenerChild(((iter).Get())->GetKey());
        }
        (mManagedPWebSocketEventListenerChild).Clear();
    }
    {
        // Recursively deleting PTCPSocket kids
        for (auto iter = (mManagedPTCPSocketChild).Iter(); (!((iter).Done())); (iter).Next()) {
            (((iter).Get())->GetKey())->DeallocSubtree();
        }

        for (auto iter = (mManagedPTCPSocketChild).Iter(); (!((iter).Done())); (iter).Next()) {
            DeallocPTCPSocketChild(((iter).Get())->GetKey());
        }
        (mManagedPTCPSocketChild).Clear();
    }
    {
        // Recursively deleting PTCPServerSocket kids
        for (auto iter = (mManagedPTCPServerSocketChild).Iter(); (!((iter).Done())); (iter).Next()) {
            (((iter).Get())->GetKey())->DeallocSubtree();
        }

        for (auto iter = (mManagedPTCPServerSocketChild).Iter(); (!((iter).Done())); (iter).Next()) {
            DeallocPTCPServerSocketChild(((iter).Get())->GetKey());
        }
        (mManagedPTCPServerSocketChild).Clear();
    }
    {
        // Recursively deleting PUDPSocket kids
        for (auto iter = (mManagedPUDPSocketChild).Iter(); (!((iter).Done())); (iter).Next()) {
            (((iter).Get())->GetKey())->DeallocSubtree();
        }

        for (auto iter = (mManagedPUDPSocketChild).Iter(); (!((iter).Done())); (iter).Next()) {
            DeallocPUDPSocketChild(((iter).Get())->GetKey());
        }
        (mManagedPUDPSocketChild).Clear();
    }
    {
        // Recursively deleting PDNSRequest kids
        for (auto iter = (mManagedPDNSRequestChild).Iter(); (!((iter).Done())); (iter).Next()) {
            (((iter).Get())->GetKey())->DeallocSubtree();
        }

        for (auto iter = (mManagedPDNSRequestChild).Iter(); (!((iter).Done())); (iter).Next()) {
            DeallocPDNSRequestChild(((iter).Get())->GetKey());
        }
        (mManagedPDNSRequestChild).Clear();
    }
    {
        // Recursively deleting PDataChannel kids
        for (auto iter = (mManagedPDataChannelChild).Iter(); (!((iter).Done())); (iter).Next()) {
            (((iter).Get())->GetKey())->DeallocSubtree();
        }

        for (auto iter = (mManagedPDataChannelChild).Iter(); (!((iter).Done())); (iter).Next()) {
            DeallocPDataChannelChild(((iter).Get())->GetKey());
        }
        (mManagedPDataChannelChild).Clear();
    }
    {
        // Recursively deleting PSimpleChannel kids
        for (auto iter = (mManagedPSimpleChannelChild).Iter(); (!((iter).Done())); (iter).Next()) {
            (((iter).Get())->GetKey())->DeallocSubtree();
        }

        for (auto iter = (mManagedPSimpleChannelChild).Iter(); (!((iter).Done())); (iter).Next()) {
            DeallocPSimpleChannelChild(((iter).Get())->GetKey());
        }
        (mManagedPSimpleChannelChild).Clear();
    }
    {
        // Recursively deleting PFileChannel kids
        for (auto iter = (mManagedPFileChannelChild).Iter(); (!((iter).Done())); (iter).Next()) {
            (((iter).Get())->GetKey())->DeallocSubtree();
        }

        for (auto iter = (mManagedPFileChannelChild).Iter(); (!((iter).Done())); (iter).Next()) {
            DeallocPFileChannelChild(((iter).Get())->GetKey());
        }
        (mManagedPFileChannelChild).Clear();
    }
    {
        // Recursively deleting PChannelDiverter kids
        for (auto iter = (mManagedPChannelDiverterChild).Iter(); (!((iter).Done())); (iter).Next()) {
            (((iter).Get())->GetKey())->DeallocSubtree();
        }

        for (auto iter = (mManagedPChannelDiverterChild).Iter(); (!((iter).Done())); (iter).Next()) {
            DeallocPChannelDiverterChild(((iter).Get())->GetKey());
        }
        (mManagedPChannelDiverterChild).Clear();
    }
    {
        // Recursively deleting PTransportProvider kids
        for (auto iter = (mManagedPTransportProviderChild).Iter(); (!((iter).Done())); (iter).Next()) {
            (((iter).Get())->GetKey())->DeallocSubtree();
        }

        for (auto iter = (mManagedPTransportProviderChild).Iter(); (!((iter).Done())); (iter).Next()) {
            DeallocPTransportProviderChild(((iter).Get())->GetKey());
        }
        (mManagedPTransportProviderChild).Clear();
    }
    {
        // Recursively deleting PAltDataOutputStream kids
        for (auto iter = (mManagedPAltDataOutputStreamChild).Iter(); (!((iter).Done())); (iter).Next()) {
            (((iter).Get())->GetKey())->DeallocSubtree();
        }

        for (auto iter = (mManagedPAltDataOutputStreamChild).Iter(); (!((iter).Done())); (iter).Next()) {
            DeallocPAltDataOutputStreamChild(((iter).Get())->GetKey());
        }
        (mManagedPAltDataOutputStreamChild).Clear();
    }
    {
        // Recursively deleting PStunAddrsRequest kids
        for (auto iter = (mManagedPStunAddrsRequestChild).Iter(); (!((iter).Done())); (iter).Next()) {
            (((iter).Get())->GetKey())->DeallocSubtree();
        }

        for (auto iter = (mManagedPStunAddrsRequestChild).Iter(); (!((iter).Done())); (iter).Next()) {
            DeallocPStunAddrsRequestChild(((iter).Get())->GetKey());
        }
        (mManagedPStunAddrsRequestChild).Clear();
    }
}



} // namespace net
} // namespace mozilla
namespace mozilla {
namespace ipc {
auto IPDLParamTraits<mozilla::net::PNeckoChild>::Write(
        IPC::Message* aMsg,
        mozilla::ipc::IProtocol* aActor,
        const paramType& aVar) -> void
{
    int32_t id;
    if ((!(aVar))) {
        id = 0;
    }
    else {
        id = (aVar)->Id();
        if ((1) == (id)) {
            (aActor)->FatalError("actor has been |delete|d");
        }
    }
    WriteIPDLParam(aMsg, aActor, id);
}

auto IPDLParamTraits<mozilla::net::PNeckoChild>::Read(
        const IPC::Message* aMsg,
        PickleIterator* aIter,
        mozilla::ipc::IProtocol* aActor,
        paramType* aVar) -> bool
{
    mozilla::Maybe<mozilla::ipc::IProtocol*> actor = (aActor)->ReadActor(aMsg, aIter, true, "PNecko", PNeckoMsgStart);
    if ((actor).isNothing()) {
        return false;
    }

    (*(aVar)) = static_cast<mozilla::net::PNeckoChild*>((actor).value());
    return true;
}

} // namespace ipc
} // namespace mozilla

Coverage Report

Created: 2018-09-25 14:53