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

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


#include "mozilla/ipc/PBackgroundChild.h"

#include "mozilla/dom/asmjscache/PAsmJSCacheEntryChild.h"
#include "mozilla/dom/indexedDB/PBackgroundIDBFactoryChild.h"
#include "mozilla/dom/indexedDB/PBackgroundIndexedDBUtilsChild.h"
#include "mozilla/dom/PBackgroundSDBConnectionChild.h"
#include "mozilla/dom/PBackgroundLocalStorageCacheChild.h"
#include "mozilla/dom/PBackgroundStorageChild.h"
#include "mozilla/ipc/PBackgroundTestChild.h"
#include "mozilla/dom/PBroadcastChannelChild.h"
#include "mozilla/dom/cache/PCacheChild.h"
#include "mozilla/dom/cache/PCacheStorageChild.h"
#include "mozilla/dom/cache/PCacheStreamControlChild.h"
#include "mozilla/dom/PClientManagerChild.h"
#include "mozilla/ipc/PFileDescriptorSetChild.h"
#include "mozilla/dom/PFileSystemRequestChild.h"
#include "mozilla/dom/PGamepadEventChannelChild.h"
#include "mozilla/dom/PGamepadTestChannelChild.h"
#include "mozilla/net/PHttpBackgroundChannelChild.h"
#include "mozilla/ipc/PIPCBlobInputStreamChild.h"
#include "mozilla/ipc/PPendingIPCBlobChild.h"
#include "mozilla/ipc/PTemporaryIPCBlobChild.h"
#include "mozilla/dom/PMessagePortChild.h"
#include "mozilla/camera/PCamerasChild.h"
#include "mozilla/dom/PMIDIManagerChild.h"
#include "mozilla/dom/PMIDIPortChild.h"
#include "mozilla/dom/quota/PQuotaChild.h"
#include "mozilla/ipc/PChildToParentStreamChild.h"
#include "mozilla/ipc/PParentToChildStreamChild.h"
#include "mozilla/dom/PServiceWorkerChild.h"
#include "mozilla/dom/PServiceWorkerContainerChild.h"
#include "mozilla/dom/PServiceWorkerManagerChild.h"
#include "mozilla/dom/PServiceWorkerRegistrationChild.h"
#include "mozilla/dom/PWebAuthnTransactionChild.h"
#include "mozilla/net/PUDPSocketChild.h"
#include "mozilla/layout/PVsyncChild.h"

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

namespace mozilla {
namespace ipc {


auto PBackgroundChild::RecvPCacheConstructor(PCacheChild* actor) -> mozilla::ipc::IPCResult
{
    return IPC_OK();
}

auto PBackgroundChild::RecvPCacheStreamControlConstructor(PCacheStreamControlChild* actor) -> mozilla::ipc::IPCResult
{
    return IPC_OK();
}

auto PBackgroundChild::RecvPParentToChildStreamConstructor(PParentToChildStreamChild* actor) -> mozilla::ipc::IPCResult
{
    return IPC_OK();
}

auto PBackgroundChild::RecvPPendingIPCBlobConstructor(
        PPendingIPCBlobChild* actor,
        const IPCBlob& blob) -> mozilla::ipc::IPCResult
{
    return IPC_OK();
}

auto PBackgroundChild::RecvPIPCBlobInputStreamConstructor(
        PIPCBlobInputStreamChild* actor,
        const nsID& aID,
        const uint64_t& aSize) -> mozilla::ipc::IPCResult
{
    return IPC_OK();
}

auto PBackgroundChild::RecvPFileDescriptorSetConstructor(
        PFileDescriptorSetChild* actor,
        const FileDescriptor& fd) -> mozilla::ipc::IPCResult
{
    return IPC_OK();
}

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

auto PBackgroundChild::ProcessingError(
        Result aCode,
        const char* aReason) -> void
{
}

auto PBackgroundChild::ShouldContinueFromReplyTimeout() -> bool
{
    return true;
}

auto PBackgroundChild::EnteredCxxStack() -> void
{
}

auto PBackgroundChild::ExitedCxxStack() -> void
{
}

auto PBackgroundChild::EnteredCall() -> void
{
}

auto PBackgroundChild::ExitedCall() -> void
{
}

MOZ_IMPLICIT PBackgroundChild::PBackgroundChild() :
    mozilla::ipc::IToplevelProtocol("PBackgroundChild", PBackgroundMsgStart, mozilla::ipc::ChildSide),
    mLivenessState(mozilla::ipc::LivenessState::Start)
{
    MOZ_COUNT_CTOR(PBackgroundChild);
}

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

auto PBackgroundChild::ManagedPAsmJSCacheEntryChild(nsTArray<PAsmJSCacheEntryChild*>& aArr) const -> void
{
    (mManagedPAsmJSCacheEntryChild).ToArray(aArr);
}

auto PBackgroundChild::ManagedPAsmJSCacheEntryChild() const -> const ManagedContainer<PAsmJSCacheEntryChild>&
{
    return mManagedPAsmJSCacheEntryChild;
}

auto PBackgroundChild::ManagedPBackgroundIDBFactoryChild(nsTArray<PBackgroundIDBFactoryChild*>& aArr) const -> void
{
    (mManagedPBackgroundIDBFactoryChild).ToArray(aArr);
}

auto PBackgroundChild::ManagedPBackgroundIDBFactoryChild() const -> const ManagedContainer<PBackgroundIDBFactoryChild>&
{
    return mManagedPBackgroundIDBFactoryChild;
}

auto PBackgroundChild::ManagedPBackgroundIndexedDBUtilsChild(nsTArray<PBackgroundIndexedDBUtilsChild*>& aArr) const -> void
{
    (mManagedPBackgroundIndexedDBUtilsChild).ToArray(aArr);
}

auto PBackgroundChild::ManagedPBackgroundIndexedDBUtilsChild() const -> const ManagedContainer<PBackgroundIndexedDBUtilsChild>&
{
    return mManagedPBackgroundIndexedDBUtilsChild;
}

auto PBackgroundChild::ManagedPBackgroundSDBConnectionChild(nsTArray<PBackgroundSDBConnectionChild*>& aArr) const -> void
{
    (mManagedPBackgroundSDBConnectionChild).ToArray(aArr);
}

auto PBackgroundChild::ManagedPBackgroundSDBConnectionChild() const -> const ManagedContainer<PBackgroundSDBConnectionChild>&
{
    return mManagedPBackgroundSDBConnectionChild;
}

auto PBackgroundChild::ManagedPBackgroundLocalStorageCacheChild(nsTArray<PBackgroundLocalStorageCacheChild*>& aArr) const -> void
{
    (mManagedPBackgroundLocalStorageCacheChild).ToArray(aArr);
}

auto PBackgroundChild::ManagedPBackgroundLocalStorageCacheChild() const -> const ManagedContainer<PBackgroundLocalStorageCacheChild>&
{
    return mManagedPBackgroundLocalStorageCacheChild;
}

auto PBackgroundChild::ManagedPBackgroundStorageChild(nsTArray<PBackgroundStorageChild*>& aArr) const -> void
{
    (mManagedPBackgroundStorageChild).ToArray(aArr);
}

auto PBackgroundChild::ManagedPBackgroundStorageChild() const -> const ManagedContainer<PBackgroundStorageChild>&
{
    return mManagedPBackgroundStorageChild;
}

auto PBackgroundChild::ManagedPBackgroundTestChild(nsTArray<PBackgroundTestChild*>& aArr) const -> void
{
    (mManagedPBackgroundTestChild).ToArray(aArr);
}

auto PBackgroundChild::ManagedPBackgroundTestChild() const -> const ManagedContainer<PBackgroundTestChild>&
{
    return mManagedPBackgroundTestChild;
}

auto PBackgroundChild::ManagedPBroadcastChannelChild(nsTArray<PBroadcastChannelChild*>& aArr) const -> void
{
    (mManagedPBroadcastChannelChild).ToArray(aArr);
}

auto PBackgroundChild::ManagedPBroadcastChannelChild() const -> const ManagedContainer<PBroadcastChannelChild>&
{
    return mManagedPBroadcastChannelChild;
}

auto PBackgroundChild::ManagedPCacheChild(nsTArray<PCacheChild*>& aArr) const -> void
{
    (mManagedPCacheChild).ToArray(aArr);
}

auto PBackgroundChild::ManagedPCacheChild() const -> const ManagedContainer<PCacheChild>&
{
    return mManagedPCacheChild;
}

auto PBackgroundChild::ManagedPCacheStorageChild(nsTArray<PCacheStorageChild*>& aArr) const -> void
{
    (mManagedPCacheStorageChild).ToArray(aArr);
}

auto PBackgroundChild::ManagedPCacheStorageChild() const -> const ManagedContainer<PCacheStorageChild>&
{
    return mManagedPCacheStorageChild;
}

auto PBackgroundChild::ManagedPCacheStreamControlChild(nsTArray<PCacheStreamControlChild*>& aArr) const -> void
{
    (mManagedPCacheStreamControlChild).ToArray(aArr);
}

auto PBackgroundChild::ManagedPCacheStreamControlChild() const -> const ManagedContainer<PCacheStreamControlChild>&
{
    return mManagedPCacheStreamControlChild;
}

auto PBackgroundChild::ManagedPClientManagerChild(nsTArray<PClientManagerChild*>& aArr) const -> void
{
    (mManagedPClientManagerChild).ToArray(aArr);
}

auto PBackgroundChild::ManagedPClientManagerChild() const -> const ManagedContainer<PClientManagerChild>&
{
    return mManagedPClientManagerChild;
}

auto PBackgroundChild::ManagedPFileDescriptorSetChild(nsTArray<PFileDescriptorSetChild*>& aArr) const -> void
{
    (mManagedPFileDescriptorSetChild).ToArray(aArr);
}

auto PBackgroundChild::ManagedPFileDescriptorSetChild() const -> const ManagedContainer<PFileDescriptorSetChild>&
{
    return mManagedPFileDescriptorSetChild;
}

auto PBackgroundChild::ManagedPFileSystemRequestChild(nsTArray<PFileSystemRequestChild*>& aArr) const -> void
{
    (mManagedPFileSystemRequestChild).ToArray(aArr);
}

auto PBackgroundChild::ManagedPFileSystemRequestChild() const -> const ManagedContainer<PFileSystemRequestChild>&
{
    return mManagedPFileSystemRequestChild;
}

auto PBackgroundChild::ManagedPGamepadEventChannelChild(nsTArray<PGamepadEventChannelChild*>& aArr) const -> void
{
    (mManagedPGamepadEventChannelChild).ToArray(aArr);
}

auto PBackgroundChild::ManagedPGamepadEventChannelChild() const -> const ManagedContainer<PGamepadEventChannelChild>&
{
    return mManagedPGamepadEventChannelChild;
}

auto PBackgroundChild::ManagedPGamepadTestChannelChild(nsTArray<PGamepadTestChannelChild*>& aArr) const -> void
{
    (mManagedPGamepadTestChannelChild).ToArray(aArr);
}

auto PBackgroundChild::ManagedPGamepadTestChannelChild() const -> const ManagedContainer<PGamepadTestChannelChild>&
{
    return mManagedPGamepadTestChannelChild;
}

auto PBackgroundChild::ManagedPHttpBackgroundChannelChild(nsTArray<PHttpBackgroundChannelChild*>& aArr) const -> void
{
    (mManagedPHttpBackgroundChannelChild).ToArray(aArr);
}

auto PBackgroundChild::ManagedPHttpBackgroundChannelChild() const -> const ManagedContainer<PHttpBackgroundChannelChild>&
{
    return mManagedPHttpBackgroundChannelChild;
}

auto PBackgroundChild::ManagedPIPCBlobInputStreamChild(nsTArray<PIPCBlobInputStreamChild*>& aArr) const -> void
{
    (mManagedPIPCBlobInputStreamChild).ToArray(aArr);
}

auto PBackgroundChild::ManagedPIPCBlobInputStreamChild() const -> const ManagedContainer<PIPCBlobInputStreamChild>&
{
    return mManagedPIPCBlobInputStreamChild;
}

auto PBackgroundChild::ManagedPPendingIPCBlobChild(nsTArray<PPendingIPCBlobChild*>& aArr) const -> void
{
    (mManagedPPendingIPCBlobChild).ToArray(aArr);
}

auto PBackgroundChild::ManagedPPendingIPCBlobChild() const -> const ManagedContainer<PPendingIPCBlobChild>&
{
    return mManagedPPendingIPCBlobChild;
}

auto PBackgroundChild::ManagedPTemporaryIPCBlobChild(nsTArray<PTemporaryIPCBlobChild*>& aArr) const -> void
{
    (mManagedPTemporaryIPCBlobChild).ToArray(aArr);
}

auto PBackgroundChild::ManagedPTemporaryIPCBlobChild() const -> const ManagedContainer<PTemporaryIPCBlobChild>&
{
    return mManagedPTemporaryIPCBlobChild;
}

auto PBackgroundChild::ManagedPMessagePortChild(nsTArray<PMessagePortChild*>& aArr) const -> void
{
    (mManagedPMessagePortChild).ToArray(aArr);
}

auto PBackgroundChild::ManagedPMessagePortChild() const -> const ManagedContainer<PMessagePortChild>&
{
    return mManagedPMessagePortChild;
}

auto PBackgroundChild::ManagedPCamerasChild(nsTArray<PCamerasChild*>& aArr) const -> void
{
    (mManagedPCamerasChild).ToArray(aArr);
}

auto PBackgroundChild::ManagedPCamerasChild() const -> const ManagedContainer<PCamerasChild>&
{
    return mManagedPCamerasChild;
}

auto PBackgroundChild::ManagedPMIDIManagerChild(nsTArray<PMIDIManagerChild*>& aArr) const -> void
{
    (mManagedPMIDIManagerChild).ToArray(aArr);
}

auto PBackgroundChild::ManagedPMIDIManagerChild() const -> const ManagedContainer<PMIDIManagerChild>&
{
    return mManagedPMIDIManagerChild;
}

auto PBackgroundChild::ManagedPMIDIPortChild(nsTArray<PMIDIPortChild*>& aArr) const -> void
{
    (mManagedPMIDIPortChild).ToArray(aArr);
}

auto PBackgroundChild::ManagedPMIDIPortChild() const -> const ManagedContainer<PMIDIPortChild>&
{
    return mManagedPMIDIPortChild;
}

auto PBackgroundChild::ManagedPQuotaChild(nsTArray<PQuotaChild*>& aArr) const -> void
{
    (mManagedPQuotaChild).ToArray(aArr);
}

auto PBackgroundChild::ManagedPQuotaChild() const -> const ManagedContainer<PQuotaChild>&
{
    return mManagedPQuotaChild;
}

auto PBackgroundChild::ManagedPChildToParentStreamChild(nsTArray<PChildToParentStreamChild*>& aArr) const -> void
{
    (mManagedPChildToParentStreamChild).ToArray(aArr);
}

auto PBackgroundChild::ManagedPChildToParentStreamChild() const -> const ManagedContainer<PChildToParentStreamChild>&
{
    return mManagedPChildToParentStreamChild;
}

auto PBackgroundChild::ManagedPParentToChildStreamChild(nsTArray<PParentToChildStreamChild*>& aArr) const -> void
{
    (mManagedPParentToChildStreamChild).ToArray(aArr);
}

auto PBackgroundChild::ManagedPParentToChildStreamChild() const -> const ManagedContainer<PParentToChildStreamChild>&
{
    return mManagedPParentToChildStreamChild;
}

auto PBackgroundChild::ManagedPServiceWorkerChild(nsTArray<PServiceWorkerChild*>& aArr) const -> void
{
    (mManagedPServiceWorkerChild).ToArray(aArr);
}

auto PBackgroundChild::ManagedPServiceWorkerChild() const -> const ManagedContainer<PServiceWorkerChild>&
{
    return mManagedPServiceWorkerChild;
}

auto PBackgroundChild::ManagedPServiceWorkerContainerChild(nsTArray<PServiceWorkerContainerChild*>& aArr) const -> void
{
    (mManagedPServiceWorkerContainerChild).ToArray(aArr);
}

auto PBackgroundChild::ManagedPServiceWorkerContainerChild() const -> const ManagedContainer<PServiceWorkerContainerChild>&
{
    return mManagedPServiceWorkerContainerChild;
}

auto PBackgroundChild::ManagedPServiceWorkerManagerChild(nsTArray<PServiceWorkerManagerChild*>& aArr) const -> void
{
    (mManagedPServiceWorkerManagerChild).ToArray(aArr);
}

auto PBackgroundChild::ManagedPServiceWorkerManagerChild() const -> const ManagedContainer<PServiceWorkerManagerChild>&
{
    return mManagedPServiceWorkerManagerChild;
}

auto PBackgroundChild::ManagedPServiceWorkerRegistrationChild(nsTArray<PServiceWorkerRegistrationChild*>& aArr) const -> void
{
    (mManagedPServiceWorkerRegistrationChild).ToArray(aArr);
}

auto PBackgroundChild::ManagedPServiceWorkerRegistrationChild() const -> const ManagedContainer<PServiceWorkerRegistrationChild>&
{
    return mManagedPServiceWorkerRegistrationChild;
}

auto PBackgroundChild::ManagedPWebAuthnTransactionChild(nsTArray<PWebAuthnTransactionChild*>& aArr) const -> void
{
    (mManagedPWebAuthnTransactionChild).ToArray(aArr);
}

auto PBackgroundChild::ManagedPWebAuthnTransactionChild() const -> const ManagedContainer<PWebAuthnTransactionChild>&
{
    return mManagedPWebAuthnTransactionChild;
}

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

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

auto PBackgroundChild::ManagedPVsyncChild(nsTArray<PVsyncChild*>& aArr) const -> void
{
    (mManagedPVsyncChild).ToArray(aArr);
}

auto PBackgroundChild::ManagedPVsyncChild() const -> const ManagedContainer<PVsyncChild>&
{
    return mManagedPVsyncChild;
}

auto PBackgroundChild::SendPBackgroundTestConstructor(const nsCString& testArg) -> PBackgroundTestChild*
{
    return SendPBackgroundTestConstructor(AllocPBackgroundTestChild(testArg), testArg);
}

auto PBackgroundChild::SendPBackgroundTestConstructor(
        PBackgroundTestChild* actor,
        const nsCString& testArg) -> PBackgroundTestChild*
{
    if ((!(actor))) {
        NS_WARNING("Error constructing actor PBackgroundTestChild");
        return nullptr;
    }
    (actor)->SetManagerAndRegister(this);
    (mManagedPBackgroundTestChild).PutEntry(actor);
    (actor)->mLivenessState = mozilla::ipc::LivenessState::Start;

    IPC::Message* msg__ = PBackground::Msg_PBackgroundTestConstructor(MSG_ROUTING_CONTROL);

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



    if (mozilla::ipc::LoggingEnabledFor("PBackgroundChild")) {
        mozilla::ipc::LogMessageForProtocol("PBackgroundChild", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PBackground::Msg_PBackgroundTestConstructor", 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 PBackgroundChild::SendPBackgroundIDBFactoryConstructor(const LoggingInfo& loggingInfo) -> PBackgroundIDBFactoryChild*
{
    return SendPBackgroundIDBFactoryConstructor(AllocPBackgroundIDBFactoryChild(loggingInfo), loggingInfo);
}

auto PBackgroundChild::SendPBackgroundIDBFactoryConstructor(
        PBackgroundIDBFactoryChild* actor,
        const LoggingInfo& loggingInfo) -> PBackgroundIDBFactoryChild*
{
    if ((!(actor))) {
        NS_WARNING("Error constructing actor PBackgroundIDBFactoryChild");
        return nullptr;
    }
    (actor)->SetManagerAndRegister(this);
    (mManagedPBackgroundIDBFactoryChild).PutEntry(actor);
    (actor)->mLivenessState = mozilla::ipc::LivenessState::Start;

    IPC::Message* msg__ = PBackground::Msg_PBackgroundIDBFactoryConstructor(MSG_ROUTING_CONTROL);

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



    if (mozilla::ipc::LoggingEnabledFor("PBackgroundChild")) {
        mozilla::ipc::LogMessageForProtocol("PBackgroundChild", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PBackground::Msg_PBackgroundIDBFactoryConstructor", 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 PBackgroundChild::SendPBackgroundIndexedDBUtilsConstructor() -> PBackgroundIndexedDBUtilsChild*
{
    return SendPBackgroundIndexedDBUtilsConstructor(AllocPBackgroundIndexedDBUtilsChild());
}

auto PBackgroundChild::SendPBackgroundIndexedDBUtilsConstructor(PBackgroundIndexedDBUtilsChild* actor) -> PBackgroundIndexedDBUtilsChild*
{
    if ((!(actor))) {
        NS_WARNING("Error constructing actor PBackgroundIndexedDBUtilsChild");
        return nullptr;
    }
    (actor)->SetManagerAndRegister(this);
    (mManagedPBackgroundIndexedDBUtilsChild).PutEntry(actor);
    (actor)->mLivenessState = mozilla::ipc::LivenessState::Start;

    IPC::Message* msg__ = PBackground::Msg_PBackgroundIndexedDBUtilsConstructor(MSG_ROUTING_CONTROL);

    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("PBackgroundChild")) {
        mozilla::ipc::LogMessageForProtocol("PBackgroundChild", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PBackground::Msg_PBackgroundIndexedDBUtilsConstructor", 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 PBackgroundChild::SendFlushPendingFileDeletions() -> bool
{
    IPC::Message* msg__ = PBackground::Msg_FlushPendingFileDeletions(MSG_ROUTING_CONTROL);





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

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

auto PBackgroundChild::SendPBackgroundSDBConnectionConstructor(const PrincipalInfo& principalInfo) -> PBackgroundSDBConnectionChild*
{
    return SendPBackgroundSDBConnectionConstructor(AllocPBackgroundSDBConnectionChild(principalInfo), principalInfo);
}

auto PBackgroundChild::SendPBackgroundSDBConnectionConstructor(
        PBackgroundSDBConnectionChild* actor,
        const PrincipalInfo& principalInfo) -> PBackgroundSDBConnectionChild*
{
    if ((!(actor))) {
        NS_WARNING("Error constructing actor PBackgroundSDBConnectionChild");
        return nullptr;
    }
    (actor)->SetManagerAndRegister(this);
    (mManagedPBackgroundSDBConnectionChild).PutEntry(actor);
    (actor)->mLivenessState = mozilla::ipc::LivenessState::Start;

    IPC::Message* msg__ = PBackground::Msg_PBackgroundSDBConnectionConstructor(MSG_ROUTING_CONTROL);

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



    if (mozilla::ipc::LoggingEnabledFor("PBackgroundChild")) {
        mozilla::ipc::LogMessageForProtocol("PBackgroundChild", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PBackground::Msg_PBackgroundSDBConnectionConstructor", 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 PBackgroundChild::SendPBackgroundLocalStorageCacheConstructor(
        const PrincipalInfo& principalInfo,
        const nsCString& originKey,
        const uint32_t& privateBrowsingId) -> PBackgroundLocalStorageCacheChild*
{
    return SendPBackgroundLocalStorageCacheConstructor(AllocPBackgroundLocalStorageCacheChild(principalInfo, originKey, privateBrowsingId), principalInfo, originKey, privateBrowsingId);
}

auto PBackgroundChild::SendPBackgroundLocalStorageCacheConstructor(
        PBackgroundLocalStorageCacheChild* actor,
        const PrincipalInfo& principalInfo,
        const nsCString& originKey,
        const uint32_t& privateBrowsingId) -> PBackgroundLocalStorageCacheChild*
{
    if ((!(actor))) {
        NS_WARNING("Error constructing actor PBackgroundLocalStorageCacheChild");
        return nullptr;
    }
    (actor)->SetManagerAndRegister(this);
    (mManagedPBackgroundLocalStorageCacheChild).PutEntry(actor);
    (actor)->mLivenessState = mozilla::ipc::LivenessState::Start;

    IPC::Message* msg__ = PBackground::Msg_PBackgroundLocalStorageCacheConstructor(MSG_ROUTING_CONTROL);

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



    if (mozilla::ipc::LoggingEnabledFor("PBackgroundChild")) {
        mozilla::ipc::LogMessageForProtocol("PBackgroundChild", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PBackground::Msg_PBackgroundLocalStorageCacheConstructor", 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 PBackgroundChild::SendPBackgroundStorageConstructor(const nsString& profilePath) -> PBackgroundStorageChild*
{
    return SendPBackgroundStorageConstructor(AllocPBackgroundStorageChild(profilePath), profilePath);
}

auto PBackgroundChild::SendPBackgroundStorageConstructor(
        PBackgroundStorageChild* actor,
        const nsString& profilePath) -> PBackgroundStorageChild*
{
    if ((!(actor))) {
        NS_WARNING("Error constructing actor PBackgroundStorageChild");
        return nullptr;
    }
    (actor)->SetManagerAndRegister(this);
    (mManagedPBackgroundStorageChild).PutEntry(actor);
    (actor)->mLivenessState = mozilla::ipc::LivenessState::Start;

    IPC::Message* msg__ = PBackground::Msg_PBackgroundStorageConstructor(MSG_ROUTING_CONTROL);

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



    if (mozilla::ipc::LoggingEnabledFor("PBackgroundChild")) {
        mozilla::ipc::LogMessageForProtocol("PBackgroundChild", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PBackground::Msg_PBackgroundStorageConstructor", 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 PBackgroundChild::SendPVsyncConstructor() -> PVsyncChild*
{
    return SendPVsyncConstructor(AllocPVsyncChild());
}

auto PBackgroundChild::SendPVsyncConstructor(PVsyncChild* actor) -> PVsyncChild*
{
    if ((!(actor))) {
        NS_WARNING("Error constructing actor PVsyncChild");
        return nullptr;
    }
    (actor)->SetManagerAndRegister(this);
    (mManagedPVsyncChild).PutEntry(actor);
    (actor)->mLivenessState = mozilla::ipc::LivenessState::Start;

    IPC::Message* msg__ = PBackground::Msg_PVsyncConstructor(MSG_ROUTING_CONTROL);

    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("PBackgroundChild")) {
        mozilla::ipc::LogMessageForProtocol("PBackgroundChild", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PBackground::Msg_PVsyncConstructor", 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 PBackgroundChild::SendPCamerasConstructor() -> PCamerasChild*
{
    return SendPCamerasConstructor(AllocPCamerasChild());
}

auto PBackgroundChild::SendPCamerasConstructor(PCamerasChild* actor) -> PCamerasChild*
{
    if ((!(actor))) {
        NS_WARNING("Error constructing actor PCamerasChild");
        return nullptr;
    }
    (actor)->SetManagerAndRegister(this);
    (mManagedPCamerasChild).PutEntry(actor);
    (actor)->mLivenessState = mozilla::ipc::LivenessState::Start;

    IPC::Message* msg__ = PBackground::Msg_PCamerasConstructor(MSG_ROUTING_CONTROL);

    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("PBackgroundChild")) {
        mozilla::ipc::LogMessageForProtocol("PBackgroundChild", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PBackground::Msg_PCamerasConstructor", 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 PBackgroundChild::SendPUDPSocketConstructor(
        const OptionalPrincipalInfo& pInfo,
        const nsCString& filter) -> PUDPSocketChild*
{
    return SendPUDPSocketConstructor(AllocPUDPSocketChild(pInfo, filter), pInfo, filter);
}

auto PBackgroundChild::SendPUDPSocketConstructor(
        PUDPSocketChild* actor,
        const OptionalPrincipalInfo& pInfo,
        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__ = PBackground::Msg_PUDPSocketConstructor(MSG_ROUTING_CONTROL);

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



    if (mozilla::ipc::LoggingEnabledFor("PBackgroundChild")) {
        mozilla::ipc::LogMessageForProtocol("PBackgroundChild", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PBackground::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 PBackgroundChild::SendPBroadcastChannelConstructor(
        const PrincipalInfo& pInfo,
        const nsCString& origin,
        const nsString& channel) -> PBroadcastChannelChild*
{
    return SendPBroadcastChannelConstructor(AllocPBroadcastChannelChild(pInfo, origin, channel), pInfo, origin, channel);
}

auto PBackgroundChild::SendPBroadcastChannelConstructor(
        PBroadcastChannelChild* actor,
        const PrincipalInfo& pInfo,
        const nsCString& origin,
        const nsString& channel) -> PBroadcastChannelChild*
{
    if ((!(actor))) {
        NS_WARNING("Error constructing actor PBroadcastChannelChild");
        return nullptr;
    }
    (actor)->SetManagerAndRegister(this);
    (mManagedPBroadcastChannelChild).PutEntry(actor);
    (actor)->mLivenessState = mozilla::ipc::LivenessState::Start;

    IPC::Message* msg__ = PBackground::Msg_PBroadcastChannelConstructor(MSG_ROUTING_CONTROL);

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



    if (mozilla::ipc::LoggingEnabledFor("PBackgroundChild")) {
        mozilla::ipc::LogMessageForProtocol("PBackgroundChild", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PBackground::Msg_PBroadcastChannelConstructor", 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 PBackgroundChild::SendPServiceWorkerManagerConstructor() -> PServiceWorkerManagerChild*
{
    return SendPServiceWorkerManagerConstructor(AllocPServiceWorkerManagerChild());
}

auto PBackgroundChild::SendPServiceWorkerManagerConstructor(PServiceWorkerManagerChild* actor) -> PServiceWorkerManagerChild*
{
    if ((!(actor))) {
        NS_WARNING("Error constructing actor PServiceWorkerManagerChild");
        return nullptr;
    }
    (actor)->SetManagerAndRegister(this);
    (mManagedPServiceWorkerManagerChild).PutEntry(actor);
    (actor)->mLivenessState = mozilla::ipc::LivenessState::Start;

    IPC::Message* msg__ = PBackground::Msg_PServiceWorkerManagerConstructor(MSG_ROUTING_CONTROL);

    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("PBackgroundChild")) {
        mozilla::ipc::LogMessageForProtocol("PBackgroundChild", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PBackground::Msg_PServiceWorkerManagerConstructor", 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 PBackgroundChild::SendShutdownServiceWorkerRegistrar() -> bool
{
    IPC::Message* msg__ = PBackground::Msg_ShutdownServiceWorkerRegistrar(MSG_ROUTING_CONTROL);





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

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

auto PBackgroundChild::SendPCacheStorageConstructor(
        const Namespace& aNamespace,
        const PrincipalInfo& aPrincipalInfo) -> PCacheStorageChild*
{
    return SendPCacheStorageConstructor(AllocPCacheStorageChild(aNamespace, aPrincipalInfo), aNamespace, aPrincipalInfo);
}

auto PBackgroundChild::SendPCacheStorageConstructor(
        PCacheStorageChild* actor,
        const Namespace& aNamespace,
        const PrincipalInfo& aPrincipalInfo) -> PCacheStorageChild*
{
    if ((!(actor))) {
        NS_WARNING("Error constructing actor PCacheStorageChild");
        return nullptr;
    }
    (actor)->SetManagerAndRegister(this);
    (mManagedPCacheStorageChild).PutEntry(actor);
    (actor)->mLivenessState = mozilla::ipc::LivenessState::Start;

    IPC::Message* msg__ = PBackground::Msg_PCacheStorageConstructor(MSG_ROUTING_CONTROL);

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



    if (mozilla::ipc::LoggingEnabledFor("PBackgroundChild")) {
        mozilla::ipc::LogMessageForProtocol("PBackgroundChild", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PBackground::Msg_PCacheStorageConstructor", 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 PBackgroundChild::SendPMessagePortConstructor(
        const nsID& uuid,
        const nsID& destinationUuid,
        const uint32_t& sequenceId) -> PMessagePortChild*
{
    return SendPMessagePortConstructor(AllocPMessagePortChild(uuid, destinationUuid, sequenceId), uuid, destinationUuid, sequenceId);
}

auto PBackgroundChild::SendPMessagePortConstructor(
        PMessagePortChild* actor,
        const nsID& uuid,
        const nsID& destinationUuid,
        const uint32_t& sequenceId) -> PMessagePortChild*
{
    if ((!(actor))) {
        NS_WARNING("Error constructing actor PMessagePortChild");
        return nullptr;
    }
    (actor)->SetManagerAndRegister(this);
    (mManagedPMessagePortChild).PutEntry(actor);
    (actor)->mLivenessState = mozilla::ipc::LivenessState::Start;

    IPC::Message* msg__ = PBackground::Msg_PMessagePortConstructor(MSG_ROUTING_CONTROL);

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



    if (mozilla::ipc::LoggingEnabledFor("PBackgroundChild")) {
        mozilla::ipc::LogMessageForProtocol("PBackgroundChild", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PBackground::Msg_PMessagePortConstructor", 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 PBackgroundChild::SendPChildToParentStreamConstructor() -> PChildToParentStreamChild*
{
    return SendPChildToParentStreamConstructor(AllocPChildToParentStreamChild());
}

auto PBackgroundChild::SendPChildToParentStreamConstructor(PChildToParentStreamChild* actor) -> PChildToParentStreamChild*
{
    if ((!(actor))) {
        NS_WARNING("Error constructing actor PChildToParentStreamChild");
        return nullptr;
    }
    (actor)->SetManagerAndRegister(this);
    (mManagedPChildToParentStreamChild).PutEntry(actor);
    (actor)->mLivenessState = mozilla::ipc::LivenessState::Start;

    IPC::Message* msg__ = PBackground::Msg_PChildToParentStreamConstructor(MSG_ROUTING_CONTROL);

    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("PBackgroundChild")) {
        mozilla::ipc::LogMessageForProtocol("PBackgroundChild", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PBackground::Msg_PChildToParentStreamConstructor", 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 PBackgroundChild::SendMessagePortForceClose(
        const nsID& uuid,
        const nsID& destinationUuid,
        const uint32_t& sequenceId) -> bool
{
    IPC::Message* msg__ = PBackground::Msg_MessagePortForceClose(MSG_ROUTING_CONTROL);

    WriteIPDLParam(msg__, this, uuid);
    // Sentinel = 'uuid'
    (msg__)->WriteSentinel(1982267941);
    WriteIPDLParam(msg__, this, destinationUuid);
    // Sentinel = 'destinationUuid'
    (msg__)->WriteSentinel(372087918);
    WriteIPDLParam(msg__, this, sequenceId);
    // Sentinel = 'sequenceId'
    (msg__)->WriteSentinel(2743535618);




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

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

auto PBackgroundChild::SendPAsmJSCacheEntryConstructor(
        const OpenMode& openMode,
        const WriteParams& write,
        const PrincipalInfo& principalInfo) -> PAsmJSCacheEntryChild*
{
    return SendPAsmJSCacheEntryConstructor(AllocPAsmJSCacheEntryChild(openMode, write, principalInfo), openMode, write, principalInfo);
}

auto PBackgroundChild::SendPAsmJSCacheEntryConstructor(
        PAsmJSCacheEntryChild* actor,
        const OpenMode& openMode,
        const WriteParams& write,
        const PrincipalInfo& principalInfo) -> PAsmJSCacheEntryChild*
{
    if ((!(actor))) {
        NS_WARNING("Error constructing actor PAsmJSCacheEntryChild");
        return nullptr;
    }
    (actor)->SetManagerAndRegister(this);
    (mManagedPAsmJSCacheEntryChild).PutEntry(actor);
    (actor)->mLivenessState = mozilla::ipc::LivenessState::Start;

    IPC::Message* msg__ = PBackground::Msg_PAsmJSCacheEntryConstructor(MSG_ROUTING_CONTROL);

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



    if (mozilla::ipc::LoggingEnabledFor("PBackgroundChild")) {
        mozilla::ipc::LogMessageForProtocol("PBackgroundChild", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PBackground::Msg_PAsmJSCacheEntryConstructor", 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 PBackgroundChild::SendPQuotaConstructor() -> PQuotaChild*
{
    return SendPQuotaConstructor(AllocPQuotaChild());
}

auto PBackgroundChild::SendPQuotaConstructor(PQuotaChild* actor) -> PQuotaChild*
{
    if ((!(actor))) {
        NS_WARNING("Error constructing actor PQuotaChild");
        return nullptr;
    }
    (actor)->SetManagerAndRegister(this);
    (mManagedPQuotaChild).PutEntry(actor);
    (actor)->mLivenessState = mozilla::ipc::LivenessState::Start;

    IPC::Message* msg__ = PBackground::Msg_PQuotaConstructor(MSG_ROUTING_CONTROL);

    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("PBackgroundChild")) {
        mozilla::ipc::LogMessageForProtocol("PBackgroundChild", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PBackground::Msg_PQuotaConstructor", 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 PBackgroundChild::SendPFileSystemRequestConstructor(const FileSystemParams& params) -> PFileSystemRequestChild*
{
    return SendPFileSystemRequestConstructor(AllocPFileSystemRequestChild(params), params);
}

auto PBackgroundChild::SendPFileSystemRequestConstructor(
        PFileSystemRequestChild* actor,
        const FileSystemParams& params) -> PFileSystemRequestChild*
{
    if ((!(actor))) {
        NS_WARNING("Error constructing actor PFileSystemRequestChild");
        return nullptr;
    }
    (actor)->SetManagerAndRegister(this);
    (mManagedPFileSystemRequestChild).PutEntry(actor);
    (actor)->mLivenessState = mozilla::ipc::LivenessState::Start;

    IPC::Message* msg__ = PBackground::Msg_PFileSystemRequestConstructor(MSG_ROUTING_CONTROL);

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



    if (mozilla::ipc::LoggingEnabledFor("PBackgroundChild")) {
        mozilla::ipc::LogMessageForProtocol("PBackgroundChild", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PBackground::Msg_PFileSystemRequestConstructor", 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 PBackgroundChild::SendPGamepadEventChannelConstructor() -> PGamepadEventChannelChild*
{
    return SendPGamepadEventChannelConstructor(AllocPGamepadEventChannelChild());
}

auto PBackgroundChild::SendPGamepadEventChannelConstructor(PGamepadEventChannelChild* actor) -> PGamepadEventChannelChild*
{
    if ((!(actor))) {
        NS_WARNING("Error constructing actor PGamepadEventChannelChild");
        return nullptr;
    }
    (actor)->SetManagerAndRegister(this);
    (mManagedPGamepadEventChannelChild).PutEntry(actor);
    (actor)->mLivenessState = mozilla::ipc::LivenessState::Start;

    IPC::Message* msg__ = PBackground::Msg_PGamepadEventChannelConstructor(MSG_ROUTING_CONTROL);

    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("PBackgroundChild")) {
        mozilla::ipc::LogMessageForProtocol("PBackgroundChild", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PBackground::Msg_PGamepadEventChannelConstructor", 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 PBackgroundChild::SendPGamepadTestChannelConstructor() -> PGamepadTestChannelChild*
{
    return SendPGamepadTestChannelConstructor(AllocPGamepadTestChannelChild());
}

auto PBackgroundChild::SendPGamepadTestChannelConstructor(PGamepadTestChannelChild* actor) -> PGamepadTestChannelChild*
{
    if ((!(actor))) {
        NS_WARNING("Error constructing actor PGamepadTestChannelChild");
        return nullptr;
    }
    (actor)->SetManagerAndRegister(this);
    (mManagedPGamepadTestChannelChild).PutEntry(actor);
    (actor)->mLivenessState = mozilla::ipc::LivenessState::Start;

    IPC::Message* msg__ = PBackground::Msg_PGamepadTestChannelConstructor(MSG_ROUTING_CONTROL);

    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("PBackgroundChild")) {
        mozilla::ipc::LogMessageForProtocol("PBackgroundChild", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PBackground::Msg_PGamepadTestChannelConstructor", 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 PBackgroundChild::SendPHttpBackgroundChannelConstructor(const uint64_t& channelId) -> PHttpBackgroundChannelChild*
{
    return SendPHttpBackgroundChannelConstructor(AllocPHttpBackgroundChannelChild(channelId), channelId);
}

auto PBackgroundChild::SendPHttpBackgroundChannelConstructor(
        PHttpBackgroundChannelChild* actor,
        const uint64_t& channelId) -> PHttpBackgroundChannelChild*
{
    if ((!(actor))) {
        NS_WARNING("Error constructing actor PHttpBackgroundChannelChild");
        return nullptr;
    }
    (actor)->SetManagerAndRegister(this);
    (mManagedPHttpBackgroundChannelChild).PutEntry(actor);
    (actor)->mLivenessState = mozilla::ipc::LivenessState::Start;

    IPC::Message* msg__ = PBackground::Msg_PHttpBackgroundChannelConstructor(MSG_ROUTING_CONTROL);

    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("PBackgroundChild")) {
        mozilla::ipc::LogMessageForProtocol("PBackgroundChild", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PBackground::Msg_PHttpBackgroundChannelConstructor", 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 PBackgroundChild::SendPWebAuthnTransactionConstructor() -> PWebAuthnTransactionChild*
{
    return SendPWebAuthnTransactionConstructor(AllocPWebAuthnTransactionChild());
}

auto PBackgroundChild::SendPWebAuthnTransactionConstructor(PWebAuthnTransactionChild* actor) -> PWebAuthnTransactionChild*
{
    if ((!(actor))) {
        NS_WARNING("Error constructing actor PWebAuthnTransactionChild");
        return nullptr;
    }
    (actor)->SetManagerAndRegister(this);
    (mManagedPWebAuthnTransactionChild).PutEntry(actor);
    (actor)->mLivenessState = mozilla::ipc::LivenessState::Start;

    IPC::Message* msg__ = PBackground::Msg_PWebAuthnTransactionConstructor(MSG_ROUTING_CONTROL);

    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("PBackgroundChild")) {
        mozilla::ipc::LogMessageForProtocol("PBackgroundChild", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PBackground::Msg_PWebAuthnTransactionConstructor", 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 PBackgroundChild::SendPTemporaryIPCBlobConstructor() -> PTemporaryIPCBlobChild*
{
    return SendPTemporaryIPCBlobConstructor(AllocPTemporaryIPCBlobChild());
}

auto PBackgroundChild::SendPTemporaryIPCBlobConstructor(PTemporaryIPCBlobChild* actor) -> PTemporaryIPCBlobChild*
{
    if ((!(actor))) {
        NS_WARNING("Error constructing actor PTemporaryIPCBlobChild");
        return nullptr;
    }
    (actor)->SetManagerAndRegister(this);
    (mManagedPTemporaryIPCBlobChild).PutEntry(actor);
    (actor)->mLivenessState = mozilla::ipc::LivenessState::Start;

    IPC::Message* msg__ = PBackground::Msg_PTemporaryIPCBlobConstructor(MSG_ROUTING_CONTROL);

    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("PBackgroundChild")) {
        mozilla::ipc::LogMessageForProtocol("PBackgroundChild", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PBackground::Msg_PTemporaryIPCBlobConstructor", 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 PBackgroundChild::SendPClientManagerConstructor() -> PClientManagerChild*
{
    return SendPClientManagerConstructor(AllocPClientManagerChild());
}

auto PBackgroundChild::SendPClientManagerConstructor(PClientManagerChild* actor) -> PClientManagerChild*
{
    if ((!(actor))) {
        NS_WARNING("Error constructing actor PClientManagerChild");
        return nullptr;
    }
    (actor)->SetManagerAndRegister(this);
    (mManagedPClientManagerChild).PutEntry(actor);
    (actor)->mLivenessState = mozilla::ipc::LivenessState::Start;

    IPC::Message* msg__ = PBackground::Msg_PClientManagerConstructor(MSG_ROUTING_CONTROL);

    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("PBackgroundChild")) {
        mozilla::ipc::LogMessageForProtocol("PBackgroundChild", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PBackground::Msg_PClientManagerConstructor", 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 PBackgroundChild::SendPMIDIManagerConstructor() -> PMIDIManagerChild*
{
    return SendPMIDIManagerConstructor(AllocPMIDIManagerChild());
}

auto PBackgroundChild::SendPMIDIManagerConstructor(PMIDIManagerChild* actor) -> PMIDIManagerChild*
{
    if ((!(actor))) {
        NS_WARNING("Error constructing actor PMIDIManagerChild");
        return nullptr;
    }
    (actor)->SetManagerAndRegister(this);
    (mManagedPMIDIManagerChild).PutEntry(actor);
    (actor)->mLivenessState = mozilla::ipc::LivenessState::Start;

    IPC::Message* msg__ = PBackground::Msg_PMIDIManagerConstructor(MSG_ROUTING_CONTROL);

    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("PBackgroundChild")) {
        mozilla::ipc::LogMessageForProtocol("PBackgroundChild", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PBackground::Msg_PMIDIManagerConstructor", 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 PBackgroundChild::SendPMIDIPortConstructor(
        const MIDIPortInfo& portInfo,
        const bool& sysexEnabled) -> PMIDIPortChild*
{
    return SendPMIDIPortConstructor(AllocPMIDIPortChild(portInfo, sysexEnabled), portInfo, sysexEnabled);
}

auto PBackgroundChild::SendPMIDIPortConstructor(
        PMIDIPortChild* actor,
        const MIDIPortInfo& portInfo,
        const bool& sysexEnabled) -> PMIDIPortChild*
{
    if ((!(actor))) {
        NS_WARNING("Error constructing actor PMIDIPortChild");
        return nullptr;
    }
    (actor)->SetManagerAndRegister(this);
    (mManagedPMIDIPortChild).PutEntry(actor);
    (actor)->mLivenessState = mozilla::ipc::LivenessState::Start;

    IPC::Message* msg__ = PBackground::Msg_PMIDIPortConstructor(MSG_ROUTING_CONTROL);

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



    if (mozilla::ipc::LoggingEnabledFor("PBackgroundChild")) {
        mozilla::ipc::LogMessageForProtocol("PBackgroundChild", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PBackground::Msg_PMIDIPortConstructor", 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 PBackgroundChild::SendStorageActivity(const PrincipalInfo& principalInfo) -> bool
{
    IPC::Message* msg__ = PBackground::Msg_StorageActivity(MSG_ROUTING_CONTROL);

    WriteIPDLParam(msg__, this, principalInfo);
    // Sentinel = 'principalInfo'
    (msg__)->WriteSentinel(3386633731);




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

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

auto PBackgroundChild::SendPServiceWorkerConstructor(const IPCServiceWorkerDescriptor& aDescriptor) -> PServiceWorkerChild*
{
    return SendPServiceWorkerConstructor(AllocPServiceWorkerChild(aDescriptor), aDescriptor);
}

auto PBackgroundChild::SendPServiceWorkerConstructor(
        PServiceWorkerChild* actor,
        const IPCServiceWorkerDescriptor& aDescriptor) -> PServiceWorkerChild*
{
    if ((!(actor))) {
        NS_WARNING("Error constructing actor PServiceWorkerChild");
        return nullptr;
    }
    (actor)->SetManagerAndRegister(this);
    (mManagedPServiceWorkerChild).PutEntry(actor);
    (actor)->mLivenessState = mozilla::ipc::LivenessState::Start;

    IPC::Message* msg__ = PBackground::Msg_PServiceWorkerConstructor(MSG_ROUTING_CONTROL);

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



    if (mozilla::ipc::LoggingEnabledFor("PBackgroundChild")) {
        mozilla::ipc::LogMessageForProtocol("PBackgroundChild", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PBackground::Msg_PServiceWorkerConstructor", 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 PBackgroundChild::SendPServiceWorkerContainerConstructor() -> PServiceWorkerContainerChild*
{
    return SendPServiceWorkerContainerConstructor(AllocPServiceWorkerContainerChild());
}

auto PBackgroundChild::SendPServiceWorkerContainerConstructor(PServiceWorkerContainerChild* actor) -> PServiceWorkerContainerChild*
{
    if ((!(actor))) {
        NS_WARNING("Error constructing actor PServiceWorkerContainerChild");
        return nullptr;
    }
    (actor)->SetManagerAndRegister(this);
    (mManagedPServiceWorkerContainerChild).PutEntry(actor);
    (actor)->mLivenessState = mozilla::ipc::LivenessState::Start;

    IPC::Message* msg__ = PBackground::Msg_PServiceWorkerContainerConstructor(MSG_ROUTING_CONTROL);

    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("PBackgroundChild")) {
        mozilla::ipc::LogMessageForProtocol("PBackgroundChild", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PBackground::Msg_PServiceWorkerContainerConstructor", 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 PBackgroundChild::SendPServiceWorkerRegistrationConstructor(const IPCServiceWorkerRegistrationDescriptor& aDescriptor) -> PServiceWorkerRegistrationChild*
{
    return SendPServiceWorkerRegistrationConstructor(AllocPServiceWorkerRegistrationChild(aDescriptor), aDescriptor);
}

auto PBackgroundChild::SendPServiceWorkerRegistrationConstructor(
        PServiceWorkerRegistrationChild* actor,
        const IPCServiceWorkerRegistrationDescriptor& aDescriptor) -> PServiceWorkerRegistrationChild*
{
    if ((!(actor))) {
        NS_WARNING("Error constructing actor PServiceWorkerRegistrationChild");
        return nullptr;
    }
    (actor)->SetManagerAndRegister(this);
    (mManagedPServiceWorkerRegistrationChild).PutEntry(actor);
    (actor)->mLivenessState = mozilla::ipc::LivenessState::Start;

    IPC::Message* msg__ = PBackground::Msg_PServiceWorkerRegistrationConstructor(MSG_ROUTING_CONTROL);

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



    if (mozilla::ipc::LoggingEnabledFor("PBackgroundChild")) {
        mozilla::ipc::LogMessageForProtocol("PBackgroundChild", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PBackground::Msg_PServiceWorkerRegistrationConstructor", 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 PBackgroundChild::SendPIPCBlobInputStreamConstructor(
        const nsID& aID,
        const uint64_t& aSize) -> PIPCBlobInputStreamChild*
{
    return SendPIPCBlobInputStreamConstructor(AllocPIPCBlobInputStreamChild(aID, aSize), aID, aSize);
}

auto PBackgroundChild::SendPIPCBlobInputStreamConstructor(
        PIPCBlobInputStreamChild* actor,
        const nsID& aID,
        const uint64_t& aSize) -> PIPCBlobInputStreamChild*
{
    if ((!(actor))) {
        NS_WARNING("Error constructing actor PIPCBlobInputStreamChild");
        return nullptr;
    }
    (actor)->SetManagerAndRegister(this);
    (mManagedPIPCBlobInputStreamChild).PutEntry(actor);
    (actor)->mLivenessState = mozilla::ipc::LivenessState::Start;

    IPC::Message* msg__ = PBackground::Msg_PIPCBlobInputStreamConstructor(MSG_ROUTING_CONTROL);

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



    if (mozilla::ipc::LoggingEnabledFor("PBackgroundChild")) {
        mozilla::ipc::LogMessageForProtocol("PBackgroundChild", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PBackground::Msg_PIPCBlobInputStreamConstructor", 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 PBackgroundChild::SendPFileDescriptorSetConstructor(const FileDescriptor& fd) -> PFileDescriptorSetChild*
{
    return SendPFileDescriptorSetConstructor(AllocPFileDescriptorSetChild(fd), fd);
}

auto PBackgroundChild::SendPFileDescriptorSetConstructor(
        PFileDescriptorSetChild* actor,
        const FileDescriptor& fd) -> PFileDescriptorSetChild*
{
    if ((!(actor))) {
        NS_WARNING("Error constructing actor PFileDescriptorSetChild");
        return nullptr;
    }
    (actor)->SetManagerAndRegister(this);
    (mManagedPFileDescriptorSetChild).PutEntry(actor);
    (actor)->mLivenessState = mozilla::ipc::LivenessState::Start;

    IPC::Message* msg__ = PBackground::Msg_PFileDescriptorSetConstructor(MSG_ROUTING_CONTROL);

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



    if (mozilla::ipc::LoggingEnabledFor("PBackgroundChild")) {
        mozilla::ipc::LogMessageForProtocol("PBackgroundChild", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PBackground::Msg_PFileDescriptorSetConstructor", 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 PBackgroundChild::RemoveManagee(
        int32_t aProtocolId,
        IProtocol* aListener) -> void
{
    switch (aProtocolId) {
    case PAsmJSCacheEntryMsgStart:
        {
            PAsmJSCacheEntryChild* actor = static_cast<PAsmJSCacheEntryChild*>(aListener);
            auto& container = mManagedPAsmJSCacheEntryChild;
            MOZ_RELEASE_ASSERT((container).Contains(actor), "actor not managed by this!");

            (container).RemoveEntry(actor);
            DeallocPAsmJSCacheEntryChild(actor);
            return;
        }
    case PBackgroundIDBFactoryMsgStart:
        {
            PBackgroundIDBFactoryChild* actor = static_cast<PBackgroundIDBFactoryChild*>(aListener);
            auto& container = mManagedPBackgroundIDBFactoryChild;
            MOZ_RELEASE_ASSERT((container).Contains(actor), "actor not managed by this!");

            (container).RemoveEntry(actor);
            DeallocPBackgroundIDBFactoryChild(actor);
            return;
        }
    case PBackgroundIndexedDBUtilsMsgStart:
        {
            PBackgroundIndexedDBUtilsChild* actor = static_cast<PBackgroundIndexedDBUtilsChild*>(aListener);
            auto& container = mManagedPBackgroundIndexedDBUtilsChild;
            MOZ_RELEASE_ASSERT((container).Contains(actor), "actor not managed by this!");

            (container).RemoveEntry(actor);
            DeallocPBackgroundIndexedDBUtilsChild(actor);
            return;
        }
    case PBackgroundSDBConnectionMsgStart:
        {
            PBackgroundSDBConnectionChild* actor = static_cast<PBackgroundSDBConnectionChild*>(aListener);
            auto& container = mManagedPBackgroundSDBConnectionChild;
            MOZ_RELEASE_ASSERT((container).Contains(actor), "actor not managed by this!");

            (container).RemoveEntry(actor);
            DeallocPBackgroundSDBConnectionChild(actor);
            return;
        }
    case PBackgroundLocalStorageCacheMsgStart:
        {
            PBackgroundLocalStorageCacheChild* actor = static_cast<PBackgroundLocalStorageCacheChild*>(aListener);
            auto& container = mManagedPBackgroundLocalStorageCacheChild;
            MOZ_RELEASE_ASSERT((container).Contains(actor), "actor not managed by this!");

            (container).RemoveEntry(actor);
            DeallocPBackgroundLocalStorageCacheChild(actor);
            return;
        }
    case PBackgroundStorageMsgStart:
        {
            PBackgroundStorageChild* actor = static_cast<PBackgroundStorageChild*>(aListener);
            auto& container = mManagedPBackgroundStorageChild;
            MOZ_RELEASE_ASSERT((container).Contains(actor), "actor not managed by this!");

            (container).RemoveEntry(actor);
            DeallocPBackgroundStorageChild(actor);
            return;
        }
    case PBackgroundTestMsgStart:
        {
            PBackgroundTestChild* actor = static_cast<PBackgroundTestChild*>(aListener);
            auto& container = mManagedPBackgroundTestChild;
            MOZ_RELEASE_ASSERT((container).Contains(actor), "actor not managed by this!");

            (container).RemoveEntry(actor);
            DeallocPBackgroundTestChild(actor);
            return;
        }
    case PBroadcastChannelMsgStart:
        {
            PBroadcastChannelChild* actor = static_cast<PBroadcastChannelChild*>(aListener);
            auto& container = mManagedPBroadcastChannelChild;
            MOZ_RELEASE_ASSERT((container).Contains(actor), "actor not managed by this!");

            (container).RemoveEntry(actor);
            DeallocPBroadcastChannelChild(actor);
            return;
        }
    case PCacheMsgStart:
        {
            PCacheChild* actor = static_cast<PCacheChild*>(aListener);
            auto& container = mManagedPCacheChild;
            MOZ_RELEASE_ASSERT((container).Contains(actor), "actor not managed by this!");

            (container).RemoveEntry(actor);
            DeallocPCacheChild(actor);
            return;
        }
    case PCacheStorageMsgStart:
        {
            PCacheStorageChild* actor = static_cast<PCacheStorageChild*>(aListener);
            auto& container = mManagedPCacheStorageChild;
            MOZ_RELEASE_ASSERT((container).Contains(actor), "actor not managed by this!");

            (container).RemoveEntry(actor);
            DeallocPCacheStorageChild(actor);
            return;
        }
    case PCacheStreamControlMsgStart:
        {
            PCacheStreamControlChild* actor = static_cast<PCacheStreamControlChild*>(aListener);
            auto& container = mManagedPCacheStreamControlChild;
            MOZ_RELEASE_ASSERT((container).Contains(actor), "actor not managed by this!");

            (container).RemoveEntry(actor);
            DeallocPCacheStreamControlChild(actor);
            return;
        }
    case PClientManagerMsgStart:
        {
            PClientManagerChild* actor = static_cast<PClientManagerChild*>(aListener);
            auto& container = mManagedPClientManagerChild;
            MOZ_RELEASE_ASSERT((container).Contains(actor), "actor not managed by this!");

            (container).RemoveEntry(actor);
            DeallocPClientManagerChild(actor);
            return;
        }
    case PFileDescriptorSetMsgStart:
        {
            PFileDescriptorSetChild* actor = static_cast<PFileDescriptorSetChild*>(aListener);
            auto& container = mManagedPFileDescriptorSetChild;
            MOZ_RELEASE_ASSERT((container).Contains(actor), "actor not managed by this!");

            (container).RemoveEntry(actor);
            DeallocPFileDescriptorSetChild(actor);
            return;
        }
    case PFileSystemRequestMsgStart:
        {
            PFileSystemRequestChild* actor = static_cast<PFileSystemRequestChild*>(aListener);
            auto& container = mManagedPFileSystemRequestChild;
            MOZ_RELEASE_ASSERT((container).Contains(actor), "actor not managed by this!");

            (container).RemoveEntry(actor);
            DeallocPFileSystemRequestChild(actor);
            return;
        }
    case PGamepadEventChannelMsgStart:
        {
            PGamepadEventChannelChild* actor = static_cast<PGamepadEventChannelChild*>(aListener);
            auto& container = mManagedPGamepadEventChannelChild;
            MOZ_RELEASE_ASSERT((container).Contains(actor), "actor not managed by this!");

            (container).RemoveEntry(actor);
            DeallocPGamepadEventChannelChild(actor);
            return;
        }
    case PGamepadTestChannelMsgStart:
        {
            PGamepadTestChannelChild* actor = static_cast<PGamepadTestChannelChild*>(aListener);
            auto& container = mManagedPGamepadTestChannelChild;
            MOZ_RELEASE_ASSERT((container).Contains(actor), "actor not managed by this!");

            (container).RemoveEntry(actor);
            DeallocPGamepadTestChannelChild(actor);
            return;
        }
    case PHttpBackgroundChannelMsgStart:
        {
            PHttpBackgroundChannelChild* actor = static_cast<PHttpBackgroundChannelChild*>(aListener);
            auto& container = mManagedPHttpBackgroundChannelChild;
            MOZ_RELEASE_ASSERT((container).Contains(actor), "actor not managed by this!");

            (container).RemoveEntry(actor);
            DeallocPHttpBackgroundChannelChild(actor);
            return;
        }
    case PIPCBlobInputStreamMsgStart:
        {
            PIPCBlobInputStreamChild* actor = static_cast<PIPCBlobInputStreamChild*>(aListener);
            auto& container = mManagedPIPCBlobInputStreamChild;
            MOZ_RELEASE_ASSERT((container).Contains(actor), "actor not managed by this!");

            (container).RemoveEntry(actor);
            DeallocPIPCBlobInputStreamChild(actor);
            return;
        }
    case PPendingIPCBlobMsgStart:
        {
            PPendingIPCBlobChild* actor = static_cast<PPendingIPCBlobChild*>(aListener);
            auto& container = mManagedPPendingIPCBlobChild;
            MOZ_RELEASE_ASSERT((container).Contains(actor), "actor not managed by this!");

            (container).RemoveEntry(actor);
            DeallocPPendingIPCBlobChild(actor);
            return;
        }
    case PTemporaryIPCBlobMsgStart:
        {
            PTemporaryIPCBlobChild* actor = static_cast<PTemporaryIPCBlobChild*>(aListener);
            auto& container = mManagedPTemporaryIPCBlobChild;
            MOZ_RELEASE_ASSERT((container).Contains(actor), "actor not managed by this!");

            (container).RemoveEntry(actor);
            DeallocPTemporaryIPCBlobChild(actor);
            return;
        }
    case PMessagePortMsgStart:
        {
            PMessagePortChild* actor = static_cast<PMessagePortChild*>(aListener);
            auto& container = mManagedPMessagePortChild;
            MOZ_RELEASE_ASSERT((container).Contains(actor), "actor not managed by this!");

            (container).RemoveEntry(actor);
            DeallocPMessagePortChild(actor);
            return;
        }
    case PCamerasMsgStart:
        {
            PCamerasChild* actor = static_cast<PCamerasChild*>(aListener);
            auto& container = mManagedPCamerasChild;
            MOZ_RELEASE_ASSERT((container).Contains(actor), "actor not managed by this!");

            (container).RemoveEntry(actor);
            DeallocPCamerasChild(actor);
            return;
        }
    case PMIDIManagerMsgStart:
        {
            PMIDIManagerChild* actor = static_cast<PMIDIManagerChild*>(aListener);
            auto& container = mManagedPMIDIManagerChild;
            MOZ_RELEASE_ASSERT((container).Contains(actor), "actor not managed by this!");

            (container).RemoveEntry(actor);
            DeallocPMIDIManagerChild(actor);
            return;
        }
    case PMIDIPortMsgStart:
        {
            PMIDIPortChild* actor = static_cast<PMIDIPortChild*>(aListener);
            auto& container = mManagedPMIDIPortChild;
            MOZ_RELEASE_ASSERT((container).Contains(actor), "actor not managed by this!");

            (container).RemoveEntry(actor);
            DeallocPMIDIPortChild(actor);
            return;
        }
    case PQuotaMsgStart:
        {
            PQuotaChild* actor = static_cast<PQuotaChild*>(aListener);
            auto& container = mManagedPQuotaChild;
            MOZ_RELEASE_ASSERT((container).Contains(actor), "actor not managed by this!");

            (container).RemoveEntry(actor);
            DeallocPQuotaChild(actor);
            return;
        }
    case PChildToParentStreamMsgStart:
        {
            PChildToParentStreamChild* actor = static_cast<PChildToParentStreamChild*>(aListener);
            auto& container = mManagedPChildToParentStreamChild;
            MOZ_RELEASE_ASSERT((container).Contains(actor), "actor not managed by this!");

            (container).RemoveEntry(actor);
            DeallocPChildToParentStreamChild(actor);
            return;
        }
    case PParentToChildStreamMsgStart:
        {
            PParentToChildStreamChild* actor = static_cast<PParentToChildStreamChild*>(aListener);
            auto& container = mManagedPParentToChildStreamChild;
            MOZ_RELEASE_ASSERT((container).Contains(actor), "actor not managed by this!");

            (container).RemoveEntry(actor);
            DeallocPParentToChildStreamChild(actor);
            return;
        }
    case PServiceWorkerMsgStart:
        {
            PServiceWorkerChild* actor = static_cast<PServiceWorkerChild*>(aListener);
            auto& container = mManagedPServiceWorkerChild;
            MOZ_RELEASE_ASSERT((container).Contains(actor), "actor not managed by this!");

            (container).RemoveEntry(actor);
            DeallocPServiceWorkerChild(actor);
            return;
        }
    case PServiceWorkerContainerMsgStart:
        {
            PServiceWorkerContainerChild* actor = static_cast<PServiceWorkerContainerChild*>(aListener);
            auto& container = mManagedPServiceWorkerContainerChild;
            MOZ_RELEASE_ASSERT((container).Contains(actor), "actor not managed by this!");

            (container).RemoveEntry(actor);
            DeallocPServiceWorkerContainerChild(actor);
            return;
        }
    case PServiceWorkerManagerMsgStart:
        {
            PServiceWorkerManagerChild* actor = static_cast<PServiceWorkerManagerChild*>(aListener);
            auto& container = mManagedPServiceWorkerManagerChild;
            MOZ_RELEASE_ASSERT((container).Contains(actor), "actor not managed by this!");

            (container).RemoveEntry(actor);
            DeallocPServiceWorkerManagerChild(actor);
            return;
        }
    case PServiceWorkerRegistrationMsgStart:
        {
            PServiceWorkerRegistrationChild* actor = static_cast<PServiceWorkerRegistrationChild*>(aListener);
            auto& container = mManagedPServiceWorkerRegistrationChild;
            MOZ_RELEASE_ASSERT((container).Contains(actor), "actor not managed by this!");

            (container).RemoveEntry(actor);
            DeallocPServiceWorkerRegistrationChild(actor);
            return;
        }
    case PWebAuthnTransactionMsgStart:
        {
            PWebAuthnTransactionChild* actor = static_cast<PWebAuthnTransactionChild*>(aListener);
            auto& container = mManagedPWebAuthnTransactionChild;
            MOZ_RELEASE_ASSERT((container).Contains(actor), "actor not managed by this!");

            (container).RemoveEntry(actor);
            DeallocPWebAuthnTransactionChild(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 PVsyncMsgStart:
        {
            PVsyncChild* actor = static_cast<PVsyncChild*>(aListener);
            auto& container = mManagedPVsyncChild;
            MOZ_RELEASE_ASSERT((container).Contains(actor), "actor not managed by this!");

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

auto PBackgroundChild::OnMessageReceived(const Message& msg__) -> PBackgroundChild::Result
{
    int32_t route__ = (msg__).routing_id();
    if ((MSG_ROUTING_CONTROL) != (route__)) {
        IProtocol* routed__ = Lookup(route__);
        if ((!(routed__))) {
            return MsgRouteError;
        }
        return (routed__)->OnMessageReceived(msg__);
    }

    switch ((msg__).type()) {
    case PBackground::Reply_PBackgroundTestConstructor__ID:
        {
            return MsgProcessed;
        }
    case PBackground::Reply_PBackgroundIDBFactoryConstructor__ID:
        {
            return MsgProcessed;
        }
    case PBackground::Reply_PBackgroundIndexedDBUtilsConstructor__ID:
        {
            return MsgProcessed;
        }
    case PBackground::Reply_PBackgroundSDBConnectionConstructor__ID:
        {
            return MsgProcessed;
        }
    case PBackground::Reply_PBackgroundLocalStorageCacheConstructor__ID:
        {
            return MsgProcessed;
        }
    case PBackground::Reply_PBackgroundStorageConstructor__ID:
        {
            return MsgProcessed;
        }
    case PBackground::Reply_PVsyncConstructor__ID:
        {
            return MsgProcessed;
        }
    case PBackground::Reply_PCamerasConstructor__ID:
        {
            return MsgProcessed;
        }
    case PBackground::Reply_PUDPSocketConstructor__ID:
        {
            return MsgProcessed;
        }
    case PBackground::Reply_PBroadcastChannelConstructor__ID:
        {
            return MsgProcessed;
        }
    case PBackground::Reply_PServiceWorkerManagerConstructor__ID:
        {
            return MsgProcessed;
        }
    case PBackground::Reply_PCacheStorageConstructor__ID:
        {
            return MsgProcessed;
        }
    case PBackground::Reply_PMessagePortConstructor__ID:
        {
            return MsgProcessed;
        }
    case PBackground::Reply_PChildToParentStreamConstructor__ID:
        {
            return MsgProcessed;
        }
    case PBackground::Reply_PAsmJSCacheEntryConstructor__ID:
        {
            return MsgProcessed;
        }
    case PBackground::Reply_PQuotaConstructor__ID:
        {
            return MsgProcessed;
        }
    case PBackground::Reply_PFileSystemRequestConstructor__ID:
        {
            return MsgProcessed;
        }
    case PBackground::Reply_PGamepadEventChannelConstructor__ID:
        {
            return MsgProcessed;
        }
    case PBackground::Reply_PGamepadTestChannelConstructor__ID:
        {
            return MsgProcessed;
        }
    case PBackground::Reply_PHttpBackgroundChannelConstructor__ID:
        {
            return MsgProcessed;
        }
    case PBackground::Reply_PWebAuthnTransactionConstructor__ID:
        {
            return MsgProcessed;
        }
    case PBackground::Reply_PTemporaryIPCBlobConstructor__ID:
        {
            return MsgProcessed;
        }
    case PBackground::Reply_PClientManagerConstructor__ID:
        {
            return MsgProcessed;
        }
    case PBackground::Reply_PMIDIManagerConstructor__ID:
        {
            return MsgProcessed;
        }
    case PBackground::Reply_PMIDIPortConstructor__ID:
        {
            return MsgProcessed;
        }
    case PBackground::Reply_PServiceWorkerConstructor__ID:
        {
            return MsgProcessed;
        }
    case PBackground::Reply_PServiceWorkerContainerConstructor__ID:
        {
            return MsgProcessed;
        }
    case PBackground::Reply_PServiceWorkerRegistrationConstructor__ID:
        {
            return MsgProcessed;
        }
    case PBackground::Msg_PCacheConstructor__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBackgroundChild")) {
                mozilla::ipc::LogMessageForProtocol("PBackgroundChild", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBackground::Msg_PCacheConstructor", OTHER);

            PickleIterator iter__(msg__);
            ActorHandle handle__;
            PCacheChild* 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 = AllocPCacheChild();
            if ((!(actor))) {
                NS_WARNING("Error constructing actor PCacheChild");
                return MsgValueError;
            }
            (actor)->SetManagerAndRegister(this, (handle__).mId);
            (mManagedPCacheChild).PutEntry(actor);
            (actor)->mLivenessState = mozilla::ipc::LivenessState::Start;

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

            return MsgProcessed;
        }
    case PBackground::Msg_PCacheStreamControlConstructor__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBackgroundChild")) {
                mozilla::ipc::LogMessageForProtocol("PBackgroundChild", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBackground::Msg_PCacheStreamControlConstructor", OTHER);

            PickleIterator iter__(msg__);
            ActorHandle handle__;
            PCacheStreamControlChild* 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 = AllocPCacheStreamControlChild();
            if ((!(actor))) {
                NS_WARNING("Error constructing actor PCacheStreamControlChild");
                return MsgValueError;
            }
            (actor)->SetManagerAndRegister(this, (handle__).mId);
            (mManagedPCacheStreamControlChild).PutEntry(actor);
            (actor)->mLivenessState = mozilla::ipc::LivenessState::Start;

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

            return MsgProcessed;
        }
    case PBackground::Msg_PParentToChildStreamConstructor__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBackgroundChild")) {
                mozilla::ipc::LogMessageForProtocol("PBackgroundChild", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBackground::Msg_PParentToChildStreamConstructor", OTHER);

            PickleIterator iter__(msg__);
            ActorHandle handle__;
            PParentToChildStreamChild* 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 = AllocPParentToChildStreamChild();
            if ((!(actor))) {
                NS_WARNING("Error constructing actor PParentToChildStreamChild");
                return MsgValueError;
            }
            (actor)->SetManagerAndRegister(this, (handle__).mId);
            (mManagedPParentToChildStreamChild).PutEntry(actor);
            (actor)->mLivenessState = mozilla::ipc::LivenessState::Start;

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

            return MsgProcessed;
        }
    case PBackground::Msg_PPendingIPCBlobConstructor__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBackgroundChild")) {
                mozilla::ipc::LogMessageForProtocol("PBackgroundChild", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBackground::Msg_PPendingIPCBlobConstructor", OTHER);

            PickleIterator iter__(msg__);
            ActorHandle handle__;
            PPendingIPCBlobChild* actor;
            IPCBlob blob;

            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, (&(blob)))))) {
                FatalError("Error deserializing 'IPCBlob'");
                return MsgValueError;
            }
            // Sentinel = 'blob'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 1963585077)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'IPCBlob'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            actor = AllocPPendingIPCBlobChild(blob);
            if ((!(actor))) {
                NS_WARNING("Error constructing actor PPendingIPCBlobChild");
                return MsgValueError;
            }
            (actor)->SetManagerAndRegister(this, (handle__).mId);
            (mManagedPPendingIPCBlobChild).PutEntry(actor);
            (actor)->mLivenessState = mozilla::ipc::LivenessState::Start;

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

            return MsgProcessed;
        }
    case PBackground::Reply_PIPCBlobInputStreamConstructor__ID:
        {
            return MsgProcessed;
        }
    case PBackground::Msg_PIPCBlobInputStreamConstructor__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBackgroundChild")) {
                mozilla::ipc::LogMessageForProtocol("PBackgroundChild", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBackground::Msg_PIPCBlobInputStreamConstructor", OTHER);

            PickleIterator iter__(msg__);
            ActorHandle handle__;
            PIPCBlobInputStreamChild* actor;
            nsID aID;
            uint64_t aSize;

            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, (&(aID)))))) {
                FatalError("Error deserializing 'nsID'");
                return MsgValueError;
            }
            // Sentinel = 'aID'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 2735041849)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsID'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aSize)))))) {
                FatalError("Error deserializing 'uint64_t'");
                return MsgValueError;
            }
            // Sentinel = 'aSize'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 2556665555)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            actor = AllocPIPCBlobInputStreamChild(aID, aSize);
            if ((!(actor))) {
                NS_WARNING("Error constructing actor PIPCBlobInputStreamChild");
                return MsgValueError;
            }
            (actor)->SetManagerAndRegister(this, (handle__).mId);
            (mManagedPIPCBlobInputStreamChild).PutEntry(actor);
            (actor)->mLivenessState = mozilla::ipc::LivenessState::Start;

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

            return MsgProcessed;
        }
    case PBackground::Reply_PFileDescriptorSetConstructor__ID:
        {
            return MsgProcessed;
        }
    case PBackground::Msg_PFileDescriptorSetConstructor__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBackgroundChild")) {
                mozilla::ipc::LogMessageForProtocol("PBackgroundChild", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBackground::Msg_PFileDescriptorSetConstructor", OTHER);

            PickleIterator iter__(msg__);
            ActorHandle handle__;
            PFileDescriptorSetChild* actor;
            FileDescriptor fd;

            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, (&(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());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            actor = AllocPFileDescriptorSetChild(fd);
            if ((!(actor))) {
                NS_WARNING("Error constructing actor PFileDescriptorSetChild");
                return MsgValueError;
            }
            (actor)->SetManagerAndRegister(this, (handle__).mId);
            (mManagedPFileDescriptorSetChild).PutEntry(actor);
            (actor)->mLivenessState = mozilla::ipc::LivenessState::Start;

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

            return MsgProcessed;
        }
    default:
        {
            return MsgNotKnown;
        }
    case SHMEM_CREATED_MESSAGE_TYPE:
        {
            if ((!(ShmemCreated(msg__)))) {
                return MsgPayloadError;
            }
            return MsgProcessed;
        }
    case SHMEM_DESTROYED_MESSAGE_TYPE:
        {
            if ((!(ShmemDestroyed(msg__)))) {
                return MsgPayloadError;
            }
            return MsgProcessed;
        }
    }
}

auto PBackgroundChild::OnMessageReceived(
        const Message& msg__,
        Message*& reply__) -> PBackgroundChild::Result
{
    int32_t route__ = (msg__).routing_id();
    if ((MSG_ROUTING_CONTROL) != (route__)) {
        IProtocol* routed__ = Lookup(route__);
        if ((!(routed__))) {
            return MsgRouteError;
        }
        return (routed__)->OnMessageReceived(msg__, reply__);
    }

    return MsgNotKnown;
}

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

auto PBackgroundChild::GetProtocolTypeId() -> int32_t
{
    return PBackgroundMsgStart;
}

auto PBackgroundChild::OnChannelClose() -> void
{
    DestroySubtree(NormalShutdown);
    DeallocSubtree();
    DeallocShmems();
    DeallocPBackgroundChild();
}

auto PBackgroundChild::OnChannelError() -> void
{
    DestroySubtree(AbnormalShutdown);
    DeallocSubtree();
    DeallocShmems();
    DeallocPBackgroundChild();
}

auto PBackgroundChild::DestroySubtree(ActorDestroyReason why) -> void
{
    ActorDestroyReason subtreewhy = (((why) == (Deletion)) || ((why) == (FailedConstructor)) ? AncestorDeletion : why);

    {
        // Recursively shutting down PAsmJSCacheEntry kids
        nsTArray<PAsmJSCacheEntryChild*> kids;
        // Accumulate kids into a stable structure to iterate over
        ManagedPAsmJSCacheEntryChild(kids);
        for (auto& kid : kids) {
            // Guarding against a child removing a sibling from the list during the iteration.
            if ((mManagedPAsmJSCacheEntryChild).Contains(kid)) {
                (kid)->DestroySubtree(subtreewhy);
            }
        }
    }
    {
        // Recursively shutting down PBackgroundIDBFactory kids
        nsTArray<PBackgroundIDBFactoryChild*> kids;
        // Accumulate kids into a stable structure to iterate over
        ManagedPBackgroundIDBFactoryChild(kids);
        for (auto& kid : kids) {
            // Guarding against a child removing a sibling from the list during the iteration.
            if ((mManagedPBackgroundIDBFactoryChild).Contains(kid)) {
                (kid)->DestroySubtree(subtreewhy);
            }
        }
    }
    {
        // Recursively shutting down PBackgroundIndexedDBUtils kids
        nsTArray<PBackgroundIndexedDBUtilsChild*> kids;
        // Accumulate kids into a stable structure to iterate over
        ManagedPBackgroundIndexedDBUtilsChild(kids);
        for (auto& kid : kids) {
            // Guarding against a child removing a sibling from the list during the iteration.
            if ((mManagedPBackgroundIndexedDBUtilsChild).Contains(kid)) {
                (kid)->DestroySubtree(subtreewhy);
            }
        }
    }
    {
        // Recursively shutting down PBackgroundSDBConnection kids
        nsTArray<PBackgroundSDBConnectionChild*> kids;
        // Accumulate kids into a stable structure to iterate over
        ManagedPBackgroundSDBConnectionChild(kids);
        for (auto& kid : kids) {
            // Guarding against a child removing a sibling from the list during the iteration.
            if ((mManagedPBackgroundSDBConnectionChild).Contains(kid)) {
                (kid)->DestroySubtree(subtreewhy);
            }
        }
    }
    {
        // Recursively shutting down PBackgroundLocalStorageCache kids
        nsTArray<PBackgroundLocalStorageCacheChild*> kids;
        // Accumulate kids into a stable structure to iterate over
        ManagedPBackgroundLocalStorageCacheChild(kids);
        for (auto& kid : kids) {
            // Guarding against a child removing a sibling from the list during the iteration.
            if ((mManagedPBackgroundLocalStorageCacheChild).Contains(kid)) {
                (kid)->DestroySubtree(subtreewhy);
            }
        }
    }
    {
        // Recursively shutting down PBackgroundStorage kids
        nsTArray<PBackgroundStorageChild*> kids;
        // Accumulate kids into a stable structure to iterate over
        ManagedPBackgroundStorageChild(kids);
        for (auto& kid : kids) {
            // Guarding against a child removing a sibling from the list during the iteration.
            if ((mManagedPBackgroundStorageChild).Contains(kid)) {
                (kid)->DestroySubtree(subtreewhy);
            }
        }
    }
    {
        // Recursively shutting down PBackgroundTest kids
        nsTArray<PBackgroundTestChild*> kids;
        // Accumulate kids into a stable structure to iterate over
        ManagedPBackgroundTestChild(kids);
        for (auto& kid : kids) {
            // Guarding against a child removing a sibling from the list during the iteration.
            if ((mManagedPBackgroundTestChild).Contains(kid)) {
                (kid)->DestroySubtree(subtreewhy);
            }
        }
    }
    {
        // Recursively shutting down PBroadcastChannel kids
        nsTArray<PBroadcastChannelChild*> kids;
        // Accumulate kids into a stable structure to iterate over
        ManagedPBroadcastChannelChild(kids);
        for (auto& kid : kids) {
            // Guarding against a child removing a sibling from the list during the iteration.
            if ((mManagedPBroadcastChannelChild).Contains(kid)) {
                (kid)->DestroySubtree(subtreewhy);
            }
        }
    }
    {
        // Recursively shutting down PCache kids
        nsTArray<PCacheChild*> kids;
        // Accumulate kids into a stable structure to iterate over
        ManagedPCacheChild(kids);
        for (auto& kid : kids) {
            // Guarding against a child removing a sibling from the list during the iteration.
            if ((mManagedPCacheChild).Contains(kid)) {
                (kid)->DestroySubtree(subtreewhy);
            }
        }
    }
    {
        // Recursively shutting down PCacheStorage kids
        nsTArray<PCacheStorageChild*> kids;
        // Accumulate kids into a stable structure to iterate over
        ManagedPCacheStorageChild(kids);
        for (auto& kid : kids) {
            // Guarding against a child removing a sibling from the list during the iteration.
            if ((mManagedPCacheStorageChild).Contains(kid)) {
                (kid)->DestroySubtree(subtreewhy);
            }
        }
    }
    {
        // Recursively shutting down PCacheStreamControl kids
        nsTArray<PCacheStreamControlChild*> kids;
        // Accumulate kids into a stable structure to iterate over
        ManagedPCacheStreamControlChild(kids);
        for (auto& kid : kids) {
            // Guarding against a child removing a sibling from the list during the iteration.
            if ((mManagedPCacheStreamControlChild).Contains(kid)) {
                (kid)->DestroySubtree(subtreewhy);
            }
        }
    }
    {
        // Recursively shutting down PClientManager kids
        nsTArray<PClientManagerChild*> kids;
        // Accumulate kids into a stable structure to iterate over
        ManagedPClientManagerChild(kids);
        for (auto& kid : kids) {
            // Guarding against a child removing a sibling from the list during the iteration.
            if ((mManagedPClientManagerChild).Contains(kid)) {
                (kid)->DestroySubtree(subtreewhy);
            }
        }
    }
    {
        // Recursively shutting down PFileDescriptorSet kids
        nsTArray<PFileDescriptorSetChild*> kids;
        // Accumulate kids into a stable structure to iterate over
        ManagedPFileDescriptorSetChild(kids);
        for (auto& kid : kids) {
            // Guarding against a child removing a sibling from the list during the iteration.
            if ((mManagedPFileDescriptorSetChild).Contains(kid)) {
                (kid)->DestroySubtree(subtreewhy);
            }
        }
    }
    {
        // Recursively shutting down PFileSystemRequest kids
        nsTArray<PFileSystemRequestChild*> kids;
        // Accumulate kids into a stable structure to iterate over
        ManagedPFileSystemRequestChild(kids);
        for (auto& kid : kids) {
            // Guarding against a child removing a sibling from the list during the iteration.
            if ((mManagedPFileSystemRequestChild).Contains(kid)) {
                (kid)->DestroySubtree(subtreewhy);
            }
        }
    }
    {
        // Recursively shutting down PGamepadEventChannel kids
        nsTArray<PGamepadEventChannelChild*> kids;
        // Accumulate kids into a stable structure to iterate over
        ManagedPGamepadEventChannelChild(kids);
        for (auto& kid : kids) {
            // Guarding against a child removing a sibling from the list during the iteration.
            if ((mManagedPGamepadEventChannelChild).Contains(kid)) {
                (kid)->DestroySubtree(subtreewhy);
            }
        }
    }
    {
        // Recursively shutting down PGamepadTestChannel kids
        nsTArray<PGamepadTestChannelChild*> kids;
        // Accumulate kids into a stable structure to iterate over
        ManagedPGamepadTestChannelChild(kids);
        for (auto& kid : kids) {
            // Guarding against a child removing a sibling from the list during the iteration.
            if ((mManagedPGamepadTestChannelChild).Contains(kid)) {
                (kid)->DestroySubtree(subtreewhy);
            }
        }
    }
    {
        // Recursively shutting down PHttpBackgroundChannel kids
        nsTArray<PHttpBackgroundChannelChild*> kids;
        // Accumulate kids into a stable structure to iterate over
        ManagedPHttpBackgroundChannelChild(kids);
        for (auto& kid : kids) {
            // Guarding against a child removing a sibling from the list during the iteration.
            if ((mManagedPHttpBackgroundChannelChild).Contains(kid)) {
                (kid)->DestroySubtree(subtreewhy);
            }
        }
    }
    {
        // Recursively shutting down PIPCBlobInputStream kids
        nsTArray<PIPCBlobInputStreamChild*> kids;
        // Accumulate kids into a stable structure to iterate over
        ManagedPIPCBlobInputStreamChild(kids);
        for (auto& kid : kids) {
            // Guarding against a child removing a sibling from the list during the iteration.
            if ((mManagedPIPCBlobInputStreamChild).Contains(kid)) {
                (kid)->DestroySubtree(subtreewhy);
            }
        }
    }
    {
        // Recursively shutting down PPendingIPCBlob kids
        nsTArray<PPendingIPCBlobChild*> kids;
        // Accumulate kids into a stable structure to iterate over
        ManagedPPendingIPCBlobChild(kids);
        for (auto& kid : kids) {
            // Guarding against a child removing a sibling from the list during the iteration.
            if ((mManagedPPendingIPCBlobChild).Contains(kid)) {
                (kid)->DestroySubtree(subtreewhy);
            }
        }
    }
    {
        // Recursively shutting down PTemporaryIPCBlob kids
        nsTArray<PTemporaryIPCBlobChild*> kids;
        // Accumulate kids into a stable structure to iterate over
        ManagedPTemporaryIPCBlobChild(kids);
        for (auto& kid : kids) {
            // Guarding against a child removing a sibling from the list during the iteration.
            if ((mManagedPTemporaryIPCBlobChild).Contains(kid)) {
                (kid)->DestroySubtree(subtreewhy);
            }
        }
    }
    {
        // Recursively shutting down PMessagePort kids
        nsTArray<PMessagePortChild*> kids;
        // Accumulate kids into a stable structure to iterate over
        ManagedPMessagePortChild(kids);
        for (auto& kid : kids) {
            // Guarding against a child removing a sibling from the list during the iteration.
            if ((mManagedPMessagePortChild).Contains(kid)) {
                (kid)->DestroySubtree(subtreewhy);
            }
        }
    }
    {
        // Recursively shutting down PCameras kids
        nsTArray<PCamerasChild*> kids;
        // Accumulate kids into a stable structure to iterate over
        ManagedPCamerasChild(kids);
        for (auto& kid : kids) {
            // Guarding against a child removing a sibling from the list during the iteration.
            if ((mManagedPCamerasChild).Contains(kid)) {
                (kid)->DestroySubtree(subtreewhy);
            }
        }
    }
    {
        // Recursively shutting down PMIDIManager kids
        nsTArray<PMIDIManagerChild*> kids;
        // Accumulate kids into a stable structure to iterate over
        ManagedPMIDIManagerChild(kids);
        for (auto& kid : kids) {
            // Guarding against a child removing a sibling from the list during the iteration.
            if ((mManagedPMIDIManagerChild).Contains(kid)) {
                (kid)->DestroySubtree(subtreewhy);
            }
        }
    }
    {
        // Recursively shutting down PMIDIPort kids
        nsTArray<PMIDIPortChild*> kids;
        // Accumulate kids into a stable structure to iterate over
        ManagedPMIDIPortChild(kids);
        for (auto& kid : kids) {
            // Guarding against a child removing a sibling from the list during the iteration.
            if ((mManagedPMIDIPortChild).Contains(kid)) {
                (kid)->DestroySubtree(subtreewhy);
            }
        }
    }
    {
        // Recursively shutting down PQuota kids
        nsTArray<PQuotaChild*> kids;
        // Accumulate kids into a stable structure to iterate over
        ManagedPQuotaChild(kids);
        for (auto& kid : kids) {
            // Guarding against a child removing a sibling from the list during the iteration.
            if ((mManagedPQuotaChild).Contains(kid)) {
                (kid)->DestroySubtree(subtreewhy);
            }
        }
    }
    {
        // Recursively shutting down PChildToParentStream kids
        nsTArray<PChildToParentStreamChild*> kids;
        // Accumulate kids into a stable structure to iterate over
        ManagedPChildToParentStreamChild(kids);
        for (auto& kid : kids) {
            // Guarding against a child removing a sibling from the list during the iteration.
            if ((mManagedPChildToParentStreamChild).Contains(kid)) {
                (kid)->DestroySubtree(subtreewhy);
            }
        }
    }
    {
        // Recursively shutting down PParentToChildStream kids
        nsTArray<PParentToChildStreamChild*> kids;
        // Accumulate kids into a stable structure to iterate over
        ManagedPParentToChildStreamChild(kids);
        for (auto& kid : kids) {
            // Guarding against a child removing a sibling from the list during the iteration.
            if ((mManagedPParentToChildStreamChild).Contains(kid)) {
                (kid)->DestroySubtree(subtreewhy);
            }
        }
    }
    {
        // Recursively shutting down PServiceWorker kids
        nsTArray<PServiceWorkerChild*> kids;
        // Accumulate kids into a stable structure to iterate over
        ManagedPServiceWorkerChild(kids);
        for (auto& kid : kids) {
            // Guarding against a child removing a sibling from the list during the iteration.
            if ((mManagedPServiceWorkerChild).Contains(kid)) {
                (kid)->DestroySubtree(subtreewhy);
            }
        }
    }
    {
        // Recursively shutting down PServiceWorkerContainer kids
        nsTArray<PServiceWorkerContainerChild*> kids;
        // Accumulate kids into a stable structure to iterate over
        ManagedPServiceWorkerContainerChild(kids);
        for (auto& kid : kids) {
            // Guarding against a child removing a sibling from the list during the iteration.
            if ((mManagedPServiceWorkerContainerChild).Contains(kid)) {
                (kid)->DestroySubtree(subtreewhy);
            }
        }
    }
    {
        // Recursively shutting down PServiceWorkerManager kids
        nsTArray<PServiceWorkerManagerChild*> kids;
        // Accumulate kids into a stable structure to iterate over
        ManagedPServiceWorkerManagerChild(kids);
        for (auto& kid : kids) {
            // Guarding against a child removing a sibling from the list during the iteration.
            if ((mManagedPServiceWorkerManagerChild).Contains(kid)) {
                (kid)->DestroySubtree(subtreewhy);
            }
        }
    }
    {
        // Recursively shutting down PServiceWorkerRegistration kids
        nsTArray<PServiceWorkerRegistrationChild*> kids;
        // Accumulate kids into a stable structure to iterate over
        ManagedPServiceWorkerRegistrationChild(kids);
        for (auto& kid : kids) {
            // Guarding against a child removing a sibling from the list during the iteration.
            if ((mManagedPServiceWorkerRegistrationChild).Contains(kid)) {
                (kid)->DestroySubtree(subtreewhy);
            }
        }
    }
    {
        // Recursively shutting down PWebAuthnTransaction kids
        nsTArray<PWebAuthnTransactionChild*> kids;
        // Accumulate kids into a stable structure to iterate over
        ManagedPWebAuthnTransactionChild(kids);
        for (auto& kid : kids) {
            // Guarding against a child removing a sibling from the list during the iteration.
            if ((mManagedPWebAuthnTransactionChild).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 PVsync kids
        nsTArray<PVsyncChild*> kids;
        // Accumulate kids into a stable structure to iterate over
        ManagedPVsyncChild(kids);
        for (auto& kid : kids) {
            // Guarding against a child removing a sibling from the list during the iteration.
            if ((mManagedPVsyncChild).Contains(kid)) {
                (kid)->DestroySubtree(subtreewhy);
            }
        }
    }

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

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

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

        for (auto iter = (mManagedPAsmJSCacheEntryChild).Iter(); (!((iter).Done())); (iter).Next()) {
            DeallocPAsmJSCacheEntryChild(((iter).Get())->GetKey());
        }
        (mManagedPAsmJSCacheEntryChild).Clear();
    }
    {
        // Recursively deleting PBackgroundIDBFactory kids
        for (auto iter = (mManagedPBackgroundIDBFactoryChild).Iter(); (!((iter).Done())); (iter).Next()) {
            (((iter).Get())->GetKey())->DeallocSubtree();
        }

        for (auto iter = (mManagedPBackgroundIDBFactoryChild).Iter(); (!((iter).Done())); (iter).Next()) {
            DeallocPBackgroundIDBFactoryChild(((iter).Get())->GetKey());
        }
        (mManagedPBackgroundIDBFactoryChild).Clear();
    }
    {
        // Recursively deleting PBackgroundIndexedDBUtils kids
        for (auto iter = (mManagedPBackgroundIndexedDBUtilsChild).Iter(); (!((iter).Done())); (iter).Next()) {
            (((iter).Get())->GetKey())->DeallocSubtree();
        }

        for (auto iter = (mManagedPBackgroundIndexedDBUtilsChild).Iter(); (!((iter).Done())); (iter).Next()) {
            DeallocPBackgroundIndexedDBUtilsChild(((iter).Get())->GetKey());
        }
        (mManagedPBackgroundIndexedDBUtilsChild).Clear();
    }
    {
        // Recursively deleting PBackgroundSDBConnection kids
        for (auto iter = (mManagedPBackgroundSDBConnectionChild).Iter(); (!((iter).Done())); (iter).Next()) {
            (((iter).Get())->GetKey())->DeallocSubtree();
        }

        for (auto iter = (mManagedPBackgroundSDBConnectionChild).Iter(); (!((iter).Done())); (iter).Next()) {
            DeallocPBackgroundSDBConnectionChild(((iter).Get())->GetKey());
        }
        (mManagedPBackgroundSDBConnectionChild).Clear();
    }
    {
        // Recursively deleting PBackgroundLocalStorageCache kids
        for (auto iter = (mManagedPBackgroundLocalStorageCacheChild).Iter(); (!((iter).Done())); (iter).Next()) {
            (((iter).Get())->GetKey())->DeallocSubtree();
        }

        for (auto iter = (mManagedPBackgroundLocalStorageCacheChild).Iter(); (!((iter).Done())); (iter).Next()) {
            DeallocPBackgroundLocalStorageCacheChild(((iter).Get())->GetKey());
        }
        (mManagedPBackgroundLocalStorageCacheChild).Clear();
    }
    {
        // Recursively deleting PBackgroundStorage kids
        for (auto iter = (mManagedPBackgroundStorageChild).Iter(); (!((iter).Done())); (iter).Next()) {
            (((iter).Get())->GetKey())->DeallocSubtree();
        }

        for (auto iter = (mManagedPBackgroundStorageChild).Iter(); (!((iter).Done())); (iter).Next()) {
            DeallocPBackgroundStorageChild(((iter).Get())->GetKey());
        }
        (mManagedPBackgroundStorageChild).Clear();
    }
    {
        // Recursively deleting PBackgroundTest kids
        for (auto iter = (mManagedPBackgroundTestChild).Iter(); (!((iter).Done())); (iter).Next()) {
            (((iter).Get())->GetKey())->DeallocSubtree();
        }

        for (auto iter = (mManagedPBackgroundTestChild).Iter(); (!((iter).Done())); (iter).Next()) {
            DeallocPBackgroundTestChild(((iter).Get())->GetKey());
        }
        (mManagedPBackgroundTestChild).Clear();
    }
    {
        // Recursively deleting PBroadcastChannel kids
        for (auto iter = (mManagedPBroadcastChannelChild).Iter(); (!((iter).Done())); (iter).Next()) {
            (((iter).Get())->GetKey())->DeallocSubtree();
        }

        for (auto iter = (mManagedPBroadcastChannelChild).Iter(); (!((iter).Done())); (iter).Next()) {
            DeallocPBroadcastChannelChild(((iter).Get())->GetKey());
        }
        (mManagedPBroadcastChannelChild).Clear();
    }
    {
        // Recursively deleting PCache kids
        for (auto iter = (mManagedPCacheChild).Iter(); (!((iter).Done())); (iter).Next()) {
            (((iter).Get())->GetKey())->DeallocSubtree();
        }

        for (auto iter = (mManagedPCacheChild).Iter(); (!((iter).Done())); (iter).Next()) {
            DeallocPCacheChild(((iter).Get())->GetKey());
        }
        (mManagedPCacheChild).Clear();
    }
    {
        // Recursively deleting PCacheStorage kids
        for (auto iter = (mManagedPCacheStorageChild).Iter(); (!((iter).Done())); (iter).Next()) {
            (((iter).Get())->GetKey())->DeallocSubtree();
        }

        for (auto iter = (mManagedPCacheStorageChild).Iter(); (!((iter).Done())); (iter).Next()) {
            DeallocPCacheStorageChild(((iter).Get())->GetKey());
        }
        (mManagedPCacheStorageChild).Clear();
    }
    {
        // Recursively deleting PCacheStreamControl kids
        for (auto iter = (mManagedPCacheStreamControlChild).Iter(); (!((iter).Done())); (iter).Next()) {
            (((iter).Get())->GetKey())->DeallocSubtree();
        }

        for (auto iter = (mManagedPCacheStreamControlChild).Iter(); (!((iter).Done())); (iter).Next()) {
            DeallocPCacheStreamControlChild(((iter).Get())->GetKey());
        }
        (mManagedPCacheStreamControlChild).Clear();
    }
    {
        // Recursively deleting PClientManager kids
        for (auto iter = (mManagedPClientManagerChild).Iter(); (!((iter).Done())); (iter).Next()) {
            (((iter).Get())->GetKey())->DeallocSubtree();
        }

        for (auto iter = (mManagedPClientManagerChild).Iter(); (!((iter).Done())); (iter).Next()) {
            DeallocPClientManagerChild(((iter).Get())->GetKey());
        }
        (mManagedPClientManagerChild).Clear();
    }
    {
        // Recursively deleting PFileDescriptorSet kids
        for (auto iter = (mManagedPFileDescriptorSetChild).Iter(); (!((iter).Done())); (iter).Next()) {
            (((iter).Get())->GetKey())->DeallocSubtree();
        }

        for (auto iter = (mManagedPFileDescriptorSetChild).Iter(); (!((iter).Done())); (iter).Next()) {
            DeallocPFileDescriptorSetChild(((iter).Get())->GetKey());
        }
        (mManagedPFileDescriptorSetChild).Clear();
    }
    {
        // Recursively deleting PFileSystemRequest kids
        for (auto iter = (mManagedPFileSystemRequestChild).Iter(); (!((iter).Done())); (iter).Next()) {
            (((iter).Get())->GetKey())->DeallocSubtree();
        }

        for (auto iter = (mManagedPFileSystemRequestChild).Iter(); (!((iter).Done())); (iter).Next()) {
            DeallocPFileSystemRequestChild(((iter).Get())->GetKey());
        }
        (mManagedPFileSystemRequestChild).Clear();
    }
    {
        // Recursively deleting PGamepadEventChannel kids
        for (auto iter = (mManagedPGamepadEventChannelChild).Iter(); (!((iter).Done())); (iter).Next()) {
            (((iter).Get())->GetKey())->DeallocSubtree();
        }

        for (auto iter = (mManagedPGamepadEventChannelChild).Iter(); (!((iter).Done())); (iter).Next()) {
            DeallocPGamepadEventChannelChild(((iter).Get())->GetKey());
        }
        (mManagedPGamepadEventChannelChild).Clear();
    }
    {
        // Recursively deleting PGamepadTestChannel kids
        for (auto iter = (mManagedPGamepadTestChannelChild).Iter(); (!((iter).Done())); (iter).Next()) {
            (((iter).Get())->GetKey())->DeallocSubtree();
        }

        for (auto iter = (mManagedPGamepadTestChannelChild).Iter(); (!((iter).Done())); (iter).Next()) {
            DeallocPGamepadTestChannelChild(((iter).Get())->GetKey());
        }
        (mManagedPGamepadTestChannelChild).Clear();
    }
    {
        // Recursively deleting PHttpBackgroundChannel kids
        for (auto iter = (mManagedPHttpBackgroundChannelChild).Iter(); (!((iter).Done())); (iter).Next()) {
            (((iter).Get())->GetKey())->DeallocSubtree();
        }

        for (auto iter = (mManagedPHttpBackgroundChannelChild).Iter(); (!((iter).Done())); (iter).Next()) {
            DeallocPHttpBackgroundChannelChild(((iter).Get())->GetKey());
        }
        (mManagedPHttpBackgroundChannelChild).Clear();
    }
    {
        // Recursively deleting PIPCBlobInputStream kids
        for (auto iter = (mManagedPIPCBlobInputStreamChild).Iter(); (!((iter).Done())); (iter).Next()) {
            (((iter).Get())->GetKey())->DeallocSubtree();
        }

        for (auto iter = (mManagedPIPCBlobInputStreamChild).Iter(); (!((iter).Done())); (iter).Next()) {
            DeallocPIPCBlobInputStreamChild(((iter).Get())->GetKey());
        }
        (mManagedPIPCBlobInputStreamChild).Clear();
    }
    {
        // Recursively deleting PPendingIPCBlob kids
        for (auto iter = (mManagedPPendingIPCBlobChild).Iter(); (!((iter).Done())); (iter).Next()) {
            (((iter).Get())->GetKey())->DeallocSubtree();
        }

        for (auto iter = (mManagedPPendingIPCBlobChild).Iter(); (!((iter).Done())); (iter).Next()) {
            DeallocPPendingIPCBlobChild(((iter).Get())->GetKey());
        }
        (mManagedPPendingIPCBlobChild).Clear();
    }
    {
        // Recursively deleting PTemporaryIPCBlob kids
        for (auto iter = (mManagedPTemporaryIPCBlobChild).Iter(); (!((iter).Done())); (iter).Next()) {
            (((iter).Get())->GetKey())->DeallocSubtree();
        }

        for (auto iter = (mManagedPTemporaryIPCBlobChild).Iter(); (!((iter).Done())); (iter).Next()) {
            DeallocPTemporaryIPCBlobChild(((iter).Get())->GetKey());
        }
        (mManagedPTemporaryIPCBlobChild).Clear();
    }
    {
        // Recursively deleting PMessagePort kids
        for (auto iter = (mManagedPMessagePortChild).Iter(); (!((iter).Done())); (iter).Next()) {
            (((iter).Get())->GetKey())->DeallocSubtree();
        }

        for (auto iter = (mManagedPMessagePortChild).Iter(); (!((iter).Done())); (iter).Next()) {
            DeallocPMessagePortChild(((iter).Get())->GetKey());
        }
        (mManagedPMessagePortChild).Clear();
    }
    {
        // Recursively deleting PCameras kids
        for (auto iter = (mManagedPCamerasChild).Iter(); (!((iter).Done())); (iter).Next()) {
            (((iter).Get())->GetKey())->DeallocSubtree();
        }

        for (auto iter = (mManagedPCamerasChild).Iter(); (!((iter).Done())); (iter).Next()) {
            DeallocPCamerasChild(((iter).Get())->GetKey());
        }
        (mManagedPCamerasChild).Clear();
    }
    {
        // Recursively deleting PMIDIManager kids
        for (auto iter = (mManagedPMIDIManagerChild).Iter(); (!((iter).Done())); (iter).Next()) {
            (((iter).Get())->GetKey())->DeallocSubtree();
        }

        for (auto iter = (mManagedPMIDIManagerChild).Iter(); (!((iter).Done())); (iter).Next()) {
            DeallocPMIDIManagerChild(((iter).Get())->GetKey());
        }
        (mManagedPMIDIManagerChild).Clear();
    }
    {
        // Recursively deleting PMIDIPort kids
        for (auto iter = (mManagedPMIDIPortChild).Iter(); (!((iter).Done())); (iter).Next()) {
            (((iter).Get())->GetKey())->DeallocSubtree();
        }

        for (auto iter = (mManagedPMIDIPortChild).Iter(); (!((iter).Done())); (iter).Next()) {
            DeallocPMIDIPortChild(((iter).Get())->GetKey());
        }
        (mManagedPMIDIPortChild).Clear();
    }
    {
        // Recursively deleting PQuota kids
        for (auto iter = (mManagedPQuotaChild).Iter(); (!((iter).Done())); (iter).Next()) {
            (((iter).Get())->GetKey())->DeallocSubtree();
        }

        for (auto iter = (mManagedPQuotaChild).Iter(); (!((iter).Done())); (iter).Next()) {
            DeallocPQuotaChild(((iter).Get())->GetKey());
        }
        (mManagedPQuotaChild).Clear();
    }
    {
        // Recursively deleting PChildToParentStream kids
        for (auto iter = (mManagedPChildToParentStreamChild).Iter(); (!((iter).Done())); (iter).Next()) {
            (((iter).Get())->GetKey())->DeallocSubtree();
        }

        for (auto iter = (mManagedPChildToParentStreamChild).Iter(); (!((iter).Done())); (iter).Next()) {
            DeallocPChildToParentStreamChild(((iter).Get())->GetKey());
        }
        (mManagedPChildToParentStreamChild).Clear();
    }
    {
        // Recursively deleting PParentToChildStream kids
        for (auto iter = (mManagedPParentToChildStreamChild).Iter(); (!((iter).Done())); (iter).Next()) {
            (((iter).Get())->GetKey())->DeallocSubtree();
        }

        for (auto iter = (mManagedPParentToChildStreamChild).Iter(); (!((iter).Done())); (iter).Next()) {
            DeallocPParentToChildStreamChild(((iter).Get())->GetKey());
        }
        (mManagedPParentToChildStreamChild).Clear();
    }
    {
        // Recursively deleting PServiceWorker kids
        for (auto iter = (mManagedPServiceWorkerChild).Iter(); (!((iter).Done())); (iter).Next()) {
            (((iter).Get())->GetKey())->DeallocSubtree();
        }

        for (auto iter = (mManagedPServiceWorkerChild).Iter(); (!((iter).Done())); (iter).Next()) {
            DeallocPServiceWorkerChild(((iter).Get())->GetKey());
        }
        (mManagedPServiceWorkerChild).Clear();
    }
    {
        // Recursively deleting PServiceWorkerContainer kids
        for (auto iter = (mManagedPServiceWorkerContainerChild).Iter(); (!((iter).Done())); (iter).Next()) {
            (((iter).Get())->GetKey())->DeallocSubtree();
        }

        for (auto iter = (mManagedPServiceWorkerContainerChild).Iter(); (!((iter).Done())); (iter).Next()) {
            DeallocPServiceWorkerContainerChild(((iter).Get())->GetKey());
        }
        (mManagedPServiceWorkerContainerChild).Clear();
    }
    {
        // Recursively deleting PServiceWorkerManager kids
        for (auto iter = (mManagedPServiceWorkerManagerChild).Iter(); (!((iter).Done())); (iter).Next()) {
            (((iter).Get())->GetKey())->DeallocSubtree();
        }

        for (auto iter = (mManagedPServiceWorkerManagerChild).Iter(); (!((iter).Done())); (iter).Next()) {
            DeallocPServiceWorkerManagerChild(((iter).Get())->GetKey());
        }
        (mManagedPServiceWorkerManagerChild).Clear();
    }
    {
        // Recursively deleting PServiceWorkerRegistration kids
        for (auto iter = (mManagedPServiceWorkerRegistrationChild).Iter(); (!((iter).Done())); (iter).Next()) {
            (((iter).Get())->GetKey())->DeallocSubtree();
        }

        for (auto iter = (mManagedPServiceWorkerRegistrationChild).Iter(); (!((iter).Done())); (iter).Next()) {
            DeallocPServiceWorkerRegistrationChild(((iter).Get())->GetKey());
        }
        (mManagedPServiceWorkerRegistrationChild).Clear();
    }
    {
        // Recursively deleting PWebAuthnTransaction kids
        for (auto iter = (mManagedPWebAuthnTransactionChild).Iter(); (!((iter).Done())); (iter).Next()) {
            (((iter).Get())->GetKey())->DeallocSubtree();
        }

        for (auto iter = (mManagedPWebAuthnTransactionChild).Iter(); (!((iter).Done())); (iter).Next()) {
            DeallocPWebAuthnTransactionChild(((iter).Get())->GetKey());
        }
        (mManagedPWebAuthnTransactionChild).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 PVsync kids
        for (auto iter = (mManagedPVsyncChild).Iter(); (!((iter).Done())); (iter).Next()) {
            (((iter).Get())->GetKey())->DeallocSubtree();
        }

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

auto PBackgroundChild::DeallocPBackgroundChild() -> void
{
}



} // namespace ipc
} // namespace mozilla
namespace mozilla {
namespace ipc {
auto IPDLParamTraits<mozilla::ipc::PBackgroundChild>::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::ipc::PBackgroundChild>::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, "PBackground", PBackgroundMsgStart);
    if ((actor).isNothing()) {
        return false;
    }

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

} // namespace ipc
} // namespace mozilla

Coverage Report

Created: 2018-09-25 14:53