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

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


#include "mozilla/ipc/PBackgroundParent.h"

#include "mozilla/dom/asmjscache/PAsmJSCacheEntryParent.h"
#include "mozilla/dom/indexedDB/PBackgroundIDBFactoryParent.h"
#include "mozilla/dom/indexedDB/PBackgroundIndexedDBUtilsParent.h"
#include "mozilla/dom/PBackgroundSDBConnectionParent.h"
#include "mozilla/dom/PBackgroundLocalStorageCacheParent.h"
#include "mozilla/dom/PBackgroundStorageParent.h"
#include "mozilla/ipc/PBackgroundTestParent.h"
#include "mozilla/dom/PBroadcastChannelParent.h"
#include "mozilla/dom/cache/PCacheParent.h"
#include "mozilla/dom/cache/PCacheStorageParent.h"
#include "mozilla/dom/cache/PCacheStreamControlParent.h"
#include "mozilla/dom/PClientManagerParent.h"
#include "mozilla/ipc/PFileDescriptorSetParent.h"
#include "mozilla/dom/PFileSystemRequestParent.h"
#include "mozilla/dom/PGamepadEventChannelParent.h"
#include "mozilla/dom/PGamepadTestChannelParent.h"
#include "mozilla/net/PHttpBackgroundChannelParent.h"
#include "mozilla/ipc/PIPCBlobInputStreamParent.h"
#include "mozilla/ipc/PPendingIPCBlobParent.h"
#include "mozilla/ipc/PTemporaryIPCBlobParent.h"
#include "mozilla/dom/PMessagePortParent.h"
#include "mozilla/camera/PCamerasParent.h"
#include "mozilla/dom/PMIDIManagerParent.h"
#include "mozilla/dom/PMIDIPortParent.h"
#include "mozilla/dom/quota/PQuotaParent.h"
#include "mozilla/ipc/PChildToParentStreamParent.h"
#include "mozilla/ipc/PParentToChildStreamParent.h"
#include "mozilla/dom/PServiceWorkerParent.h"
#include "mozilla/dom/PServiceWorkerContainerParent.h"
#include "mozilla/dom/PServiceWorkerManagerParent.h"
#include "mozilla/dom/PServiceWorkerRegistrationParent.h"
#include "mozilla/dom/PWebAuthnTransactionParent.h"
#include "mozilla/net/PUDPSocketParent.h"
#include "mozilla/layout/PVsyncParent.h"

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

namespace mozilla {
namespace ipc {


auto PBackgroundParent::RecvPBackgroundTestConstructor(
        PBackgroundTestParent* actor,
        const nsCString& testArg) -> mozilla::ipc::IPCResult
{
    return IPC_OK();
}

auto PBackgroundParent::RecvPBackgroundIDBFactoryConstructor(
        PBackgroundIDBFactoryParent* actor,
        const LoggingInfo& loggingInfo) -> mozilla::ipc::IPCResult
{
    return IPC_OK();
}

auto PBackgroundParent::RecvPBackgroundIndexedDBUtilsConstructor(PBackgroundIndexedDBUtilsParent* actor) -> mozilla::ipc::IPCResult
{
    return IPC_OK();
}

auto PBackgroundParent::RecvPBackgroundSDBConnectionConstructor(
        PBackgroundSDBConnectionParent* actor,
        const PrincipalInfo& principalInfo) -> mozilla::ipc::IPCResult
{
    return IPC_OK();
}

auto PBackgroundParent::RecvPBackgroundLocalStorageCacheConstructor(
        PBackgroundLocalStorageCacheParent* actor,
        const PrincipalInfo& principalInfo,
        const nsCString& originKey,
        const uint32_t& privateBrowsingId) -> mozilla::ipc::IPCResult
{
    return IPC_OK();
}

auto PBackgroundParent::RecvPBackgroundStorageConstructor(
        PBackgroundStorageParent* actor,
        const nsString& profilePath) -> mozilla::ipc::IPCResult
{
    return IPC_OK();
}

auto PBackgroundParent::RecvPVsyncConstructor(PVsyncParent* actor) -> mozilla::ipc::IPCResult
{
    return IPC_OK();
}

auto PBackgroundParent::RecvPCamerasConstructor(PCamerasParent* actor) -> mozilla::ipc::IPCResult
{
    return IPC_OK();
}

auto PBackgroundParent::RecvPUDPSocketConstructor(
        PUDPSocketParent* actor,
        const OptionalPrincipalInfo& pInfo,
        const nsCString& filter) -> mozilla::ipc::IPCResult
{
    return IPC_OK();
}

auto PBackgroundParent::RecvPBroadcastChannelConstructor(
        PBroadcastChannelParent* actor,
        const PrincipalInfo& pInfo,
        const nsCString& origin,
        const nsString& channel) -> mozilla::ipc::IPCResult
{
    return IPC_OK();
}

auto PBackgroundParent::RecvPServiceWorkerManagerConstructor(PServiceWorkerManagerParent* actor) -> mozilla::ipc::IPCResult
{
    return IPC_OK();
}

auto PBackgroundParent::RecvPCacheStorageConstructor(
        PCacheStorageParent* actor,
        const Namespace& aNamespace,
        const PrincipalInfo& aPrincipalInfo) -> mozilla::ipc::IPCResult
{
    return IPC_OK();
}

auto PBackgroundParent::RecvPMessagePortConstructor(
        PMessagePortParent* actor,
        const nsID& uuid,
        const nsID& destinationUuid,
        const uint32_t& sequenceId) -> mozilla::ipc::IPCResult
{
    return IPC_OK();
}

auto PBackgroundParent::RecvPChildToParentStreamConstructor(PChildToParentStreamParent* actor) -> mozilla::ipc::IPCResult
{
    return IPC_OK();
}

auto PBackgroundParent::RecvPAsmJSCacheEntryConstructor(
        PAsmJSCacheEntryParent* actor,
        const OpenMode& openMode,
        const WriteParams& write,
        const PrincipalInfo& principalInfo) -> mozilla::ipc::IPCResult
{
    return IPC_OK();
}

auto PBackgroundParent::RecvPQuotaConstructor(PQuotaParent* actor) -> mozilla::ipc::IPCResult
{
    return IPC_OK();
}

auto PBackgroundParent::RecvPFileSystemRequestConstructor(
        PFileSystemRequestParent* actor,
        const FileSystemParams& params) -> mozilla::ipc::IPCResult
{
    return IPC_OK();
}

auto PBackgroundParent::RecvPGamepadEventChannelConstructor(PGamepadEventChannelParent* actor) -> mozilla::ipc::IPCResult
{
    return IPC_OK();
}

auto PBackgroundParent::RecvPGamepadTestChannelConstructor(PGamepadTestChannelParent* actor) -> mozilla::ipc::IPCResult
{
    return IPC_OK();
}

auto PBackgroundParent::RecvPHttpBackgroundChannelConstructor(
        PHttpBackgroundChannelParent* actor,
        const uint64_t& channelId) -> mozilla::ipc::IPCResult
{
    return IPC_OK();
}

auto PBackgroundParent::RecvPWebAuthnTransactionConstructor(PWebAuthnTransactionParent* actor) -> mozilla::ipc::IPCResult
{
    return IPC_OK();
}

auto PBackgroundParent::RecvPTemporaryIPCBlobConstructor(PTemporaryIPCBlobParent* actor) -> mozilla::ipc::IPCResult
{
    return IPC_OK();
}

auto PBackgroundParent::RecvPClientManagerConstructor(PClientManagerParent* actor) -> mozilla::ipc::IPCResult
{
    return IPC_OK();
}

auto PBackgroundParent::RecvPMIDIManagerConstructor(PMIDIManagerParent* actor) -> mozilla::ipc::IPCResult
{
    return IPC_OK();
}

auto PBackgroundParent::RecvPMIDIPortConstructor(
        PMIDIPortParent* actor,
        const MIDIPortInfo& portInfo,
        const bool& sysexEnabled) -> mozilla::ipc::IPCResult
{
    return IPC_OK();
}

auto PBackgroundParent::RecvPServiceWorkerConstructor(
        PServiceWorkerParent* actor,
        const IPCServiceWorkerDescriptor& aDescriptor) -> mozilla::ipc::IPCResult
{
    return IPC_OK();
}

auto PBackgroundParent::RecvPServiceWorkerContainerConstructor(PServiceWorkerContainerParent* actor) -> mozilla::ipc::IPCResult
{
    return IPC_OK();
}

auto PBackgroundParent::RecvPServiceWorkerRegistrationConstructor(
        PServiceWorkerRegistrationParent* actor,
        const IPCServiceWorkerRegistrationDescriptor& aDescriptor) -> mozilla::ipc::IPCResult
{
    return IPC_OK();
}

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

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

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

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

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

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

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

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

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

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

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

auto PBackgroundParent::ManagedPAsmJSCacheEntryParent(nsTArray<PAsmJSCacheEntryParent*>& aArr) const -> void
{
    (mManagedPAsmJSCacheEntryParent).ToArray(aArr);
}

auto PBackgroundParent::ManagedPAsmJSCacheEntryParent() const -> const ManagedContainer<PAsmJSCacheEntryParent>&
{
    return mManagedPAsmJSCacheEntryParent;
}

auto PBackgroundParent::ManagedPBackgroundIDBFactoryParent(nsTArray<PBackgroundIDBFactoryParent*>& aArr) const -> void
{
    (mManagedPBackgroundIDBFactoryParent).ToArray(aArr);
}

auto PBackgroundParent::ManagedPBackgroundIDBFactoryParent() const -> const ManagedContainer<PBackgroundIDBFactoryParent>&
{
    return mManagedPBackgroundIDBFactoryParent;
}

auto PBackgroundParent::ManagedPBackgroundIndexedDBUtilsParent(nsTArray<PBackgroundIndexedDBUtilsParent*>& aArr) const -> void
{
    (mManagedPBackgroundIndexedDBUtilsParent).ToArray(aArr);
}

auto PBackgroundParent::ManagedPBackgroundIndexedDBUtilsParent() const -> const ManagedContainer<PBackgroundIndexedDBUtilsParent>&
{
    return mManagedPBackgroundIndexedDBUtilsParent;
}

auto PBackgroundParent::ManagedPBackgroundSDBConnectionParent(nsTArray<PBackgroundSDBConnectionParent*>& aArr) const -> void
{
    (mManagedPBackgroundSDBConnectionParent).ToArray(aArr);
}

auto PBackgroundParent::ManagedPBackgroundSDBConnectionParent() const -> const ManagedContainer<PBackgroundSDBConnectionParent>&
{
    return mManagedPBackgroundSDBConnectionParent;
}

auto PBackgroundParent::ManagedPBackgroundLocalStorageCacheParent(nsTArray<PBackgroundLocalStorageCacheParent*>& aArr) const -> void
{
    (mManagedPBackgroundLocalStorageCacheParent).ToArray(aArr);
}

auto PBackgroundParent::ManagedPBackgroundLocalStorageCacheParent() const -> const ManagedContainer<PBackgroundLocalStorageCacheParent>&
{
    return mManagedPBackgroundLocalStorageCacheParent;
}

auto PBackgroundParent::ManagedPBackgroundStorageParent(nsTArray<PBackgroundStorageParent*>& aArr) const -> void
{
    (mManagedPBackgroundStorageParent).ToArray(aArr);
}

auto PBackgroundParent::ManagedPBackgroundStorageParent() const -> const ManagedContainer<PBackgroundStorageParent>&
{
    return mManagedPBackgroundStorageParent;
}

auto PBackgroundParent::ManagedPBackgroundTestParent(nsTArray<PBackgroundTestParent*>& aArr) const -> void
{
    (mManagedPBackgroundTestParent).ToArray(aArr);
}

auto PBackgroundParent::ManagedPBackgroundTestParent() const -> const ManagedContainer<PBackgroundTestParent>&
{
    return mManagedPBackgroundTestParent;
}

auto PBackgroundParent::ManagedPBroadcastChannelParent(nsTArray<PBroadcastChannelParent*>& aArr) const -> void
{
    (mManagedPBroadcastChannelParent).ToArray(aArr);
}

auto PBackgroundParent::ManagedPBroadcastChannelParent() const -> const ManagedContainer<PBroadcastChannelParent>&
{
    return mManagedPBroadcastChannelParent;
}

auto PBackgroundParent::ManagedPCacheParent(nsTArray<PCacheParent*>& aArr) const -> void
{
    (mManagedPCacheParent).ToArray(aArr);
}

auto PBackgroundParent::ManagedPCacheParent() const -> const ManagedContainer<PCacheParent>&
{
    return mManagedPCacheParent;
}

auto PBackgroundParent::ManagedPCacheStorageParent(nsTArray<PCacheStorageParent*>& aArr) const -> void
{
    (mManagedPCacheStorageParent).ToArray(aArr);
}

auto PBackgroundParent::ManagedPCacheStorageParent() const -> const ManagedContainer<PCacheStorageParent>&
{
    return mManagedPCacheStorageParent;
}

auto PBackgroundParent::ManagedPCacheStreamControlParent(nsTArray<PCacheStreamControlParent*>& aArr) const -> void
{
    (mManagedPCacheStreamControlParent).ToArray(aArr);
}

auto PBackgroundParent::ManagedPCacheStreamControlParent() const -> const ManagedContainer<PCacheStreamControlParent>&
{
    return mManagedPCacheStreamControlParent;
}

auto PBackgroundParent::ManagedPClientManagerParent(nsTArray<PClientManagerParent*>& aArr) const -> void
{
    (mManagedPClientManagerParent).ToArray(aArr);
}

auto PBackgroundParent::ManagedPClientManagerParent() const -> const ManagedContainer<PClientManagerParent>&
{
    return mManagedPClientManagerParent;
}

auto PBackgroundParent::ManagedPFileDescriptorSetParent(nsTArray<PFileDescriptorSetParent*>& aArr) const -> void
{
    (mManagedPFileDescriptorSetParent).ToArray(aArr);
}

auto PBackgroundParent::ManagedPFileDescriptorSetParent() const -> const ManagedContainer<PFileDescriptorSetParent>&
{
    return mManagedPFileDescriptorSetParent;
}

auto PBackgroundParent::ManagedPFileSystemRequestParent(nsTArray<PFileSystemRequestParent*>& aArr) const -> void
{
    (mManagedPFileSystemRequestParent).ToArray(aArr);
}

auto PBackgroundParent::ManagedPFileSystemRequestParent() const -> const ManagedContainer<PFileSystemRequestParent>&
{
    return mManagedPFileSystemRequestParent;
}

auto PBackgroundParent::ManagedPGamepadEventChannelParent(nsTArray<PGamepadEventChannelParent*>& aArr) const -> void
{
    (mManagedPGamepadEventChannelParent).ToArray(aArr);
}

auto PBackgroundParent::ManagedPGamepadEventChannelParent() const -> const ManagedContainer<PGamepadEventChannelParent>&
{
    return mManagedPGamepadEventChannelParent;
}

auto PBackgroundParent::ManagedPGamepadTestChannelParent(nsTArray<PGamepadTestChannelParent*>& aArr) const -> void
{
    (mManagedPGamepadTestChannelParent).ToArray(aArr);
}

auto PBackgroundParent::ManagedPGamepadTestChannelParent() const -> const ManagedContainer<PGamepadTestChannelParent>&
{
    return mManagedPGamepadTestChannelParent;
}

auto PBackgroundParent::ManagedPHttpBackgroundChannelParent(nsTArray<PHttpBackgroundChannelParent*>& aArr) const -> void
{
    (mManagedPHttpBackgroundChannelParent).ToArray(aArr);
}

auto PBackgroundParent::ManagedPHttpBackgroundChannelParent() const -> const ManagedContainer<PHttpBackgroundChannelParent>&
{
    return mManagedPHttpBackgroundChannelParent;
}

auto PBackgroundParent::ManagedPIPCBlobInputStreamParent(nsTArray<PIPCBlobInputStreamParent*>& aArr) const -> void
{
    (mManagedPIPCBlobInputStreamParent).ToArray(aArr);
}

auto PBackgroundParent::ManagedPIPCBlobInputStreamParent() const -> const ManagedContainer<PIPCBlobInputStreamParent>&
{
    return mManagedPIPCBlobInputStreamParent;
}

auto PBackgroundParent::ManagedPPendingIPCBlobParent(nsTArray<PPendingIPCBlobParent*>& aArr) const -> void
{
    (mManagedPPendingIPCBlobParent).ToArray(aArr);
}

auto PBackgroundParent::ManagedPPendingIPCBlobParent() const -> const ManagedContainer<PPendingIPCBlobParent>&
{
    return mManagedPPendingIPCBlobParent;
}

auto PBackgroundParent::ManagedPTemporaryIPCBlobParent(nsTArray<PTemporaryIPCBlobParent*>& aArr) const -> void
{
    (mManagedPTemporaryIPCBlobParent).ToArray(aArr);
}

auto PBackgroundParent::ManagedPTemporaryIPCBlobParent() const -> const ManagedContainer<PTemporaryIPCBlobParent>&
{
    return mManagedPTemporaryIPCBlobParent;
}

auto PBackgroundParent::ManagedPMessagePortParent(nsTArray<PMessagePortParent*>& aArr) const -> void
{
    (mManagedPMessagePortParent).ToArray(aArr);
}

auto PBackgroundParent::ManagedPMessagePortParent() const -> const ManagedContainer<PMessagePortParent>&
{
    return mManagedPMessagePortParent;
}

auto PBackgroundParent::ManagedPCamerasParent(nsTArray<PCamerasParent*>& aArr) const -> void
{
    (mManagedPCamerasParent).ToArray(aArr);
}

auto PBackgroundParent::ManagedPCamerasParent() const -> const ManagedContainer<PCamerasParent>&
{
    return mManagedPCamerasParent;
}

auto PBackgroundParent::ManagedPMIDIManagerParent(nsTArray<PMIDIManagerParent*>& aArr) const -> void
{
    (mManagedPMIDIManagerParent).ToArray(aArr);
}

auto PBackgroundParent::ManagedPMIDIManagerParent() const -> const ManagedContainer<PMIDIManagerParent>&
{
    return mManagedPMIDIManagerParent;
}

auto PBackgroundParent::ManagedPMIDIPortParent(nsTArray<PMIDIPortParent*>& aArr) const -> void
{
    (mManagedPMIDIPortParent).ToArray(aArr);
}

auto PBackgroundParent::ManagedPMIDIPortParent() const -> const ManagedContainer<PMIDIPortParent>&
{
    return mManagedPMIDIPortParent;
}

auto PBackgroundParent::ManagedPQuotaParent(nsTArray<PQuotaParent*>& aArr) const -> void
{
    (mManagedPQuotaParent).ToArray(aArr);
}

auto PBackgroundParent::ManagedPQuotaParent() const -> const ManagedContainer<PQuotaParent>&
{
    return mManagedPQuotaParent;
}

auto PBackgroundParent::ManagedPChildToParentStreamParent(nsTArray<PChildToParentStreamParent*>& aArr) const -> void
{
    (mManagedPChildToParentStreamParent).ToArray(aArr);
}

auto PBackgroundParent::ManagedPChildToParentStreamParent() const -> const ManagedContainer<PChildToParentStreamParent>&
{
    return mManagedPChildToParentStreamParent;
}

auto PBackgroundParent::ManagedPParentToChildStreamParent(nsTArray<PParentToChildStreamParent*>& aArr) const -> void
{
    (mManagedPParentToChildStreamParent).ToArray(aArr);
}

auto PBackgroundParent::ManagedPParentToChildStreamParent() const -> const ManagedContainer<PParentToChildStreamParent>&
{
    return mManagedPParentToChildStreamParent;
}

auto PBackgroundParent::ManagedPServiceWorkerParent(nsTArray<PServiceWorkerParent*>& aArr) const -> void
{
    (mManagedPServiceWorkerParent).ToArray(aArr);
}

auto PBackgroundParent::ManagedPServiceWorkerParent() const -> const ManagedContainer<PServiceWorkerParent>&
{
    return mManagedPServiceWorkerParent;
}

auto PBackgroundParent::ManagedPServiceWorkerContainerParent(nsTArray<PServiceWorkerContainerParent*>& aArr) const -> void
{
    (mManagedPServiceWorkerContainerParent).ToArray(aArr);
}

auto PBackgroundParent::ManagedPServiceWorkerContainerParent() const -> const ManagedContainer<PServiceWorkerContainerParent>&
{
    return mManagedPServiceWorkerContainerParent;
}

auto PBackgroundParent::ManagedPServiceWorkerManagerParent(nsTArray<PServiceWorkerManagerParent*>& aArr) const -> void
{
    (mManagedPServiceWorkerManagerParent).ToArray(aArr);
}

auto PBackgroundParent::ManagedPServiceWorkerManagerParent() const -> const ManagedContainer<PServiceWorkerManagerParent>&
{
    return mManagedPServiceWorkerManagerParent;
}

auto PBackgroundParent::ManagedPServiceWorkerRegistrationParent(nsTArray<PServiceWorkerRegistrationParent*>& aArr) const -> void
{
    (mManagedPServiceWorkerRegistrationParent).ToArray(aArr);
}

auto PBackgroundParent::ManagedPServiceWorkerRegistrationParent() const -> const ManagedContainer<PServiceWorkerRegistrationParent>&
{
    return mManagedPServiceWorkerRegistrationParent;
}

auto PBackgroundParent::ManagedPWebAuthnTransactionParent(nsTArray<PWebAuthnTransactionParent*>& aArr) const -> void
{
    (mManagedPWebAuthnTransactionParent).ToArray(aArr);
}

auto PBackgroundParent::ManagedPWebAuthnTransactionParent() const -> const ManagedContainer<PWebAuthnTransactionParent>&
{
    return mManagedPWebAuthnTransactionParent;
}

auto PBackgroundParent::ManagedPUDPSocketParent(nsTArray<PUDPSocketParent*>& aArr) const -> void
{
    (mManagedPUDPSocketParent).ToArray(aArr);
}

auto PBackgroundParent::ManagedPUDPSocketParent() const -> const ManagedContainer<PUDPSocketParent>&
{
    return mManagedPUDPSocketParent;
}

auto PBackgroundParent::ManagedPVsyncParent(nsTArray<PVsyncParent*>& aArr) const -> void
{
    (mManagedPVsyncParent).ToArray(aArr);
}

auto PBackgroundParent::ManagedPVsyncParent() const -> const ManagedContainer<PVsyncParent>&
{
    return mManagedPVsyncParent;
}

auto PBackgroundParent::SendPCacheConstructor() -> PCacheParent*
{
    return SendPCacheConstructor(AllocPCacheParent());
}

auto PBackgroundParent::SendPCacheConstructor(PCacheParent* actor) -> PCacheParent*
{
    if ((!(actor))) {
        NS_WARNING("Error constructing actor PCacheParent");
        return nullptr;
    }
    (actor)->SetManagerAndRegister(this);
    (mManagedPCacheParent).PutEntry(actor);
    (actor)->mLivenessState = mozilla::ipc::LivenessState::Start;

    IPC::Message* msg__ = PBackground::Msg_PCacheConstructor(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("PBackgroundParent")) {
        mozilla::ipc::LogMessageForProtocol("PBackgroundParent", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PBackground::Msg_PCacheConstructor", OTHER);
    if ((!(StateTransition(false, (&(mLivenessState)))))) {
        mozilla::ipc::LogicError("Transition error");
    }

    bool sendok__ = (GetIPCChannel())->Send(msg__);
    if ((!(sendok__))) {
        IProtocol* mgr = (actor)->Manager();
        (actor)->DestroySubtree(FailedConstructor);
        (actor)->DeallocSubtree();
        (mgr)->RemoveManagee(PCacheMsgStart, actor);
        return nullptr;
    }
    return actor;
}

auto PBackgroundParent::SendPCacheStreamControlConstructor() -> PCacheStreamControlParent*
{
    return SendPCacheStreamControlConstructor(AllocPCacheStreamControlParent());
}

auto PBackgroundParent::SendPCacheStreamControlConstructor(PCacheStreamControlParent* actor) -> PCacheStreamControlParent*
{
    if ((!(actor))) {
        NS_WARNING("Error constructing actor PCacheStreamControlParent");
        return nullptr;
    }
    (actor)->SetManagerAndRegister(this);
    (mManagedPCacheStreamControlParent).PutEntry(actor);
    (actor)->mLivenessState = mozilla::ipc::LivenessState::Start;

    IPC::Message* msg__ = PBackground::Msg_PCacheStreamControlConstructor(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("PBackgroundParent")) {
        mozilla::ipc::LogMessageForProtocol("PBackgroundParent", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PBackground::Msg_PCacheStreamControlConstructor", OTHER);
    if ((!(StateTransition(false, (&(mLivenessState)))))) {
        mozilla::ipc::LogicError("Transition error");
    }

    bool sendok__ = (GetIPCChannel())->Send(msg__);
    if ((!(sendok__))) {
        IProtocol* mgr = (actor)->Manager();
        (actor)->DestroySubtree(FailedConstructor);
        (actor)->DeallocSubtree();
        (mgr)->RemoveManagee(PCacheStreamControlMsgStart, actor);
        return nullptr;
    }
    return actor;
}

auto PBackgroundParent::SendPParentToChildStreamConstructor() -> PParentToChildStreamParent*
{
    return SendPParentToChildStreamConstructor(AllocPParentToChildStreamParent());
}

auto PBackgroundParent::SendPParentToChildStreamConstructor(PParentToChildStreamParent* actor) -> PParentToChildStreamParent*
{
    if ((!(actor))) {
        NS_WARNING("Error constructing actor PParentToChildStreamParent");
        return nullptr;
    }
    (actor)->SetManagerAndRegister(this);
    (mManagedPParentToChildStreamParent).PutEntry(actor);
    (actor)->mLivenessState = mozilla::ipc::LivenessState::Start;

    IPC::Message* msg__ = PBackground::Msg_PParentToChildStreamConstructor(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("PBackgroundParent")) {
        mozilla::ipc::LogMessageForProtocol("PBackgroundParent", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PBackground::Msg_PParentToChildStreamConstructor", OTHER);
    if ((!(StateTransition(false, (&(mLivenessState)))))) {
        mozilla::ipc::LogicError("Transition error");
    }

    bool sendok__ = (GetIPCChannel())->Send(msg__);
    if ((!(sendok__))) {
        IProtocol* mgr = (actor)->Manager();
        (actor)->DestroySubtree(FailedConstructor);
        (actor)->DeallocSubtree();
        (mgr)->RemoveManagee(PParentToChildStreamMsgStart, actor);
        return nullptr;
    }
    return actor;
}

auto PBackgroundParent::SendPPendingIPCBlobConstructor(const IPCBlob& blob) -> PPendingIPCBlobParent*
{
    return SendPPendingIPCBlobConstructor(AllocPPendingIPCBlobParent(blob), blob);
}

auto PBackgroundParent::SendPPendingIPCBlobConstructor(
        PPendingIPCBlobParent* actor,
        const IPCBlob& blob) -> PPendingIPCBlobParent*
{
    if ((!(actor))) {
        NS_WARNING("Error constructing actor PPendingIPCBlobParent");
        return nullptr;
    }
    (actor)->SetManagerAndRegister(this);
    (mManagedPPendingIPCBlobParent).PutEntry(actor);
    (actor)->mLivenessState = mozilla::ipc::LivenessState::Start;

    IPC::Message* msg__ = PBackground::Msg_PPendingIPCBlobConstructor(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, blob);
    // Sentinel = 'blob'
    (msg__)->WriteSentinel(1963585077);



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

    bool sendok__ = (GetIPCChannel())->Send(msg__);
    if ((!(sendok__))) {
        IProtocol* mgr = (actor)->Manager();
        (actor)->DestroySubtree(FailedConstructor);
        (actor)->DeallocSubtree();
        (mgr)->RemoveManagee(PPendingIPCBlobMsgStart, actor);
        return nullptr;
    }
    return actor;
}

auto PBackgroundParent::SendPIPCBlobInputStreamConstructor(
        const nsID& aID,
        const uint64_t& aSize) -> PIPCBlobInputStreamParent*
{
    return SendPIPCBlobInputStreamConstructor(AllocPIPCBlobInputStreamParent(aID, aSize), aID, aSize);
}

auto PBackgroundParent::SendPIPCBlobInputStreamConstructor(
        PIPCBlobInputStreamParent* actor,
        const nsID& aID,
        const uint64_t& aSize) -> PIPCBlobInputStreamParent*
{
    if ((!(actor))) {
        NS_WARNING("Error constructing actor PIPCBlobInputStreamParent");
        return nullptr;
    }
    (actor)->SetManagerAndRegister(this);
    (mManagedPIPCBlobInputStreamParent).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("PBackgroundParent")) {
        mozilla::ipc::LogMessageForProtocol("PBackgroundParent", 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__))) {
        IProtocol* mgr = (actor)->Manager();
        (actor)->DestroySubtree(FailedConstructor);
        (actor)->DeallocSubtree();
        (mgr)->RemoveManagee(PIPCBlobInputStreamMsgStart, actor);
        return nullptr;
    }
    return actor;
}

auto PBackgroundParent::SendPFileDescriptorSetConstructor(const FileDescriptor& fd) -> PFileDescriptorSetParent*
{
    return SendPFileDescriptorSetConstructor(AllocPFileDescriptorSetParent(fd), fd);
}

auto PBackgroundParent::SendPFileDescriptorSetConstructor(
        PFileDescriptorSetParent* actor,
        const FileDescriptor& fd) -> PFileDescriptorSetParent*
{
    if ((!(actor))) {
        NS_WARNING("Error constructing actor PFileDescriptorSetParent");
        return nullptr;
    }
    (actor)->SetManagerAndRegister(this);
    (mManagedPFileDescriptorSetParent).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("PBackgroundParent")) {
        mozilla::ipc::LogMessageForProtocol("PBackgroundParent", 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__))) {
        IProtocol* mgr = (actor)->Manager();
        (actor)->DestroySubtree(FailedConstructor);
        (actor)->DeallocSubtree();
        (mgr)->RemoveManagee(PFileDescriptorSetMsgStart, actor);
        return nullptr;
    }
    return actor;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

            (container).RemoveEntry(actor);
            DeallocPUDPSocketParent(actor);
            return;
        }
    case PVsyncMsgStart:
        {
            PVsyncParent* actor = static_cast<PVsyncParent*>(aListener);
            auto& container = mManagedPVsyncParent;
            MOZ_RELEASE_ASSERT((container).Contains(actor), "actor not managed by this!");

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

auto PBackgroundParent::OnMessageReceived(const Message& msg__) -> PBackgroundParent::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::Msg_PBackgroundTestConstructor__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBackgroundParent")) {
                mozilla::ipc::LogMessageForProtocol("PBackgroundParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBackground::Msg_PBackgroundTestConstructor", OTHER);

            PickleIterator iter__(msg__);
            ActorHandle handle__;
            PBackgroundTestParent* actor;
            nsCString testArg;

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

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

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

            PickleIterator iter__(msg__);
            ActorHandle handle__;
            PBackgroundIDBFactoryParent* actor;
            LoggingInfo loggingInfo;

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

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

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

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

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

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

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

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

            PickleIterator iter__(msg__);
            ActorHandle handle__;
            PBackgroundSDBConnectionParent* actor;
            PrincipalInfo principalInfo;

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

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

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

            PickleIterator iter__(msg__);
            ActorHandle handle__;
            PBackgroundLocalStorageCacheParent* actor;
            PrincipalInfo principalInfo;
            nsCString originKey;
            uint32_t privateBrowsingId;

            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, (&(principalInfo)))))) {
                FatalError("Error deserializing 'PrincipalInfo'");
                return MsgValueError;
            }
            // Sentinel = 'principalInfo'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 3386633731)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'PrincipalInfo'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(originKey)))))) {
                FatalError("Error deserializing 'nsCString'");
                return MsgValueError;
            }
            // Sentinel = 'originKey'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 858621434)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsCString'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(privateBrowsingId)))))) {
                FatalError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            // Sentinel = 'privateBrowsingId'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 2950341020)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            actor = AllocPBackgroundLocalStorageCacheParent(principalInfo, originKey, privateBrowsingId);
            if ((!(actor))) {
                NS_WARNING("Error constructing actor PBackgroundLocalStorageCacheParent");
                return MsgValueError;
            }
            (actor)->SetManagerAndRegister(this, (handle__).mId);
            (mManagedPBackgroundLocalStorageCacheParent).PutEntry(actor);
            (actor)->mLivenessState = mozilla::ipc::LivenessState::Start;

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

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

            PickleIterator iter__(msg__);
            ActorHandle handle__;
            PBackgroundStorageParent* actor;
            nsString profilePath;

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

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

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

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

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

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

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

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

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

            PickleIterator iter__(msg__);
            ActorHandle handle__;
            PUDPSocketParent* actor;
            OptionalPrincipalInfo pInfo;
            nsCString filter;

            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, (&(pInfo)))))) {
                FatalError("Error deserializing 'OptionalPrincipalInfo'");
                return MsgValueError;
            }
            // Sentinel = 'pInfo'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 3256439729)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'OptionalPrincipalInfo'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(filter)))))) {
                FatalError("Error deserializing 'nsCString'");
                return MsgValueError;
            }
            // Sentinel = 'filter'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 2236769008)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsCString'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            actor = AllocPUDPSocketParent(pInfo, filter);
            if ((!(actor))) {
                NS_WARNING("Error constructing actor PUDPSocketParent");
                return MsgValueError;
            }
            (actor)->SetManagerAndRegister(this, (handle__).mId);
            (mManagedPUDPSocketParent).PutEntry(actor);
            (actor)->mLivenessState = mozilla::ipc::LivenessState::Start;

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

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

            PickleIterator iter__(msg__);
            ActorHandle handle__;
            PBroadcastChannelParent* actor;
            PrincipalInfo pInfo;
            nsCString origin;
            nsString channel;

            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, (&(pInfo)))))) {
                FatalError("Error deserializing 'PrincipalInfo'");
                return MsgValueError;
            }
            // Sentinel = 'pInfo'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 3256439729)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'PrincipalInfo'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(origin)))))) {
                FatalError("Error deserializing 'nsCString'");
                return MsgValueError;
            }
            // Sentinel = 'origin'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 1429924608)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsCString'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(channel)))))) {
                FatalError("Error deserializing 'nsString'");
                return MsgValueError;
            }
            // Sentinel = 'channel'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 452840382)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsString'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            actor = AllocPBroadcastChannelParent(pInfo, origin, channel);
            if ((!(actor))) {
                NS_WARNING("Error constructing actor PBroadcastChannelParent");
                return MsgValueError;
            }
            (actor)->SetManagerAndRegister(this, (handle__).mId);
            (mManagedPBroadcastChannelParent).PutEntry(actor);
            (actor)->mLivenessState = mozilla::ipc::LivenessState::Start;

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

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

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

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

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

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

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

            PickleIterator iter__(msg__);
            ActorHandle handle__;
            PCacheStorageParent* actor;
            Namespace aNamespace;
            PrincipalInfo aPrincipalInfo;

            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, (&(aNamespace)))))) {
                FatalError("Error deserializing 'Namespace'");
                return MsgValueError;
            }
            // Sentinel = 'aNamespace'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 1104189952)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'Namespace'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aPrincipalInfo)))))) {
                FatalError("Error deserializing 'PrincipalInfo'");
                return MsgValueError;
            }
            // Sentinel = 'aPrincipalInfo'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 2377045983)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'PrincipalInfo'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            actor = AllocPCacheStorageParent(aNamespace, aPrincipalInfo);
            if ((!(actor))) {
                NS_WARNING("Error constructing actor PCacheStorageParent");
                return MsgValueError;
            }
            (actor)->SetManagerAndRegister(this, (handle__).mId);
            (mManagedPCacheStorageParent).PutEntry(actor);
            (actor)->mLivenessState = mozilla::ipc::LivenessState::Start;

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

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

            PickleIterator iter__(msg__);
            ActorHandle handle__;
            PMessagePortParent* actor;
            nsID uuid;
            nsID destinationUuid;
            uint32_t sequenceId;

            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, (&(uuid)))))) {
                FatalError("Error deserializing 'nsID'");
                return MsgValueError;
            }
            // Sentinel = 'uuid'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 1982267941)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsID'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(destinationUuid)))))) {
                FatalError("Error deserializing 'nsID'");
                return MsgValueError;
            }
            // Sentinel = 'destinationUuid'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 372087918)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsID'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(sequenceId)))))) {
                FatalError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            // Sentinel = 'sequenceId'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 2743535618)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            actor = AllocPMessagePortParent(uuid, destinationUuid, sequenceId);
            if ((!(actor))) {
                NS_WARNING("Error constructing actor PMessagePortParent");
                return MsgValueError;
            }
            (actor)->SetManagerAndRegister(this, (handle__).mId);
            (mManagedPMessagePortParent).PutEntry(actor);
            (actor)->mLivenessState = mozilla::ipc::LivenessState::Start;

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

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

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

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

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

            PickleIterator iter__(msg__);
            nsID uuid;
            nsID destinationUuid;
            uint32_t sequenceId;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(uuid)))))) {
                FatalError("Error deserializing 'nsID'");
                return MsgValueError;
            }
            // Sentinel = 'uuid'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 1982267941)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsID'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(destinationUuid)))))) {
                FatalError("Error deserializing 'nsID'");
                return MsgValueError;
            }
            // Sentinel = 'destinationUuid'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 372087918)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsID'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(sequenceId)))))) {
                FatalError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            // Sentinel = 'sequenceId'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 2743535618)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            if ((!(RecvMessagePortForceClose(uuid, destinationUuid, sequenceId)))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

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

            PickleIterator iter__(msg__);
            ActorHandle handle__;
            PAsmJSCacheEntryParent* actor;
            OpenMode openMode;
            WriteParams write;
            PrincipalInfo principalInfo;

            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, (&(openMode)))))) {
                FatalError("Error deserializing 'OpenMode'");
                return MsgValueError;
            }
            // Sentinel = 'openMode'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 2477830497)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'OpenMode'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(write)))))) {
                FatalError("Error deserializing 'WriteParams'");
                return MsgValueError;
            }
            // Sentinel = 'write'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 1000843696)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'WriteParams'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(principalInfo)))))) {
                FatalError("Error deserializing 'PrincipalInfo'");
                return MsgValueError;
            }
            // Sentinel = 'principalInfo'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 3386633731)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'PrincipalInfo'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            actor = AllocPAsmJSCacheEntryParent(openMode, write, principalInfo);
            if ((!(actor))) {
                NS_WARNING("Error constructing actor PAsmJSCacheEntryParent");
                return MsgValueError;
            }
            (actor)->SetManagerAndRegister(this, (handle__).mId);
            (mManagedPAsmJSCacheEntryParent).PutEntry(actor);
            (actor)->mLivenessState = mozilla::ipc::LivenessState::Start;

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

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

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

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

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

            PickleIterator iter__(msg__);
            ActorHandle handle__;
            PFileSystemRequestParent* actor;
            FileSystemParams params;

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

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

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

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

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

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

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

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

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

            PickleIterator iter__(msg__);
            ActorHandle handle__;
            PHttpBackgroundChannelParent* actor;
            uint64_t channelId;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

            PickleIterator iter__(msg__);
            ActorHandle handle__;
            PMIDIPortParent* actor;
            MIDIPortInfo portInfo;
            bool sysexEnabled;

            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, (&(portInfo)))))) {
                FatalError("Error deserializing 'MIDIPortInfo'");
                return MsgValueError;
            }
            // Sentinel = 'portInfo'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 1908094141)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'MIDIPortInfo'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(sysexEnabled)))))) {
                FatalError("Error deserializing 'bool'");
                return MsgValueError;
            }
            // Sentinel = 'sysexEnabled'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 1954266107)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            actor = AllocPMIDIPortParent(portInfo, sysexEnabled);
            if ((!(actor))) {
                NS_WARNING("Error constructing actor PMIDIPortParent");
                return MsgValueError;
            }
            (actor)->SetManagerAndRegister(this, (handle__).mId);
            (mManagedPMIDIPortParent).PutEntry(actor);
            (actor)->mLivenessState = mozilla::ipc::LivenessState::Start;

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

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

            PickleIterator iter__(msg__);
            PrincipalInfo principalInfo;

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

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

            PickleIterator iter__(msg__);
            ActorHandle handle__;
            PServiceWorkerParent* actor;
            IPCServiceWorkerDescriptor aDescriptor;

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

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

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

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

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

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

            PickleIterator iter__(msg__);
            ActorHandle handle__;
            PServiceWorkerRegistrationParent* actor;
            IPCServiceWorkerRegistrationDescriptor aDescriptor;

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

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

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

            PickleIterator iter__(msg__);
            ActorHandle handle__;
            PIPCBlobInputStreamParent* 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 = AllocPIPCBlobInputStreamParent(aID, aSize);
            if ((!(actor))) {
                NS_WARNING("Error constructing actor PIPCBlobInputStreamParent");
                return MsgValueError;
            }
            (actor)->SetManagerAndRegister(this, (handle__).mId);
            (mManagedPIPCBlobInputStreamParent).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("PBackgroundParent")) {
                mozilla::ipc::LogMessageForProtocol("PBackgroundParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBackground::Msg_PFileDescriptorSetConstructor", OTHER);

            PickleIterator iter__(msg__);
            ActorHandle handle__;
            PFileDescriptorSetParent* 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 = AllocPFileDescriptorSetParent(fd);
            if ((!(actor))) {
                NS_WARNING("Error constructing actor PFileDescriptorSetParent");
                return MsgValueError;
            }
            (actor)->SetManagerAndRegister(this, (handle__).mId);
            (mManagedPFileDescriptorSetParent).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 PBackgroundParent::OnMessageReceived(
        const Message& msg__,
        Message*& reply__) -> PBackgroundParent::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 PBackgroundParent::OnCallReceived(
        const Message& msg__,
        Message*& reply__) -> PBackgroundParent::Result
{
    MOZ_ASSERT_UNREACHABLE("message protocol not supported");
    return MsgNotKnown;
}

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

auto PBackgroundParent::OnChannelClose() -> void
{
    DestroySubtree(NormalShutdown);
    DeallocSubtree();
    DeallocShmems();
    DeallocPBackgroundParent();
}

auto PBackgroundParent::OnChannelError() -> void
{
    DestroySubtree(AbnormalShutdown);
    DeallocSubtree();
    DeallocShmems();
    DeallocPBackgroundParent();
}

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

    {
        // Recursively shutting down PAsmJSCacheEntry kids
        nsTArray<PAsmJSCacheEntryParent*> kids;
        // Accumulate kids into a stable structure to iterate over
        ManagedPAsmJSCacheEntryParent(kids);
        for (auto& kid : kids) {
            // Guarding against a child removing a sibling from the list during the iteration.
            if ((mManagedPAsmJSCacheEntryParent).Contains(kid)) {
                (kid)->DestroySubtree(subtreewhy);
            }
        }
    }
    {
        // Recursively shutting down PBackgroundIDBFactory kids
        nsTArray<PBackgroundIDBFactoryParent*> kids;
        // Accumulate kids into a stable structure to iterate over
        ManagedPBackgroundIDBFactoryParent(kids);
        for (auto& kid : kids) {
            // Guarding against a child removing a sibling from the list during the iteration.
            if ((mManagedPBackgroundIDBFactoryParent).Contains(kid)) {
                (kid)->DestroySubtree(subtreewhy);
            }
        }
    }
    {
        // Recursively shutting down PBackgroundIndexedDBUtils kids
        nsTArray<PBackgroundIndexedDBUtilsParent*> kids;
        // Accumulate kids into a stable structure to iterate over
        ManagedPBackgroundIndexedDBUtilsParent(kids);
        for (auto& kid : kids) {
            // Guarding against a child removing a sibling from the list during the iteration.
            if ((mManagedPBackgroundIndexedDBUtilsParent).Contains(kid)) {
                (kid)->DestroySubtree(subtreewhy);
            }
        }
    }
    {
        // Recursively shutting down PBackgroundSDBConnection kids
        nsTArray<PBackgroundSDBConnectionParent*> kids;
        // Accumulate kids into a stable structure to iterate over
        ManagedPBackgroundSDBConnectionParent(kids);
        for (auto& kid : kids) {
            // Guarding against a child removing a sibling from the list during the iteration.
            if ((mManagedPBackgroundSDBConnectionParent).Contains(kid)) {
                (kid)->DestroySubtree(subtreewhy);
            }
        }
    }
    {
        // Recursively shutting down PBackgroundLocalStorageCache kids
        nsTArray<PBackgroundLocalStorageCacheParent*> kids;
        // Accumulate kids into a stable structure to iterate over
        ManagedPBackgroundLocalStorageCacheParent(kids);
        for (auto& kid : kids) {
            // Guarding against a child removing a sibling from the list during the iteration.
            if ((mManagedPBackgroundLocalStorageCacheParent).Contains(kid)) {
                (kid)->DestroySubtree(subtreewhy);
            }
        }
    }
    {
        // Recursively shutting down PBackgroundStorage kids
        nsTArray<PBackgroundStorageParent*> kids;
        // Accumulate kids into a stable structure to iterate over
        ManagedPBackgroundStorageParent(kids);
        for (auto& kid : kids) {
            // Guarding against a child removing a sibling from the list during the iteration.
            if ((mManagedPBackgroundStorageParent).Contains(kid)) {
                (kid)->DestroySubtree(subtreewhy);
            }
        }
    }
    {
        // Recursively shutting down PBackgroundTest kids
        nsTArray<PBackgroundTestParent*> kids;
        // Accumulate kids into a stable structure to iterate over
        ManagedPBackgroundTestParent(kids);
        for (auto& kid : kids) {
            // Guarding against a child removing a sibling from the list during the iteration.
            if ((mManagedPBackgroundTestParent).Contains(kid)) {
                (kid)->DestroySubtree(subtreewhy);
            }
        }
    }
    {
        // Recursively shutting down PBroadcastChannel kids
        nsTArray<PBroadcastChannelParent*> kids;
        // Accumulate kids into a stable structure to iterate over
        ManagedPBroadcastChannelParent(kids);
        for (auto& kid : kids) {
            // Guarding against a child removing a sibling from the list during the iteration.
            if ((mManagedPBroadcastChannelParent).Contains(kid)) {
                (kid)->DestroySubtree(subtreewhy);
            }
        }
    }
    {
        // Recursively shutting down PCache kids
        nsTArray<PCacheParent*> kids;
        // Accumulate kids into a stable structure to iterate over
        ManagedPCacheParent(kids);
        for (auto& kid : kids) {
            // Guarding against a child removing a sibling from the list during the iteration.
            if ((mManagedPCacheParent).Contains(kid)) {
                (kid)->DestroySubtree(subtreewhy);
            }
        }
    }
    {
        // Recursively shutting down PCacheStorage kids
        nsTArray<PCacheStorageParent*> kids;
        // Accumulate kids into a stable structure to iterate over
        ManagedPCacheStorageParent(kids);
        for (auto& kid : kids) {
            // Guarding against a child removing a sibling from the list during the iteration.
            if ((mManagedPCacheStorageParent).Contains(kid)) {
                (kid)->DestroySubtree(subtreewhy);
            }
        }
    }
    {
        // Recursively shutting down PCacheStreamControl kids
        nsTArray<PCacheStreamControlParent*> kids;
        // Accumulate kids into a stable structure to iterate over
        ManagedPCacheStreamControlParent(kids);
        for (auto& kid : kids) {
            // Guarding against a child removing a sibling from the list during the iteration.
            if ((mManagedPCacheStreamControlParent).Contains(kid)) {
                (kid)->DestroySubtree(subtreewhy);
            }
        }
    }
    {
        // Recursively shutting down PClientManager kids
        nsTArray<PClientManagerParent*> kids;
        // Accumulate kids into a stable structure to iterate over
        ManagedPClientManagerParent(kids);
        for (auto& kid : kids) {
            // Guarding against a child removing a sibling from the list during the iteration.
            if ((mManagedPClientManagerParent).Contains(kid)) {
                (kid)->DestroySubtree(subtreewhy);
            }
        }
    }
    {
        // Recursively shutting down PFileDescriptorSet kids
        nsTArray<PFileDescriptorSetParent*> kids;
        // Accumulate kids into a stable structure to iterate over
        ManagedPFileDescriptorSetParent(kids);
        for (auto& kid : kids) {
            // Guarding against a child removing a sibling from the list during the iteration.
            if ((mManagedPFileDescriptorSetParent).Contains(kid)) {
                (kid)->DestroySubtree(subtreewhy);
            }
        }
    }
    {
        // Recursively shutting down PFileSystemRequest kids
        nsTArray<PFileSystemRequestParent*> kids;
        // Accumulate kids into a stable structure to iterate over
        ManagedPFileSystemRequestParent(kids);
        for (auto& kid : kids) {
            // Guarding against a child removing a sibling from the list during the iteration.
            if ((mManagedPFileSystemRequestParent).Contains(kid)) {
                (kid)->DestroySubtree(subtreewhy);
            }
        }
    }
    {
        // Recursively shutting down PGamepadEventChannel kids
        nsTArray<PGamepadEventChannelParent*> kids;
        // Accumulate kids into a stable structure to iterate over
        ManagedPGamepadEventChannelParent(kids);
        for (auto& kid : kids) {
            // Guarding against a child removing a sibling from the list during the iteration.
            if ((mManagedPGamepadEventChannelParent).Contains(kid)) {
                (kid)->DestroySubtree(subtreewhy);
            }
        }
    }
    {
        // Recursively shutting down PGamepadTestChannel kids
        nsTArray<PGamepadTestChannelParent*> kids;
        // Accumulate kids into a stable structure to iterate over
        ManagedPGamepadTestChannelParent(kids);
        for (auto& kid : kids) {
            // Guarding against a child removing a sibling from the list during the iteration.
            if ((mManagedPGamepadTestChannelParent).Contains(kid)) {
                (kid)->DestroySubtree(subtreewhy);
            }
        }
    }
    {
        // Recursively shutting down PHttpBackgroundChannel kids
        nsTArray<PHttpBackgroundChannelParent*> kids;
        // Accumulate kids into a stable structure to iterate over
        ManagedPHttpBackgroundChannelParent(kids);
        for (auto& kid : kids) {
            // Guarding against a child removing a sibling from the list during the iteration.
            if ((mManagedPHttpBackgroundChannelParent).Contains(kid)) {
                (kid)->DestroySubtree(subtreewhy);
            }
        }
    }
    {
        // Recursively shutting down PIPCBlobInputStream kids
        nsTArray<PIPCBlobInputStreamParent*> kids;
        // Accumulate kids into a stable structure to iterate over
        ManagedPIPCBlobInputStreamParent(kids);
        for (auto& kid : kids) {
            // Guarding against a child removing a sibling from the list during the iteration.
            if ((mManagedPIPCBlobInputStreamParent).Contains(kid)) {
                (kid)->DestroySubtree(subtreewhy);
            }
        }
    }
    {
        // Recursively shutting down PPendingIPCBlob kids
        nsTArray<PPendingIPCBlobParent*> kids;
        // Accumulate kids into a stable structure to iterate over
        ManagedPPendingIPCBlobParent(kids);
        for (auto& kid : kids) {
            // Guarding against a child removing a sibling from the list during the iteration.
            if ((mManagedPPendingIPCBlobParent).Contains(kid)) {
                (kid)->DestroySubtree(subtreewhy);
            }
        }
    }
    {
        // Recursively shutting down PTemporaryIPCBlob kids
        nsTArray<PTemporaryIPCBlobParent*> kids;
        // Accumulate kids into a stable structure to iterate over
        ManagedPTemporaryIPCBlobParent(kids);
        for (auto& kid : kids) {
            // Guarding against a child removing a sibling from the list during the iteration.
            if ((mManagedPTemporaryIPCBlobParent).Contains(kid)) {
                (kid)->DestroySubtree(subtreewhy);
            }
        }
    }
    {
        // Recursively shutting down PMessagePort kids
        nsTArray<PMessagePortParent*> kids;
        // Accumulate kids into a stable structure to iterate over
        ManagedPMessagePortParent(kids);
        for (auto& kid : kids) {
            // Guarding against a child removing a sibling from the list during the iteration.
            if ((mManagedPMessagePortParent).Contains(kid)) {
                (kid)->DestroySubtree(subtreewhy);
            }
        }
    }
    {
        // Recursively shutting down PCameras kids
        nsTArray<PCamerasParent*> kids;
        // Accumulate kids into a stable structure to iterate over
        ManagedPCamerasParent(kids);
        for (auto& kid : kids) {
            // Guarding against a child removing a sibling from the list during the iteration.
            if ((mManagedPCamerasParent).Contains(kid)) {
                (kid)->DestroySubtree(subtreewhy);
            }
        }
    }
    {
        // Recursively shutting down PMIDIManager kids
        nsTArray<PMIDIManagerParent*> kids;
        // Accumulate kids into a stable structure to iterate over
        ManagedPMIDIManagerParent(kids);
        for (auto& kid : kids) {
            // Guarding against a child removing a sibling from the list during the iteration.
            if ((mManagedPMIDIManagerParent).Contains(kid)) {
                (kid)->DestroySubtree(subtreewhy);
            }
        }
    }
    {
        // Recursively shutting down PMIDIPort kids
        nsTArray<PMIDIPortParent*> kids;
        // Accumulate kids into a stable structure to iterate over
        ManagedPMIDIPortParent(kids);
        for (auto& kid : kids) {
            // Guarding against a child removing a sibling from the list during the iteration.
            if ((mManagedPMIDIPortParent).Contains(kid)) {
                (kid)->DestroySubtree(subtreewhy);
            }
        }
    }
    {
        // Recursively shutting down PQuota kids
        nsTArray<PQuotaParent*> kids;
        // Accumulate kids into a stable structure to iterate over
        ManagedPQuotaParent(kids);
        for (auto& kid : kids) {
            // Guarding against a child removing a sibling from the list during the iteration.
            if ((mManagedPQuotaParent).Contains(kid)) {
                (kid)->DestroySubtree(subtreewhy);
            }
        }
    }
    {
        // Recursively shutting down PChildToParentStream kids
        nsTArray<PChildToParentStreamParent*> kids;
        // Accumulate kids into a stable structure to iterate over
        ManagedPChildToParentStreamParent(kids);
        for (auto& kid : kids) {
            // Guarding against a child removing a sibling from the list during the iteration.
            if ((mManagedPChildToParentStreamParent).Contains(kid)) {
                (kid)->DestroySubtree(subtreewhy);
            }
        }
    }
    {
        // Recursively shutting down PParentToChildStream kids
        nsTArray<PParentToChildStreamParent*> kids;
        // Accumulate kids into a stable structure to iterate over
        ManagedPParentToChildStreamParent(kids);
        for (auto& kid : kids) {
            // Guarding against a child removing a sibling from the list during the iteration.
            if ((mManagedPParentToChildStreamParent).Contains(kid)) {
                (kid)->DestroySubtree(subtreewhy);
            }
        }
    }
    {
        // Recursively shutting down PServiceWorker kids
        nsTArray<PServiceWorkerParent*> kids;
        // Accumulate kids into a stable structure to iterate over
        ManagedPServiceWorkerParent(kids);
        for (auto& kid : kids) {
            // Guarding against a child removing a sibling from the list during the iteration.
            if ((mManagedPServiceWorkerParent).Contains(kid)) {
                (kid)->DestroySubtree(subtreewhy);
            }
        }
    }
    {
        // Recursively shutting down PServiceWorkerContainer kids
        nsTArray<PServiceWorkerContainerParent*> kids;
        // Accumulate kids into a stable structure to iterate over
        ManagedPServiceWorkerContainerParent(kids);
        for (auto& kid : kids) {
            // Guarding against a child removing a sibling from the list during the iteration.
            if ((mManagedPServiceWorkerContainerParent).Contains(kid)) {
                (kid)->DestroySubtree(subtreewhy);
            }
        }
    }
    {
        // Recursively shutting down PServiceWorkerManager kids
        nsTArray<PServiceWorkerManagerParent*> kids;
        // Accumulate kids into a stable structure to iterate over
        ManagedPServiceWorkerManagerParent(kids);
        for (auto& kid : kids) {
            // Guarding against a child removing a sibling from the list during the iteration.
            if ((mManagedPServiceWorkerManagerParent).Contains(kid)) {
                (kid)->DestroySubtree(subtreewhy);
            }
        }
    }
    {
        // Recursively shutting down PServiceWorkerRegistration kids
        nsTArray<PServiceWorkerRegistrationParent*> kids;
        // Accumulate kids into a stable structure to iterate over
        ManagedPServiceWorkerRegistrationParent(kids);
        for (auto& kid : kids) {
            // Guarding against a child removing a sibling from the list during the iteration.
            if ((mManagedPServiceWorkerRegistrationParent).Contains(kid)) {
                (kid)->DestroySubtree(subtreewhy);
            }
        }
    }
    {
        // Recursively shutting down PWebAuthnTransaction kids
        nsTArray<PWebAuthnTransactionParent*> kids;
        // Accumulate kids into a stable structure to iterate over
        ManagedPWebAuthnTransactionParent(kids);
        for (auto& kid : kids) {
            // Guarding against a child removing a sibling from the list during the iteration.
            if ((mManagedPWebAuthnTransactionParent).Contains(kid)) {
                (kid)->DestroySubtree(subtreewhy);
            }
        }
    }
    {
        // Recursively shutting down PUDPSocket kids
        nsTArray<PUDPSocketParent*> kids;
        // Accumulate kids into a stable structure to iterate over
        ManagedPUDPSocketParent(kids);
        for (auto& kid : kids) {
            // Guarding against a child removing a sibling from the list during the iteration.
            if ((mManagedPUDPSocketParent).Contains(kid)) {
                (kid)->DestroySubtree(subtreewhy);
            }
        }
    }
    {
        // Recursively shutting down PVsync kids
        nsTArray<PVsyncParent*> kids;
        // Accumulate kids into a stable structure to iterate over
        ManagedPVsyncParent(kids);
        for (auto& kid : kids) {
            // Guarding against a child removing a sibling from the list during the iteration.
            if ((mManagedPVsyncParent).Contains(kid)) {
                (kid)->DestroySubtree(subtreewhy);
            }
        }
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        for (auto iter = (mManagedPUDPSocketParent).Iter(); (!((iter).Done())); (iter).Next()) {
            DeallocPUDPSocketParent(((iter).Get())->GetKey());
        }
        (mManagedPUDPSocketParent).Clear();
    }
    {
        // Recursively deleting PVsync kids
        for (auto iter = (mManagedPVsyncParent).Iter(); (!((iter).Done())); (iter).Next()) {
            (((iter).Get())->GetKey())->DeallocSubtree();
        }

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

auto PBackgroundParent::DeallocPBackgroundParent() -> void
{
}



} // namespace ipc
} // namespace mozilla
namespace mozilla {
namespace ipc {
auto IPDLParamTraits<mozilla::ipc::PBackgroundParent>::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::PBackgroundParent>::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::PBackgroundParent*>((actor).value());
    return true;
}

} // namespace ipc
} // namespace mozilla

Coverage Report

Created: 2018-09-25 14:53