//
// Automatically generated by ipdlc.
// Edit at your own risk
//


#include "mozilla/ipc/PBackgroundParent.h"
#include "ipc/ErrorIPCUtils.h"
#include "mozilla/GfxMessageUtils.h"
#include "mozilla/ProfilerLabels.h"
#include "mozilla/RemoteLazyInputStream.h"
#include "mozilla/URLClassifierIPCUtils.h"
#include "mozilla/dom/BindingIPCUtils.h"
#include "mozilla/dom/CSPMessageUtils.h"
#include "mozilla/dom/ClientIPCUtils.h"
#include "mozilla/dom/DocShellMessageUtils.h"
#include "mozilla/dom/DomSecurityIPCUtils.h"
#include "mozilla/dom/MIDIIPCUtils.h"
#include "mozilla/dom/NavigationAPIIPCUtils.h"
#include "mozilla/dom/PBackgroundSessionStorageCache.h"
#include "mozilla/dom/PermissionMessageUtils.h"
#include "mozilla/dom/PolicyContainerMessageUtils.h"
#include "mozilla/dom/PropertyBagUtils.h"
#include "mozilla/dom/ReferrerInfoUtils.h"
#include "mozilla/dom/RemoteType.h"
#include "mozilla/dom/ServiceWorkerIPCUtils.h"
#include "mozilla/dom/SessionHistoryEntry.h"
#include "mozilla/dom/TabMessageUtils.h"
#include "mozilla/dom/WorkerIPCUtils.h"
#include "mozilla/dom/cache/IPCUtils.h"
#include "mozilla/dom/indexedDB/Key.h"
#include "mozilla/dom/indexedDB/KeyPath.h"
#include "mozilla/dom/indexedDB/SerializationHelpers.h"
#include "mozilla/dom/ipc/StructuredCloneData.h"
#include "mozilla/dom/localstorage/SerializationHelpers.h"
#include "mozilla/dom/notification/IPCUtils.h"
#include "mozilla/dom/quota/SerializationHelpers.h"
#include "mozilla/ipc/BigBuffer.h"
#include "mozilla/ipc/IPCCore.h"
#include "mozilla/ipc/IPCStreamUtils.h"
#include "mozilla/ipc/URIUtils.h"
#include "mozilla/layers/LayersMessageUtils.h"
#include "mozilla/net/NeckoMessageUtils.h"
#include "nsID.h"
#include "nsIPolicyContainer.h"
#include "nsIPrincipal.h"
#include "nsIReferrerInfo.h"
#include "nsIURI.h"
#include "nsIVariant.h"
#include "nsStructuredCloneContainer.h"

#include "mozilla/net/PBackgroundDataBridgeParent.h"
#include "mozilla/dom/indexedDB/PBackgroundIDBFactoryParent.h"
#include "mozilla/dom/indexedDB/PBackgroundIndexedDBUtilsParent.h"
#include "mozilla/dom/PBackgroundSDBConnectionParent.h"
#include "mozilla/dom/PBackgroundLSObserverParent.h"
#include "mozilla/dom/PBackgroundLSRequestParent.h"
#include "mozilla/dom/PBackgroundLSSimpleRequestParent.h"
#include "mozilla/dom/PBackgroundLocalStorageCacheParent.h"
#include "mozilla/dom/PBackgroundSessionStorageManagerParent.h"
#include "mozilla/dom/PBackgroundSessionStorageServiceParent.h"
#include "mozilla/dom/PBackgroundStorageParent.h"
#include "mozilla/ipc/PBackgroundTestParent.h"
#include "mozilla/dom/cache/PBoundStorageKeyParent.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/dom/PCookieStoreParent.h"
#include "mozilla/dom/PFileSystemManagerParent.h"
#include "mozilla/dom/PFileSystemRequestParent.h"
#include "mozilla/dom/PGamepadEventChannelParent.h"
#include "mozilla/dom/PGamepadTestChannelParent.h"
#include "mozilla/net/PHttpBackgroundChannelParent.h"
#include "mozilla/ipc/PIdleSchedulerParent.h"
#include "mozilla/dom/PRemoteWorkerControllerParent.h"
#include "mozilla/dom/PRemoteWorkerServiceParent.h"
#include "mozilla/dom/PSharedWorkerParent.h"
#include "mozilla/dom/PTemporaryIPCBlobParent.h"
#include "mozilla/dom/PFileCreatorParent.h"
#include "mozilla/dom/PMessagePortParent.h"
#include "mozilla/camera/PCamerasParent.h"
#include "mozilla/dom/locks/PLockManagerParent.h"
#include "mozilla/dom/PMIDIManagerParent.h"
#include "mozilla/dom/PMIDIPortParent.h"
#include "mozilla/dom/PMLSTransactionParent.h"
#include "mozilla/dom/quota/PQuotaParent.h"
#include "mozilla/dom/PServiceWorkerParent.h"
#include "mozilla/dom/PServiceWorkerContainerParent.h"
#include "mozilla/dom/PServiceWorkerManagerParent.h"
#include "mozilla/dom/PServiceWorkerRegistrationParent.h"
#include "mozilla/net/PUDPSocketParent.h"
#include "mozilla/dom/PVsyncParent.h"
#include "mozilla/PRemoteMediaManagerParent.h"
#include "mozilla/dom/PWebTransportParent.h"
#include "mozilla/dom/PFetchParent.h"
#include "mozilla/dom/notification/PNotificationParent.h"

#include "ipc/IPCMessageUtils.h"
#include "ipc/IPCMessageUtilsSpecializations.h"
#include "nsIFile.h"
#include "mozilla/ipc/Endpoint.h"
#include "mozilla/ipc/ProtocolMessageUtils.h"
#include "mozilla/ipc/ProtocolUtils.h"
#include "mozilla/ipc/ShmemMessageUtils.h"
#include "mozilla/ipc/TaintingIPCUtils.h"

namespace mozilla {
namespace ipc {


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

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

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

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

auto PBackgroundParent::RecvPBackgroundLSObserverConstructor(
        PBackgroundLSObserverParent* actor,
        const uint64_t& observerId) -> mozilla::ipc::IPCResult
{
    return IPC_OK();
}

auto PBackgroundParent::RecvPBackgroundLSRequestConstructor(
        PBackgroundLSRequestParent* actor,
        const LSRequestParams& params) -> mozilla::ipc::IPCResult
{
    return IPC_OK();
}

auto PBackgroundParent::RecvPBackgroundLSSimpleRequestConstructor(
        PBackgroundLSSimpleRequestParent* actor,
        const LSSimpleRequestParams& params) -> mozilla::ipc::IPCResult
{
    return IPC_OK();
}

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

auto PBackgroundParent::RecvPBackgroundSessionStorageManagerConstructor(
        PBackgroundSessionStorageManagerParent* actor,
        const uint64_t& aTopContextId) -> mozilla::ipc::IPCResult
{
    return IPC_OK();
}

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

auto PBackgroundParent::RecvPBackgroundStorageConstructor(
        PBackgroundStorageParent* actor,
        const nsAString& profilePath,
        const uint32_t& privateBrowsingId) -> 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 mozilla::Maybe<PrincipalInfo>& pInfo,
        const nsACString& filter) -> mozilla::ipc::IPCResult
{
    return IPC_OK();
}

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

auto PBackgroundParent::RecvPCookieStoreConstructor(PCookieStoreParent* actor) -> 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::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::RecvPSharedWorkerConstructor(
        PSharedWorkerParent* actor,
        const RemoteWorkerData& data,
        const uint64_t& windowID,
        const MessagePortIdentifier& portIdentifier) -> mozilla::ipc::IPCResult
{
    return IPC_OK();
}

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

auto PBackgroundParent::RecvPFileCreatorConstructor(
        PFileCreatorParent* actor,
        const nsAString& aFullPath,
        const nsAString& aType,
        const nsAString& aName,
        const mozilla::Maybe<int64_t>& lastModified,
        const bool& aExistenceCheck,
        const bool& aIsFromNsIFile) -> mozilla::ipc::IPCResult
{
    return IPC_OK();
}

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

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

auto PBackgroundParent::RecvPRemoteWorkerControllerConstructor(
        PRemoteWorkerControllerParent* actor,
        const RemoteWorkerData& aData) -> 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,
        const IPCClientInfo& aForClient) -> mozilla::ipc::IPCResult
{
    return IPC_OK();
}

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

auto PBackgroundParent::RecvPLockManagerConstructor(
        PLockManagerParent* actor,
        mozilla::NotNull<nsIPrincipal*> aPrincipalInfo,
        const mozilla::Maybe<nsID>& aClientId) -> mozilla::ipc::IPCResult
{
    return IPC_OK();
}

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

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

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

MOZ_IMPLICIT PBackgroundParent::PBackgroundParent() :
    mozilla::ipc::IToplevelProtocol("PBackgroundParent", kProtocolId, mozilla::ipc::ParentSide)
{
    MOZ_COUNT_CTOR(PBackgroundParent);
}

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

auto PBackgroundParent::ActorAlloc() -> void
{
    MOZ_RELEASE_ASSERT(XRE_IsParentProcess(), "Invalid process for `PBackgroundParent'");
    AddRef();
}

auto PBackgroundParent::ActorDealloc() -> void
{
    Release();
}

auto PBackgroundParent::OtherPid() const -> ::base::ProcessId
{
    ::base::ProcessId pid =
        ::mozilla::ipc::IProtocol::ToplevelProtocol()->OtherPidMaybeInvalid();
    MOZ_RELEASE_ASSERT(pid != ::base::kInvalidProcessId);
    return pid;
}

auto PBackgroundParent::OtherChildID() const -> ::GeckoChildID
{
    ::GeckoChildID childID =
        ::mozilla::ipc::IProtocol::ToplevelProtocol()->OtherChildIDMaybeInvalid();
    MOZ_RELEASE_ASSERT(childID != -1);
    return childID;
}

auto PBackgroundParent::OtherEndpointProcInfo() const -> ::mozilla::ipc::EndpointProcInfo
{
    return ::mozilla::ipc::EndpointProcInfo{OtherPid(), OtherChildID()};
}

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::ManagedPBackgroundLSObserverParent(nsTArray<PBackgroundLSObserverParent*>& aArr) const -> void
{
    mManagedPBackgroundLSObserverParent.ToArray(aArr);
}

auto PBackgroundParent::ManagedPBackgroundLSObserverParent() const -> const ManagedContainer<PBackgroundLSObserverParent>&
{
    return mManagedPBackgroundLSObserverParent;
}

auto PBackgroundParent::ManagedPBackgroundLSRequestParent(nsTArray<PBackgroundLSRequestParent*>& aArr) const -> void
{
    mManagedPBackgroundLSRequestParent.ToArray(aArr);
}

auto PBackgroundParent::ManagedPBackgroundLSRequestParent() const -> const ManagedContainer<PBackgroundLSRequestParent>&
{
    return mManagedPBackgroundLSRequestParent;
}

auto PBackgroundParent::ManagedPBackgroundLSSimpleRequestParent(nsTArray<PBackgroundLSSimpleRequestParent*>& aArr) const -> void
{
    mManagedPBackgroundLSSimpleRequestParent.ToArray(aArr);
}

auto PBackgroundParent::ManagedPBackgroundLSSimpleRequestParent() const -> const ManagedContainer<PBackgroundLSSimpleRequestParent>&
{
    return mManagedPBackgroundLSSimpleRequestParent;
}

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

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

auto PBackgroundParent::ManagedPBackgroundSessionStorageManagerParent(nsTArray<PBackgroundSessionStorageManagerParent*>& aArr) const -> void
{
    mManagedPBackgroundSessionStorageManagerParent.ToArray(aArr);
}

auto PBackgroundParent::ManagedPBackgroundSessionStorageManagerParent() const -> const ManagedContainer<PBackgroundSessionStorageManagerParent>&
{
    return mManagedPBackgroundSessionStorageManagerParent;
}

auto PBackgroundParent::ManagedPBackgroundSessionStorageServiceParent(nsTArray<PBackgroundSessionStorageServiceParent*>& aArr) const -> void
{
    mManagedPBackgroundSessionStorageServiceParent.ToArray(aArr);
}

auto PBackgroundParent::ManagedPBackgroundSessionStorageServiceParent() const -> const ManagedContainer<PBackgroundSessionStorageServiceParent>&
{
    return mManagedPBackgroundSessionStorageServiceParent;
}

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::ManagedPCookieStoreParent(nsTArray<PCookieStoreParent*>& aArr) const -> void
{
    mManagedPCookieStoreParent.ToArray(aArr);
}

auto PBackgroundParent::ManagedPCookieStoreParent() const -> const ManagedContainer<PCookieStoreParent>&
{
    return mManagedPCookieStoreParent;
}

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::ManagedPIdleSchedulerParent(nsTArray<PIdleSchedulerParent*>& aArr) const -> void
{
    mManagedPIdleSchedulerParent.ToArray(aArr);
}

auto PBackgroundParent::ManagedPIdleSchedulerParent() const -> const ManagedContainer<PIdleSchedulerParent>&
{
    return mManagedPIdleSchedulerParent;
}

auto PBackgroundParent::ManagedPLockManagerParent(nsTArray<PLockManagerParent*>& aArr) const -> void
{
    mManagedPLockManagerParent.ToArray(aArr);
}

auto PBackgroundParent::ManagedPLockManagerParent() const -> const ManagedContainer<PLockManagerParent>&
{
    return mManagedPLockManagerParent;
}

auto PBackgroundParent::ManagedPRemoteWorkerControllerParent(nsTArray<PRemoteWorkerControllerParent*>& aArr) const -> void
{
    mManagedPRemoteWorkerControllerParent.ToArray(aArr);
}

auto PBackgroundParent::ManagedPRemoteWorkerControllerParent() const -> const ManagedContainer<PRemoteWorkerControllerParent>&
{
    return mManagedPRemoteWorkerControllerParent;
}

auto PBackgroundParent::ManagedPSharedWorkerParent(nsTArray<PSharedWorkerParent*>& aArr) const -> void
{
    mManagedPSharedWorkerParent.ToArray(aArr);
}

auto PBackgroundParent::ManagedPSharedWorkerParent() const -> const ManagedContainer<PSharedWorkerParent>&
{
    return mManagedPSharedWorkerParent;
}

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

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

auto PBackgroundParent::ManagedPFileCreatorParent(nsTArray<PFileCreatorParent*>& aArr) const -> void
{
    mManagedPFileCreatorParent.ToArray(aArr);
}

auto PBackgroundParent::ManagedPFileCreatorParent() const -> const ManagedContainer<PFileCreatorParent>&
{
    return mManagedPFileCreatorParent;
}

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::ManagedPQuotaParent(nsTArray<PQuotaParent*>& aArr) const -> void
{
    mManagedPQuotaParent.ToArray(aArr);
}

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

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::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::ManagedPFetchParent(nsTArray<PFetchParent*>& aArr) const -> void
{
    mManagedPFetchParent.ToArray(aArr);
}

auto PBackgroundParent::ManagedPFetchParent() const -> const ManagedContainer<PFetchParent>&
{
    return mManagedPFetchParent;
}

auto PBackgroundParent::ManagedProtocolIds() const -> mozilla::Span<mozilla::ipc::ProtocolId const>
{
    static constexpr ::mozilla::ipc::ProtocolId sIds[] = {
        PBackgroundIDBFactoryMsgStart,
        PBackgroundIndexedDBUtilsMsgStart,
        PBackgroundSDBConnectionMsgStart,
        PBackgroundLSObserverMsgStart,
        PBackgroundLSRequestMsgStart,
        PBackgroundLSSimpleRequestMsgStart,
        PBackgroundLocalStorageCacheMsgStart,
        PBackgroundSessionStorageManagerMsgStart,
        PBackgroundSessionStorageServiceMsgStart,
        PBackgroundStorageMsgStart,
        PBackgroundTestMsgStart,
        PBroadcastChannelMsgStart,
        PCacheMsgStart,
        PCacheStorageMsgStart,
        PCacheStreamControlMsgStart,
        PClientManagerMsgStart,
        PCookieStoreMsgStart,
        PFileSystemRequestMsgStart,
        PGamepadEventChannelMsgStart,
        PGamepadTestChannelMsgStart,
        PHttpBackgroundChannelMsgStart,
        PIdleSchedulerMsgStart,
        PLockManagerMsgStart,
        PRemoteWorkerControllerMsgStart,
        PSharedWorkerMsgStart,
        PTemporaryIPCBlobMsgStart,
        PFileCreatorMsgStart,
        PMessagePortMsgStart,
        PCamerasMsgStart,
        PQuotaMsgStart,
        PServiceWorkerMsgStart,
        PServiceWorkerContainerMsgStart,
        PServiceWorkerManagerMsgStart,
        PServiceWorkerRegistrationMsgStart,
        PUDPSocketMsgStart,
        PVsyncMsgStart,
        PFetchMsgStart
    };
    return sIds;
}

auto PBackgroundParent::GetManagedActors(mozilla::ipc::ProtocolId aProtocol) -> UntypedManagedContainer*
{
    switch (aProtocol) {
    case PBackgroundIDBFactoryMsgStart:
        return (&(mManagedPBackgroundIDBFactoryParent));
    case PBackgroundIndexedDBUtilsMsgStart:
        return (&(mManagedPBackgroundIndexedDBUtilsParent));
    case PBackgroundSDBConnectionMsgStart:
        return (&(mManagedPBackgroundSDBConnectionParent));
    case PBackgroundLSObserverMsgStart:
        return (&(mManagedPBackgroundLSObserverParent));
    case PBackgroundLSRequestMsgStart:
        return (&(mManagedPBackgroundLSRequestParent));
    case PBackgroundLSSimpleRequestMsgStart:
        return (&(mManagedPBackgroundLSSimpleRequestParent));
    case PBackgroundLocalStorageCacheMsgStart:
        return (&(mManagedPBackgroundLocalStorageCacheParent));
    case PBackgroundSessionStorageManagerMsgStart:
        return (&(mManagedPBackgroundSessionStorageManagerParent));
    case PBackgroundSessionStorageServiceMsgStart:
        return (&(mManagedPBackgroundSessionStorageServiceParent));
    case PBackgroundStorageMsgStart:
        return (&(mManagedPBackgroundStorageParent));
    case PBackgroundTestMsgStart:
        return (&(mManagedPBackgroundTestParent));
    case PBroadcastChannelMsgStart:
        return (&(mManagedPBroadcastChannelParent));
    case PCacheMsgStart:
        return (&(mManagedPCacheParent));
    case PCacheStorageMsgStart:
        return (&(mManagedPCacheStorageParent));
    case PCacheStreamControlMsgStart:
        return (&(mManagedPCacheStreamControlParent));
    case PClientManagerMsgStart:
        return (&(mManagedPClientManagerParent));
    case PCookieStoreMsgStart:
        return (&(mManagedPCookieStoreParent));
    case PFileSystemRequestMsgStart:
        return (&(mManagedPFileSystemRequestParent));
    case PGamepadEventChannelMsgStart:
        return (&(mManagedPGamepadEventChannelParent));
    case PGamepadTestChannelMsgStart:
        return (&(mManagedPGamepadTestChannelParent));
    case PHttpBackgroundChannelMsgStart:
        return (&(mManagedPHttpBackgroundChannelParent));
    case PIdleSchedulerMsgStart:
        return (&(mManagedPIdleSchedulerParent));
    case PLockManagerMsgStart:
        return (&(mManagedPLockManagerParent));
    case PRemoteWorkerControllerMsgStart:
        return (&(mManagedPRemoteWorkerControllerParent));
    case PSharedWorkerMsgStart:
        return (&(mManagedPSharedWorkerParent));
    case PTemporaryIPCBlobMsgStart:
        return (&(mManagedPTemporaryIPCBlobParent));
    case PFileCreatorMsgStart:
        return (&(mManagedPFileCreatorParent));
    case PMessagePortMsgStart:
        return (&(mManagedPMessagePortParent));
    case PCamerasMsgStart:
        return (&(mManagedPCamerasParent));
    case PQuotaMsgStart:
        return (&(mManagedPQuotaParent));
    case PServiceWorkerMsgStart:
        return (&(mManagedPServiceWorkerParent));
    case PServiceWorkerContainerMsgStart:
        return (&(mManagedPServiceWorkerContainerParent));
    case PServiceWorkerManagerMsgStart:
        return (&(mManagedPServiceWorkerManagerParent));
    case PServiceWorkerRegistrationMsgStart:
        return (&(mManagedPServiceWorkerRegistrationParent));
    case PUDPSocketMsgStart:
        return (&(mManagedPUDPSocketParent));
    case PVsyncMsgStart:
        return (&(mManagedPVsyncParent));
    case PFetchMsgStart:
        return (&(mManagedPFetchParent));
    default:
        return nullptr;
    }
}

auto PBackgroundParent::RejectPendingResponses(ResponseRejectReason aReason) -> void
{
    mAsyncCallbacks.RejectPendingResponses(aReason);
}

auto PBackgroundParent::OpenPBackgroundIDBFactoryEndpoint(PBackgroundIDBFactoryParent* aActor) -> ManagedEndpoint<PBackgroundIDBFactoryChild>
{
    if (!aActor) {
        NS_WARNING("Cannot bind null PBackgroundIDBFactoryParent actor");
        return ManagedEndpoint<PBackgroundIDBFactoryChild>();
    }

    if (!aActor->SetManagerAndRegister(this)) {
        NS_WARNING("Failed to bind PBackgroundIDBFactoryParent actor");
        return ManagedEndpoint<PBackgroundIDBFactoryChild>();
    }

    // Mark our actor as awaiting the other side to be bound. This will
    // be cleared when a `MANAGED_ENDPOINT_{DROPPED,BOUND}` message is
    // received.
    aActor->mAwaitingManagedEndpointBind = true;
    return ManagedEndpoint<PBackgroundIDBFactoryChild>(mozilla::ipc::PrivateIPDLInterface(), aActor);
}

auto PBackgroundParent::BindPBackgroundIDBFactoryEndpoint(
        ManagedEndpoint<PBackgroundIDBFactoryParent> aEndpoint,
        PBackgroundIDBFactoryParent* aActor) -> bool
{
    return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this);
}

auto PBackgroundParent::OpenPBackgroundIndexedDBUtilsEndpoint(PBackgroundIndexedDBUtilsParent* aActor) -> ManagedEndpoint<PBackgroundIndexedDBUtilsChild>
{
    if (!aActor) {
        NS_WARNING("Cannot bind null PBackgroundIndexedDBUtilsParent actor");
        return ManagedEndpoint<PBackgroundIndexedDBUtilsChild>();
    }

    if (!aActor->SetManagerAndRegister(this)) {
        NS_WARNING("Failed to bind PBackgroundIndexedDBUtilsParent actor");
        return ManagedEndpoint<PBackgroundIndexedDBUtilsChild>();
    }

    // Mark our actor as awaiting the other side to be bound. This will
    // be cleared when a `MANAGED_ENDPOINT_{DROPPED,BOUND}` message is
    // received.
    aActor->mAwaitingManagedEndpointBind = true;
    return ManagedEndpoint<PBackgroundIndexedDBUtilsChild>(mozilla::ipc::PrivateIPDLInterface(), aActor);
}

auto PBackgroundParent::BindPBackgroundIndexedDBUtilsEndpoint(
        ManagedEndpoint<PBackgroundIndexedDBUtilsParent> aEndpoint,
        PBackgroundIndexedDBUtilsParent* aActor) -> bool
{
    return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this);
}

auto PBackgroundParent::OpenPBackgroundSDBConnectionEndpoint(PBackgroundSDBConnectionParent* aActor) -> ManagedEndpoint<PBackgroundSDBConnectionChild>
{
    if (!aActor) {
        NS_WARNING("Cannot bind null PBackgroundSDBConnectionParent actor");
        return ManagedEndpoint<PBackgroundSDBConnectionChild>();
    }

    if (!aActor->SetManagerAndRegister(this)) {
        NS_WARNING("Failed to bind PBackgroundSDBConnectionParent actor");
        return ManagedEndpoint<PBackgroundSDBConnectionChild>();
    }

    // Mark our actor as awaiting the other side to be bound. This will
    // be cleared when a `MANAGED_ENDPOINT_{DROPPED,BOUND}` message is
    // received.
    aActor->mAwaitingManagedEndpointBind = true;
    return ManagedEndpoint<PBackgroundSDBConnectionChild>(mozilla::ipc::PrivateIPDLInterface(), aActor);
}

auto PBackgroundParent::BindPBackgroundSDBConnectionEndpoint(
        ManagedEndpoint<PBackgroundSDBConnectionParent> aEndpoint,
        PBackgroundSDBConnectionParent* aActor) -> bool
{
    return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this);
}

auto PBackgroundParent::OpenPBackgroundLSObserverEndpoint(PBackgroundLSObserverParent* aActor) -> ManagedEndpoint<PBackgroundLSObserverChild>
{
    if (!aActor) {
        NS_WARNING("Cannot bind null PBackgroundLSObserverParent actor");
        return ManagedEndpoint<PBackgroundLSObserverChild>();
    }

    if (!aActor->SetManagerAndRegister(this)) {
        NS_WARNING("Failed to bind PBackgroundLSObserverParent actor");
        return ManagedEndpoint<PBackgroundLSObserverChild>();
    }

    // Mark our actor as awaiting the other side to be bound. This will
    // be cleared when a `MANAGED_ENDPOINT_{DROPPED,BOUND}` message is
    // received.
    aActor->mAwaitingManagedEndpointBind = true;
    return ManagedEndpoint<PBackgroundLSObserverChild>(mozilla::ipc::PrivateIPDLInterface(), aActor);
}

auto PBackgroundParent::BindPBackgroundLSObserverEndpoint(
        ManagedEndpoint<PBackgroundLSObserverParent> aEndpoint,
        PBackgroundLSObserverParent* aActor) -> bool
{
    return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this);
}

auto PBackgroundParent::OpenPBackgroundLSRequestEndpoint(PBackgroundLSRequestParent* aActor) -> ManagedEndpoint<PBackgroundLSRequestChild>
{
    if (!aActor) {
        NS_WARNING("Cannot bind null PBackgroundLSRequestParent actor");
        return ManagedEndpoint<PBackgroundLSRequestChild>();
    }

    if (!aActor->SetManagerAndRegister(this)) {
        NS_WARNING("Failed to bind PBackgroundLSRequestParent actor");
        return ManagedEndpoint<PBackgroundLSRequestChild>();
    }

    // Mark our actor as awaiting the other side to be bound. This will
    // be cleared when a `MANAGED_ENDPOINT_{DROPPED,BOUND}` message is
    // received.
    aActor->mAwaitingManagedEndpointBind = true;
    return ManagedEndpoint<PBackgroundLSRequestChild>(mozilla::ipc::PrivateIPDLInterface(), aActor);
}

auto PBackgroundParent::BindPBackgroundLSRequestEndpoint(
        ManagedEndpoint<PBackgroundLSRequestParent> aEndpoint,
        PBackgroundLSRequestParent* aActor) -> bool
{
    return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this);
}

auto PBackgroundParent::OpenPBackgroundLSSimpleRequestEndpoint(PBackgroundLSSimpleRequestParent* aActor) -> ManagedEndpoint<PBackgroundLSSimpleRequestChild>
{
    if (!aActor) {
        NS_WARNING("Cannot bind null PBackgroundLSSimpleRequestParent actor");
        return ManagedEndpoint<PBackgroundLSSimpleRequestChild>();
    }

    if (!aActor->SetManagerAndRegister(this)) {
        NS_WARNING("Failed to bind PBackgroundLSSimpleRequestParent actor");
        return ManagedEndpoint<PBackgroundLSSimpleRequestChild>();
    }

    // Mark our actor as awaiting the other side to be bound. This will
    // be cleared when a `MANAGED_ENDPOINT_{DROPPED,BOUND}` message is
    // received.
    aActor->mAwaitingManagedEndpointBind = true;
    return ManagedEndpoint<PBackgroundLSSimpleRequestChild>(mozilla::ipc::PrivateIPDLInterface(), aActor);
}

auto PBackgroundParent::BindPBackgroundLSSimpleRequestEndpoint(
        ManagedEndpoint<PBackgroundLSSimpleRequestParent> aEndpoint,
        PBackgroundLSSimpleRequestParent* aActor) -> bool
{
    return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this);
}

auto PBackgroundParent::OpenPBackgroundLocalStorageCacheEndpoint(PBackgroundLocalStorageCacheParent* aActor) -> ManagedEndpoint<PBackgroundLocalStorageCacheChild>
{
    if (!aActor) {
        NS_WARNING("Cannot bind null PBackgroundLocalStorageCacheParent actor");
        return ManagedEndpoint<PBackgroundLocalStorageCacheChild>();
    }

    if (!aActor->SetManagerAndRegister(this)) {
        NS_WARNING("Failed to bind PBackgroundLocalStorageCacheParent actor");
        return ManagedEndpoint<PBackgroundLocalStorageCacheChild>();
    }

    // Mark our actor as awaiting the other side to be bound. This will
    // be cleared when a `MANAGED_ENDPOINT_{DROPPED,BOUND}` message is
    // received.
    aActor->mAwaitingManagedEndpointBind = true;
    return ManagedEndpoint<PBackgroundLocalStorageCacheChild>(mozilla::ipc::PrivateIPDLInterface(), aActor);
}

auto PBackgroundParent::BindPBackgroundLocalStorageCacheEndpoint(
        ManagedEndpoint<PBackgroundLocalStorageCacheParent> aEndpoint,
        PBackgroundLocalStorageCacheParent* aActor) -> bool
{
    return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this);
}

auto PBackgroundParent::OpenPBackgroundSessionStorageManagerEndpoint(PBackgroundSessionStorageManagerParent* aActor) -> ManagedEndpoint<PBackgroundSessionStorageManagerChild>
{
    if (!aActor) {
        NS_WARNING("Cannot bind null PBackgroundSessionStorageManagerParent actor");
        return ManagedEndpoint<PBackgroundSessionStorageManagerChild>();
    }

    if (!aActor->SetManagerAndRegister(this)) {
        NS_WARNING("Failed to bind PBackgroundSessionStorageManagerParent actor");
        return ManagedEndpoint<PBackgroundSessionStorageManagerChild>();
    }

    // Mark our actor as awaiting the other side to be bound. This will
    // be cleared when a `MANAGED_ENDPOINT_{DROPPED,BOUND}` message is
    // received.
    aActor->mAwaitingManagedEndpointBind = true;
    return ManagedEndpoint<PBackgroundSessionStorageManagerChild>(mozilla::ipc::PrivateIPDLInterface(), aActor);
}

auto PBackgroundParent::BindPBackgroundSessionStorageManagerEndpoint(
        ManagedEndpoint<PBackgroundSessionStorageManagerParent> aEndpoint,
        PBackgroundSessionStorageManagerParent* aActor) -> bool
{
    return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this);
}

auto PBackgroundParent::OpenPBackgroundSessionStorageServiceEndpoint(PBackgroundSessionStorageServiceParent* aActor) -> ManagedEndpoint<PBackgroundSessionStorageServiceChild>
{
    if (!aActor) {
        NS_WARNING("Cannot bind null PBackgroundSessionStorageServiceParent actor");
        return ManagedEndpoint<PBackgroundSessionStorageServiceChild>();
    }

    if (!aActor->SetManagerAndRegister(this)) {
        NS_WARNING("Failed to bind PBackgroundSessionStorageServiceParent actor");
        return ManagedEndpoint<PBackgroundSessionStorageServiceChild>();
    }

    // Mark our actor as awaiting the other side to be bound. This will
    // be cleared when a `MANAGED_ENDPOINT_{DROPPED,BOUND}` message is
    // received.
    aActor->mAwaitingManagedEndpointBind = true;
    return ManagedEndpoint<PBackgroundSessionStorageServiceChild>(mozilla::ipc::PrivateIPDLInterface(), aActor);
}

auto PBackgroundParent::BindPBackgroundSessionStorageServiceEndpoint(
        ManagedEndpoint<PBackgroundSessionStorageServiceParent> aEndpoint,
        PBackgroundSessionStorageServiceParent* aActor) -> bool
{
    return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this);
}

auto PBackgroundParent::OpenPBackgroundStorageEndpoint(PBackgroundStorageParent* aActor) -> ManagedEndpoint<PBackgroundStorageChild>
{
    if (!aActor) {
        NS_WARNING("Cannot bind null PBackgroundStorageParent actor");
        return ManagedEndpoint<PBackgroundStorageChild>();
    }

    if (!aActor->SetManagerAndRegister(this)) {
        NS_WARNING("Failed to bind PBackgroundStorageParent actor");
        return ManagedEndpoint<PBackgroundStorageChild>();
    }

    // Mark our actor as awaiting the other side to be bound. This will
    // be cleared when a `MANAGED_ENDPOINT_{DROPPED,BOUND}` message is
    // received.
    aActor->mAwaitingManagedEndpointBind = true;
    return ManagedEndpoint<PBackgroundStorageChild>(mozilla::ipc::PrivateIPDLInterface(), aActor);
}

auto PBackgroundParent::BindPBackgroundStorageEndpoint(
        ManagedEndpoint<PBackgroundStorageParent> aEndpoint,
        PBackgroundStorageParent* aActor) -> bool
{
    return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this);
}

auto PBackgroundParent::OpenPBackgroundTestEndpoint(PBackgroundTestParent* aActor) -> ManagedEndpoint<PBackgroundTestChild>
{
    if (!aActor) {
        NS_WARNING("Cannot bind null PBackgroundTestParent actor");
        return ManagedEndpoint<PBackgroundTestChild>();
    }

    if (!aActor->SetManagerAndRegister(this)) {
        NS_WARNING("Failed to bind PBackgroundTestParent actor");
        return ManagedEndpoint<PBackgroundTestChild>();
    }

    // Mark our actor as awaiting the other side to be bound. This will
    // be cleared when a `MANAGED_ENDPOINT_{DROPPED,BOUND}` message is
    // received.
    aActor->mAwaitingManagedEndpointBind = true;
    return ManagedEndpoint<PBackgroundTestChild>(mozilla::ipc::PrivateIPDLInterface(), aActor);
}

auto PBackgroundParent::BindPBackgroundTestEndpoint(
        ManagedEndpoint<PBackgroundTestParent> aEndpoint,
        PBackgroundTestParent* aActor) -> bool
{
    return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this);
}

auto PBackgroundParent::OpenPBroadcastChannelEndpoint(PBroadcastChannelParent* aActor) -> ManagedEndpoint<PBroadcastChannelChild>
{
    if (!aActor) {
        NS_WARNING("Cannot bind null PBroadcastChannelParent actor");
        return ManagedEndpoint<PBroadcastChannelChild>();
    }

    if (!aActor->SetManagerAndRegister(this)) {
        NS_WARNING("Failed to bind PBroadcastChannelParent actor");
        return ManagedEndpoint<PBroadcastChannelChild>();
    }

    // Mark our actor as awaiting the other side to be bound. This will
    // be cleared when a `MANAGED_ENDPOINT_{DROPPED,BOUND}` message is
    // received.
    aActor->mAwaitingManagedEndpointBind = true;
    return ManagedEndpoint<PBroadcastChannelChild>(mozilla::ipc::PrivateIPDLInterface(), aActor);
}

auto PBackgroundParent::BindPBroadcastChannelEndpoint(
        ManagedEndpoint<PBroadcastChannelParent> aEndpoint,
        PBroadcastChannelParent* aActor) -> bool
{
    return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this);
}

auto PBackgroundParent::OpenPCacheEndpoint(PCacheParent* aActor) -> ManagedEndpoint<PCacheChild>
{
    if (!aActor) {
        NS_WARNING("Cannot bind null PCacheParent actor");
        return ManagedEndpoint<PCacheChild>();
    }

    if (!aActor->SetManagerAndRegister(this)) {
        NS_WARNING("Failed to bind PCacheParent actor");
        return ManagedEndpoint<PCacheChild>();
    }

    // Mark our actor as awaiting the other side to be bound. This will
    // be cleared when a `MANAGED_ENDPOINT_{DROPPED,BOUND}` message is
    // received.
    aActor->mAwaitingManagedEndpointBind = true;
    return ManagedEndpoint<PCacheChild>(mozilla::ipc::PrivateIPDLInterface(), aActor);
}

auto PBackgroundParent::BindPCacheEndpoint(
        ManagedEndpoint<PCacheParent> aEndpoint,
        PCacheParent* aActor) -> bool
{
    return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this);
}

auto PBackgroundParent::OpenPCacheStorageEndpoint(PCacheStorageParent* aActor) -> ManagedEndpoint<PCacheStorageChild>
{
    if (!aActor) {
        NS_WARNING("Cannot bind null PCacheStorageParent actor");
        return ManagedEndpoint<PCacheStorageChild>();
    }

    if (!aActor->SetManagerAndRegister(this)) {
        NS_WARNING("Failed to bind PCacheStorageParent actor");
        return ManagedEndpoint<PCacheStorageChild>();
    }

    // Mark our actor as awaiting the other side to be bound. This will
    // be cleared when a `MANAGED_ENDPOINT_{DROPPED,BOUND}` message is
    // received.
    aActor->mAwaitingManagedEndpointBind = true;
    return ManagedEndpoint<PCacheStorageChild>(mozilla::ipc::PrivateIPDLInterface(), aActor);
}

auto PBackgroundParent::BindPCacheStorageEndpoint(
        ManagedEndpoint<PCacheStorageParent> aEndpoint,
        PCacheStorageParent* aActor) -> bool
{
    return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this);
}

auto PBackgroundParent::OpenPCacheStreamControlEndpoint(PCacheStreamControlParent* aActor) -> ManagedEndpoint<PCacheStreamControlChild>
{
    if (!aActor) {
        NS_WARNING("Cannot bind null PCacheStreamControlParent actor");
        return ManagedEndpoint<PCacheStreamControlChild>();
    }

    if (!aActor->SetManagerAndRegister(this)) {
        NS_WARNING("Failed to bind PCacheStreamControlParent actor");
        return ManagedEndpoint<PCacheStreamControlChild>();
    }

    // Mark our actor as awaiting the other side to be bound. This will
    // be cleared when a `MANAGED_ENDPOINT_{DROPPED,BOUND}` message is
    // received.
    aActor->mAwaitingManagedEndpointBind = true;
    return ManagedEndpoint<PCacheStreamControlChild>(mozilla::ipc::PrivateIPDLInterface(), aActor);
}

auto PBackgroundParent::BindPCacheStreamControlEndpoint(
        ManagedEndpoint<PCacheStreamControlParent> aEndpoint,
        PCacheStreamControlParent* aActor) -> bool
{
    return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this);
}

auto PBackgroundParent::OpenPClientManagerEndpoint(PClientManagerParent* aActor) -> ManagedEndpoint<PClientManagerChild>
{
    if (!aActor) {
        NS_WARNING("Cannot bind null PClientManagerParent actor");
        return ManagedEndpoint<PClientManagerChild>();
    }

    if (!aActor->SetManagerAndRegister(this)) {
        NS_WARNING("Failed to bind PClientManagerParent actor");
        return ManagedEndpoint<PClientManagerChild>();
    }

    // Mark our actor as awaiting the other side to be bound. This will
    // be cleared when a `MANAGED_ENDPOINT_{DROPPED,BOUND}` message is
    // received.
    aActor->mAwaitingManagedEndpointBind = true;
    return ManagedEndpoint<PClientManagerChild>(mozilla::ipc::PrivateIPDLInterface(), aActor);
}

auto PBackgroundParent::BindPClientManagerEndpoint(
        ManagedEndpoint<PClientManagerParent> aEndpoint,
        PClientManagerParent* aActor) -> bool
{
    return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this);
}

auto PBackgroundParent::OpenPCookieStoreEndpoint(PCookieStoreParent* aActor) -> ManagedEndpoint<PCookieStoreChild>
{
    if (!aActor) {
        NS_WARNING("Cannot bind null PCookieStoreParent actor");
        return ManagedEndpoint<PCookieStoreChild>();
    }

    if (!aActor->SetManagerAndRegister(this)) {
        NS_WARNING("Failed to bind PCookieStoreParent actor");
        return ManagedEndpoint<PCookieStoreChild>();
    }

    // Mark our actor as awaiting the other side to be bound. This will
    // be cleared when a `MANAGED_ENDPOINT_{DROPPED,BOUND}` message is
    // received.
    aActor->mAwaitingManagedEndpointBind = true;
    return ManagedEndpoint<PCookieStoreChild>(mozilla::ipc::PrivateIPDLInterface(), aActor);
}

auto PBackgroundParent::BindPCookieStoreEndpoint(
        ManagedEndpoint<PCookieStoreParent> aEndpoint,
        PCookieStoreParent* aActor) -> bool
{
    return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this);
}

auto PBackgroundParent::OpenPFileSystemRequestEndpoint(PFileSystemRequestParent* aActor) -> ManagedEndpoint<PFileSystemRequestChild>
{
    if (!aActor) {
        NS_WARNING("Cannot bind null PFileSystemRequestParent actor");
        return ManagedEndpoint<PFileSystemRequestChild>();
    }

    if (!aActor->SetManagerAndRegister(this)) {
        NS_WARNING("Failed to bind PFileSystemRequestParent actor");
        return ManagedEndpoint<PFileSystemRequestChild>();
    }

    // Mark our actor as awaiting the other side to be bound. This will
    // be cleared when a `MANAGED_ENDPOINT_{DROPPED,BOUND}` message is
    // received.
    aActor->mAwaitingManagedEndpointBind = true;
    return ManagedEndpoint<PFileSystemRequestChild>(mozilla::ipc::PrivateIPDLInterface(), aActor);
}

auto PBackgroundParent::BindPFileSystemRequestEndpoint(
        ManagedEndpoint<PFileSystemRequestParent> aEndpoint,
        PFileSystemRequestParent* aActor) -> bool
{
    return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this);
}

auto PBackgroundParent::OpenPGamepadEventChannelEndpoint(PGamepadEventChannelParent* aActor) -> ManagedEndpoint<PGamepadEventChannelChild>
{
    if (!aActor) {
        NS_WARNING("Cannot bind null PGamepadEventChannelParent actor");
        return ManagedEndpoint<PGamepadEventChannelChild>();
    }

    if (!aActor->SetManagerAndRegister(this)) {
        NS_WARNING("Failed to bind PGamepadEventChannelParent actor");
        return ManagedEndpoint<PGamepadEventChannelChild>();
    }

    // Mark our actor as awaiting the other side to be bound. This will
    // be cleared when a `MANAGED_ENDPOINT_{DROPPED,BOUND}` message is
    // received.
    aActor->mAwaitingManagedEndpointBind = true;
    return ManagedEndpoint<PGamepadEventChannelChild>(mozilla::ipc::PrivateIPDLInterface(), aActor);
}

auto PBackgroundParent::BindPGamepadEventChannelEndpoint(
        ManagedEndpoint<PGamepadEventChannelParent> aEndpoint,
        PGamepadEventChannelParent* aActor) -> bool
{
    return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this);
}

auto PBackgroundParent::OpenPGamepadTestChannelEndpoint(PGamepadTestChannelParent* aActor) -> ManagedEndpoint<PGamepadTestChannelChild>
{
    if (!aActor) {
        NS_WARNING("Cannot bind null PGamepadTestChannelParent actor");
        return ManagedEndpoint<PGamepadTestChannelChild>();
    }

    if (!aActor->SetManagerAndRegister(this)) {
        NS_WARNING("Failed to bind PGamepadTestChannelParent actor");
        return ManagedEndpoint<PGamepadTestChannelChild>();
    }

    // Mark our actor as awaiting the other side to be bound. This will
    // be cleared when a `MANAGED_ENDPOINT_{DROPPED,BOUND}` message is
    // received.
    aActor->mAwaitingManagedEndpointBind = true;
    return ManagedEndpoint<PGamepadTestChannelChild>(mozilla::ipc::PrivateIPDLInterface(), aActor);
}

auto PBackgroundParent::BindPGamepadTestChannelEndpoint(
        ManagedEndpoint<PGamepadTestChannelParent> aEndpoint,
        PGamepadTestChannelParent* aActor) -> bool
{
    return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this);
}

auto PBackgroundParent::OpenPHttpBackgroundChannelEndpoint(PHttpBackgroundChannelParent* aActor) -> ManagedEndpoint<PHttpBackgroundChannelChild>
{
    if (!aActor) {
        NS_WARNING("Cannot bind null PHttpBackgroundChannelParent actor");
        return ManagedEndpoint<PHttpBackgroundChannelChild>();
    }

    if (!aActor->SetManagerAndRegister(this)) {
        NS_WARNING("Failed to bind PHttpBackgroundChannelParent actor");
        return ManagedEndpoint<PHttpBackgroundChannelChild>();
    }

    // Mark our actor as awaiting the other side to be bound. This will
    // be cleared when a `MANAGED_ENDPOINT_{DROPPED,BOUND}` message is
    // received.
    aActor->mAwaitingManagedEndpointBind = true;
    return ManagedEndpoint<PHttpBackgroundChannelChild>(mozilla::ipc::PrivateIPDLInterface(), aActor);
}

auto PBackgroundParent::BindPHttpBackgroundChannelEndpoint(
        ManagedEndpoint<PHttpBackgroundChannelParent> aEndpoint,
        PHttpBackgroundChannelParent* aActor) -> bool
{
    return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this);
}

auto PBackgroundParent::OpenPIdleSchedulerEndpoint(PIdleSchedulerParent* aActor) -> ManagedEndpoint<PIdleSchedulerChild>
{
    if (!aActor) {
        NS_WARNING("Cannot bind null PIdleSchedulerParent actor");
        return ManagedEndpoint<PIdleSchedulerChild>();
    }

    if (!aActor->SetManagerAndRegister(this)) {
        NS_WARNING("Failed to bind PIdleSchedulerParent actor");
        return ManagedEndpoint<PIdleSchedulerChild>();
    }

    // Mark our actor as awaiting the other side to be bound. This will
    // be cleared when a `MANAGED_ENDPOINT_{DROPPED,BOUND}` message is
    // received.
    aActor->mAwaitingManagedEndpointBind = true;
    return ManagedEndpoint<PIdleSchedulerChild>(mozilla::ipc::PrivateIPDLInterface(), aActor);
}

auto PBackgroundParent::BindPIdleSchedulerEndpoint(
        ManagedEndpoint<PIdleSchedulerParent> aEndpoint,
        PIdleSchedulerParent* aActor) -> bool
{
    return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this);
}

auto PBackgroundParent::OpenPLockManagerEndpoint(PLockManagerParent* aActor) -> ManagedEndpoint<PLockManagerChild>
{
    if (!aActor) {
        NS_WARNING("Cannot bind null PLockManagerParent actor");
        return ManagedEndpoint<PLockManagerChild>();
    }

    if (!aActor->SetManagerAndRegister(this)) {
        NS_WARNING("Failed to bind PLockManagerParent actor");
        return ManagedEndpoint<PLockManagerChild>();
    }

    // Mark our actor as awaiting the other side to be bound. This will
    // be cleared when a `MANAGED_ENDPOINT_{DROPPED,BOUND}` message is
    // received.
    aActor->mAwaitingManagedEndpointBind = true;
    return ManagedEndpoint<PLockManagerChild>(mozilla::ipc::PrivateIPDLInterface(), aActor);
}

auto PBackgroundParent::BindPLockManagerEndpoint(
        ManagedEndpoint<PLockManagerParent> aEndpoint,
        PLockManagerParent* aActor) -> bool
{
    return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this);
}

auto PBackgroundParent::OpenPRemoteWorkerControllerEndpoint(PRemoteWorkerControllerParent* aActor) -> ManagedEndpoint<PRemoteWorkerControllerChild>
{
    if (!aActor) {
        NS_WARNING("Cannot bind null PRemoteWorkerControllerParent actor");
        return ManagedEndpoint<PRemoteWorkerControllerChild>();
    }

    if (!aActor->SetManagerAndRegister(this)) {
        NS_WARNING("Failed to bind PRemoteWorkerControllerParent actor");
        return ManagedEndpoint<PRemoteWorkerControllerChild>();
    }

    // Mark our actor as awaiting the other side to be bound. This will
    // be cleared when a `MANAGED_ENDPOINT_{DROPPED,BOUND}` message is
    // received.
    aActor->mAwaitingManagedEndpointBind = true;
    return ManagedEndpoint<PRemoteWorkerControllerChild>(mozilla::ipc::PrivateIPDLInterface(), aActor);
}

auto PBackgroundParent::BindPRemoteWorkerControllerEndpoint(
        ManagedEndpoint<PRemoteWorkerControllerParent> aEndpoint,
        PRemoteWorkerControllerParent* aActor) -> bool
{
    return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this);
}

auto PBackgroundParent::OpenPSharedWorkerEndpoint(PSharedWorkerParent* aActor) -> ManagedEndpoint<PSharedWorkerChild>
{
    if (!aActor) {
        NS_WARNING("Cannot bind null PSharedWorkerParent actor");
        return ManagedEndpoint<PSharedWorkerChild>();
    }

    if (!aActor->SetManagerAndRegister(this)) {
        NS_WARNING("Failed to bind PSharedWorkerParent actor");
        return ManagedEndpoint<PSharedWorkerChild>();
    }

    // Mark our actor as awaiting the other side to be bound. This will
    // be cleared when a `MANAGED_ENDPOINT_{DROPPED,BOUND}` message is
    // received.
    aActor->mAwaitingManagedEndpointBind = true;
    return ManagedEndpoint<PSharedWorkerChild>(mozilla::ipc::PrivateIPDLInterface(), aActor);
}

auto PBackgroundParent::BindPSharedWorkerEndpoint(
        ManagedEndpoint<PSharedWorkerParent> aEndpoint,
        PSharedWorkerParent* aActor) -> bool
{
    return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this);
}

auto PBackgroundParent::OpenPTemporaryIPCBlobEndpoint(PTemporaryIPCBlobParent* aActor) -> ManagedEndpoint<PTemporaryIPCBlobChild>
{
    if (!aActor) {
        NS_WARNING("Cannot bind null PTemporaryIPCBlobParent actor");
        return ManagedEndpoint<PTemporaryIPCBlobChild>();
    }

    if (!aActor->SetManagerAndRegister(this)) {
        NS_WARNING("Failed to bind PTemporaryIPCBlobParent actor");
        return ManagedEndpoint<PTemporaryIPCBlobChild>();
    }

    // Mark our actor as awaiting the other side to be bound. This will
    // be cleared when a `MANAGED_ENDPOINT_{DROPPED,BOUND}` message is
    // received.
    aActor->mAwaitingManagedEndpointBind = true;
    return ManagedEndpoint<PTemporaryIPCBlobChild>(mozilla::ipc::PrivateIPDLInterface(), aActor);
}

auto PBackgroundParent::BindPTemporaryIPCBlobEndpoint(
        ManagedEndpoint<PTemporaryIPCBlobParent> aEndpoint,
        PTemporaryIPCBlobParent* aActor) -> bool
{
    return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this);
}

auto PBackgroundParent::OpenPFileCreatorEndpoint(PFileCreatorParent* aActor) -> ManagedEndpoint<PFileCreatorChild>
{
    if (!aActor) {
        NS_WARNING("Cannot bind null PFileCreatorParent actor");
        return ManagedEndpoint<PFileCreatorChild>();
    }

    if (!aActor->SetManagerAndRegister(this)) {
        NS_WARNING("Failed to bind PFileCreatorParent actor");
        return ManagedEndpoint<PFileCreatorChild>();
    }

    // Mark our actor as awaiting the other side to be bound. This will
    // be cleared when a `MANAGED_ENDPOINT_{DROPPED,BOUND}` message is
    // received.
    aActor->mAwaitingManagedEndpointBind = true;
    return ManagedEndpoint<PFileCreatorChild>(mozilla::ipc::PrivateIPDLInterface(), aActor);
}

auto PBackgroundParent::BindPFileCreatorEndpoint(
        ManagedEndpoint<PFileCreatorParent> aEndpoint,
        PFileCreatorParent* aActor) -> bool
{
    return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this);
}

auto PBackgroundParent::OpenPMessagePortEndpoint(PMessagePortParent* aActor) -> ManagedEndpoint<PMessagePortChild>
{
    if (!aActor) {
        NS_WARNING("Cannot bind null PMessagePortParent actor");
        return ManagedEndpoint<PMessagePortChild>();
    }

    if (!aActor->SetManagerAndRegister(this)) {
        NS_WARNING("Failed to bind PMessagePortParent actor");
        return ManagedEndpoint<PMessagePortChild>();
    }

    // Mark our actor as awaiting the other side to be bound. This will
    // be cleared when a `MANAGED_ENDPOINT_{DROPPED,BOUND}` message is
    // received.
    aActor->mAwaitingManagedEndpointBind = true;
    return ManagedEndpoint<PMessagePortChild>(mozilla::ipc::PrivateIPDLInterface(), aActor);
}

auto PBackgroundParent::BindPMessagePortEndpoint(
        ManagedEndpoint<PMessagePortParent> aEndpoint,
        PMessagePortParent* aActor) -> bool
{
    return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this);
}

auto PBackgroundParent::OpenPCamerasEndpoint(PCamerasParent* aActor) -> ManagedEndpoint<PCamerasChild>
{
    if (!aActor) {
        NS_WARNING("Cannot bind null PCamerasParent actor");
        return ManagedEndpoint<PCamerasChild>();
    }

    if (!aActor->SetManagerAndRegister(this)) {
        NS_WARNING("Failed to bind PCamerasParent actor");
        return ManagedEndpoint<PCamerasChild>();
    }

    // Mark our actor as awaiting the other side to be bound. This will
    // be cleared when a `MANAGED_ENDPOINT_{DROPPED,BOUND}` message is
    // received.
    aActor->mAwaitingManagedEndpointBind = true;
    return ManagedEndpoint<PCamerasChild>(mozilla::ipc::PrivateIPDLInterface(), aActor);
}

auto PBackgroundParent::BindPCamerasEndpoint(
        ManagedEndpoint<PCamerasParent> aEndpoint,
        PCamerasParent* aActor) -> bool
{
    return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this);
}

auto PBackgroundParent::OpenPQuotaEndpoint(PQuotaParent* aActor) -> ManagedEndpoint<PQuotaChild>
{
    if (!aActor) {
        NS_WARNING("Cannot bind null PQuotaParent actor");
        return ManagedEndpoint<PQuotaChild>();
    }

    if (!aActor->SetManagerAndRegister(this)) {
        NS_WARNING("Failed to bind PQuotaParent actor");
        return ManagedEndpoint<PQuotaChild>();
    }

    // Mark our actor as awaiting the other side to be bound. This will
    // be cleared when a `MANAGED_ENDPOINT_{DROPPED,BOUND}` message is
    // received.
    aActor->mAwaitingManagedEndpointBind = true;
    return ManagedEndpoint<PQuotaChild>(mozilla::ipc::PrivateIPDLInterface(), aActor);
}

auto PBackgroundParent::BindPQuotaEndpoint(
        ManagedEndpoint<PQuotaParent> aEndpoint,
        PQuotaParent* aActor) -> bool
{
    return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this);
}

auto PBackgroundParent::OpenPServiceWorkerEndpoint(PServiceWorkerParent* aActor) -> ManagedEndpoint<PServiceWorkerChild>
{
    if (!aActor) {
        NS_WARNING("Cannot bind null PServiceWorkerParent actor");
        return ManagedEndpoint<PServiceWorkerChild>();
    }

    if (!aActor->SetManagerAndRegister(this)) {
        NS_WARNING("Failed to bind PServiceWorkerParent actor");
        return ManagedEndpoint<PServiceWorkerChild>();
    }

    // Mark our actor as awaiting the other side to be bound. This will
    // be cleared when a `MANAGED_ENDPOINT_{DROPPED,BOUND}` message is
    // received.
    aActor->mAwaitingManagedEndpointBind = true;
    return ManagedEndpoint<PServiceWorkerChild>(mozilla::ipc::PrivateIPDLInterface(), aActor);
}

auto PBackgroundParent::BindPServiceWorkerEndpoint(
        ManagedEndpoint<PServiceWorkerParent> aEndpoint,
        PServiceWorkerParent* aActor) -> bool
{
    return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this);
}

auto PBackgroundParent::OpenPServiceWorkerContainerEndpoint(PServiceWorkerContainerParent* aActor) -> ManagedEndpoint<PServiceWorkerContainerChild>
{
    if (!aActor) {
        NS_WARNING("Cannot bind null PServiceWorkerContainerParent actor");
        return ManagedEndpoint<PServiceWorkerContainerChild>();
    }

    if (!aActor->SetManagerAndRegister(this)) {
        NS_WARNING("Failed to bind PServiceWorkerContainerParent actor");
        return ManagedEndpoint<PServiceWorkerContainerChild>();
    }

    // Mark our actor as awaiting the other side to be bound. This will
    // be cleared when a `MANAGED_ENDPOINT_{DROPPED,BOUND}` message is
    // received.
    aActor->mAwaitingManagedEndpointBind = true;
    return ManagedEndpoint<PServiceWorkerContainerChild>(mozilla::ipc::PrivateIPDLInterface(), aActor);
}

auto PBackgroundParent::BindPServiceWorkerContainerEndpoint(
        ManagedEndpoint<PServiceWorkerContainerParent> aEndpoint,
        PServiceWorkerContainerParent* aActor) -> bool
{
    return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this);
}

auto PBackgroundParent::OpenPServiceWorkerManagerEndpoint(PServiceWorkerManagerParent* aActor) -> ManagedEndpoint<PServiceWorkerManagerChild>
{
    if (!aActor) {
        NS_WARNING("Cannot bind null PServiceWorkerManagerParent actor");
        return ManagedEndpoint<PServiceWorkerManagerChild>();
    }

    if (!aActor->SetManagerAndRegister(this)) {
        NS_WARNING("Failed to bind PServiceWorkerManagerParent actor");
        return ManagedEndpoint<PServiceWorkerManagerChild>();
    }

    // Mark our actor as awaiting the other side to be bound. This will
    // be cleared when a `MANAGED_ENDPOINT_{DROPPED,BOUND}` message is
    // received.
    aActor->mAwaitingManagedEndpointBind = true;
    return ManagedEndpoint<PServiceWorkerManagerChild>(mozilla::ipc::PrivateIPDLInterface(), aActor);
}

auto PBackgroundParent::BindPServiceWorkerManagerEndpoint(
        ManagedEndpoint<PServiceWorkerManagerParent> aEndpoint,
        PServiceWorkerManagerParent* aActor) -> bool
{
    return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this);
}

auto PBackgroundParent::OpenPServiceWorkerRegistrationEndpoint(PServiceWorkerRegistrationParent* aActor) -> ManagedEndpoint<PServiceWorkerRegistrationChild>
{
    if (!aActor) {
        NS_WARNING("Cannot bind null PServiceWorkerRegistrationParent actor");
        return ManagedEndpoint<PServiceWorkerRegistrationChild>();
    }

    if (!aActor->SetManagerAndRegister(this)) {
        NS_WARNING("Failed to bind PServiceWorkerRegistrationParent actor");
        return ManagedEndpoint<PServiceWorkerRegistrationChild>();
    }

    // Mark our actor as awaiting the other side to be bound. This will
    // be cleared when a `MANAGED_ENDPOINT_{DROPPED,BOUND}` message is
    // received.
    aActor->mAwaitingManagedEndpointBind = true;
    return ManagedEndpoint<PServiceWorkerRegistrationChild>(mozilla::ipc::PrivateIPDLInterface(), aActor);
}

auto PBackgroundParent::BindPServiceWorkerRegistrationEndpoint(
        ManagedEndpoint<PServiceWorkerRegistrationParent> aEndpoint,
        PServiceWorkerRegistrationParent* aActor) -> bool
{
    return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this);
}

auto PBackgroundParent::OpenPUDPSocketEndpoint(PUDPSocketParent* aActor) -> ManagedEndpoint<PUDPSocketChild>
{
    if (!aActor) {
        NS_WARNING("Cannot bind null PUDPSocketParent actor");
        return ManagedEndpoint<PUDPSocketChild>();
    }

    if (!aActor->SetManagerAndRegister(this)) {
        NS_WARNING("Failed to bind PUDPSocketParent actor");
        return ManagedEndpoint<PUDPSocketChild>();
    }

    // Mark our actor as awaiting the other side to be bound. This will
    // be cleared when a `MANAGED_ENDPOINT_{DROPPED,BOUND}` message is
    // received.
    aActor->mAwaitingManagedEndpointBind = true;
    return ManagedEndpoint<PUDPSocketChild>(mozilla::ipc::PrivateIPDLInterface(), aActor);
}

auto PBackgroundParent::BindPUDPSocketEndpoint(
        ManagedEndpoint<PUDPSocketParent> aEndpoint,
        PUDPSocketParent* aActor) -> bool
{
    return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this);
}

auto PBackgroundParent::OpenPVsyncEndpoint(PVsyncParent* aActor) -> ManagedEndpoint<PVsyncChild>
{
    if (!aActor) {
        NS_WARNING("Cannot bind null PVsyncParent actor");
        return ManagedEndpoint<PVsyncChild>();
    }

    if (!aActor->SetManagerAndRegister(this)) {
        NS_WARNING("Failed to bind PVsyncParent actor");
        return ManagedEndpoint<PVsyncChild>();
    }

    // Mark our actor as awaiting the other side to be bound. This will
    // be cleared when a `MANAGED_ENDPOINT_{DROPPED,BOUND}` message is
    // received.
    aActor->mAwaitingManagedEndpointBind = true;
    return ManagedEndpoint<PVsyncChild>(mozilla::ipc::PrivateIPDLInterface(), aActor);
}

auto PBackgroundParent::BindPVsyncEndpoint(
        ManagedEndpoint<PVsyncParent> aEndpoint,
        PVsyncParent* aActor) -> bool
{
    return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this);
}

auto PBackgroundParent::OpenPFetchEndpoint(PFetchParent* aActor) -> ManagedEndpoint<PFetchChild>
{
    if (!aActor) {
        NS_WARNING("Cannot bind null PFetchParent actor");
        return ManagedEndpoint<PFetchChild>();
    }

    if (!aActor->SetManagerAndRegister(this)) {
        NS_WARNING("Failed to bind PFetchParent actor");
        return ManagedEndpoint<PFetchChild>();
    }

    // Mark our actor as awaiting the other side to be bound. This will
    // be cleared when a `MANAGED_ENDPOINT_{DROPPED,BOUND}` message is
    // received.
    aActor->mAwaitingManagedEndpointBind = true;
    return ManagedEndpoint<PFetchChild>(mozilla::ipc::PrivateIPDLInterface(), aActor);
}

auto PBackgroundParent::BindPFetchEndpoint(
        ManagedEndpoint<PFetchParent> aEndpoint,
        PFetchParent* aActor) -> bool
{
    return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this);
}

auto PBackgroundParent::SendPCacheConstructor(PCacheParent* actor) -> PCacheParent*
{
    if (!actor) {
        NS_WARNING("Cannot bind null PCacheParent actor");
        return nullptr;
    }

    if (!actor->SetManagerAndRegister(this)) {
        NS_WARNING("Failed to bind PCacheParent actor");
        return nullptr;
    }


    // Build our constructor message.
    UniquePtr<IPC::Message> msg__ = PBackground::Msg_PCacheConstructor(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), (actor)->Id());
    // Sentinel = 'actorid'
    ((&(writer__)))->WriteSentinel(193725159);


    // Notify the other side about the newly created actor. This can
    // fail if our manager has already been destroyed.
    //
    // NOTE: If the send call fails due to toplevel channel teardown,
    // the `IProtocol::ChannelSend` wrapper absorbs the error for us,
    // so we don't tear down actors unexpectedly.

    if (mozilla::ipc::LoggingEnabledFor("PBackground", mozilla::ipc::ParentSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PBackgroundParent",
            this->ToplevelProtocol()->OtherPidMaybeInvalid(),
            "Sending ",
            msg__->type(),
            mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PBackground::Msg_PCacheConstructor", OTHER);

    bool sendok__ = ChannelSend(std::move(msg__));


    // Warn, destroy the actor, and return null if the message failed to
    // send. Otherwise, return the successfully created actor reference.
    if (!sendok__) {
        NS_WARNING("Error sending PCacheParent constructor");
        actor->ActorDisconnected(FailedConstructor);

        return nullptr;
    }
    return actor;
}

auto PBackgroundParent::SendPCacheStreamControlConstructor(PCacheStreamControlParent* actor) -> PCacheStreamControlParent*
{
    if (!actor) {
        NS_WARNING("Cannot bind null PCacheStreamControlParent actor");
        return nullptr;
    }

    if (!actor->SetManagerAndRegister(this)) {
        NS_WARNING("Failed to bind PCacheStreamControlParent actor");
        return nullptr;
    }


    // Build our constructor message.
    UniquePtr<IPC::Message> msg__ = PBackground::Msg_PCacheStreamControlConstructor(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), (actor)->Id());
    // Sentinel = 'actorid'
    ((&(writer__)))->WriteSentinel(193725159);


    // Notify the other side about the newly created actor. This can
    // fail if our manager has already been destroyed.
    //
    // NOTE: If the send call fails due to toplevel channel teardown,
    // the `IProtocol::ChannelSend` wrapper absorbs the error for us,
    // so we don't tear down actors unexpectedly.

    if (mozilla::ipc::LoggingEnabledFor("PBackground", mozilla::ipc::ParentSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PBackgroundParent",
            this->ToplevelProtocol()->OtherPidMaybeInvalid(),
            "Sending ",
            msg__->type(),
            mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PBackground::Msg_PCacheStreamControlConstructor", OTHER);

    bool sendok__ = ChannelSend(std::move(msg__));


    // Warn, destroy the actor, and return null if the message failed to
    // send. Otherwise, return the successfully created actor reference.
    if (!sendok__) {
        NS_WARNING("Error sending PCacheStreamControlParent constructor");
        actor->ActorDisconnected(FailedConstructor);

        return nullptr;
    }
    return actor;
}

auto PBackgroundParent::DeallocManagee(
        mozilla::ipc::ProtocolId aProtocolId,
        IProtocol* aListener) -> void
{
    switch (aProtocolId) {
    case PBackgroundIndexedDBUtilsMsgStart:
        this->DeallocPBackgroundIndexedDBUtilsParent(static_cast<PBackgroundIndexedDBUtilsParent*>(aListener));
        return;
    case PBackgroundLSObserverMsgStart:
        this->DeallocPBackgroundLSObserverParent(static_cast<PBackgroundLSObserverParent*>(aListener));
        return;
    case PBackgroundLSRequestMsgStart:
        this->DeallocPBackgroundLSRequestParent(static_cast<PBackgroundLSRequestParent*>(aListener));
        return;
    case PBackgroundLSSimpleRequestMsgStart:
        this->DeallocPBackgroundLSSimpleRequestParent(static_cast<PBackgroundLSSimpleRequestParent*>(aListener));
        return;
    case PBackgroundLocalStorageCacheMsgStart:
        this->DeallocPBackgroundLocalStorageCacheParent(static_cast<PBackgroundLocalStorageCacheParent*>(aListener));
        return;
    case PBackgroundStorageMsgStart:
        this->DeallocPBackgroundStorageParent(static_cast<PBackgroundStorageParent*>(aListener));
        return;
    case PBackgroundTestMsgStart:
        this->DeallocPBackgroundTestParent(static_cast<PBackgroundTestParent*>(aListener));
        return;
    case PBroadcastChannelMsgStart:
        this->DeallocPBroadcastChannelParent(static_cast<PBroadcastChannelParent*>(aListener));
        return;
    case PCookieStoreMsgStart:
        this->DeallocPCookieStoreParent(static_cast<PCookieStoreParent*>(aListener));
        return;
    case PSharedWorkerMsgStart:
        this->DeallocPSharedWorkerParent(static_cast<PSharedWorkerParent*>(aListener));
        return;
    case PTemporaryIPCBlobMsgStart:
        this->DeallocPTemporaryIPCBlobParent(static_cast<PTemporaryIPCBlobParent*>(aListener));
        return;
    case PFileCreatorMsgStart:
        this->DeallocPFileCreatorParent(static_cast<PFileCreatorParent*>(aListener));
        return;
    case PCamerasMsgStart:
        this->DeallocPCamerasParent(static_cast<PCamerasParent*>(aListener));
        return;
    case PServiceWorkerManagerMsgStart:
        this->DeallocPServiceWorkerManagerParent(static_cast<PServiceWorkerManagerParent*>(aListener));
        return;
    default:
        FatalError("unreached");
        return;
    }
}

auto PBackgroundParent::OnMessageReceived(const Message& msg__) -> PBackgroundParent::Result
{
    if (!CanSend()) {
        if (mozilla::ipc::LoggingEnabledFor("PBackground", mozilla::ipc::ParentSide)) {
            mozilla::ipc::LogMessageForProtocol(
                "PBackgroundParent",
                this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                "Ignored message for dead actor",
                (&(msg__))->type(),
                mozilla::ipc::MessageDirection::eSending);
        }
        return MsgProcessed;

    }
    IPC::Message::routeid_t route__ = msg__.routing_id();
    if (MSG_ROUTING_CONTROL != route__) {
        IProtocol* routed__ = Lookup(route__);
        if (!routed__ || !routed__->GetLifecycleProxy()) {
            if (mozilla::ipc::LoggingEnabledFor("PBackground", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBackgroundParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Ignored message for dead actor",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eSending);
            }
            return MsgProcessed;

        }

        RefPtr<mozilla::ipc::ActorLifecycleProxy> proxy__ =
            routed__->GetLifecycleProxy();
        return proxy__->Get()->OnMessageReceived(msg__);
    }

    switch (msg__.type()) {
    case PBackground::Msg_PBackgroundTestConstructor__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBackground", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBackgroundParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBackground::Msg_PBackgroundTestConstructor", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

            auto maybe__actorid__ = IPC::ReadParam<mozilla::ipc::ActorId>((&(reader__)));
            if (!maybe__actorid__) {
                FatalError("Error deserializing 'mozilla::ipc::ActorId'");
                return MsgValueError;

            }
            auto& actorid__ = *maybe__actorid__;
            // Sentinel = 'actorid'
            if ((!(((&(reader__)))->ReadSentinel(193725159)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'mozilla::ipc::ActorId'");
                return MsgValueError;
            }
            auto maybe__testArg = IPC::ReadParam<nsCString>((&(reader__)));
            if (!maybe__testArg) {
                FatalError("Error deserializing 'nsCString'");
                return MsgValueError;

            }
            auto& testArg = *maybe__testArg;
            // Sentinel = 'testArg'
            if ((!(((&(reader__)))->ReadSentinel(195953371)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsCString'");
                return MsgValueError;
            }
            reader__.EndRead();
            // Ensure the ID which was sent to us is valid, and reserve a spot
            // in the table for the new actor before we bother to alloc it.
            if (!ToplevelProtocol()->TryReserve(actorid__)) {
                NS_WARNING("Failed to reserve ActorId for constructor");
                return MsgValueError;
            }

            PBackgroundTestParent* actor = (this)->AllocPBackgroundTestParent(testArg);

            if (!actor) {
                NS_WARNING("Alloc function returned null");
                // Clean up the reservation taken above if this fails, to avoid
                // leaving zombie entries in the map.
                ToplevelProtocol()->ClearReservation(actorid__);
                return MsgValueError;
            }

            // NOTE: SetManagerAndRegister unconditionally consumes the
            // reservation taken by TryReserve, so we don't need to clear it on
            // failure.
            if (!actor->SetManagerAndRegister(this, actorid__)) {
                NS_WARNING("Failed to set manager for constructor");
                return MsgValueError;
            }
            mozilla::ipc::IPCResult __ok = (this)->RecvPBackgroundTestConstructor(std::move(actor), std::move(testArg));
            if ((!(__ok))) {
                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("PBackground", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBackgroundParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBackground::Msg_PBackgroundIDBFactoryConstructor", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

            auto maybe__actorid__ = IPC::ReadParam<mozilla::ipc::ActorId>((&(reader__)));
            if (!maybe__actorid__) {
                FatalError("Error deserializing 'mozilla::ipc::ActorId'");
                return MsgValueError;

            }
            auto& actorid__ = *maybe__actorid__;
            // Sentinel = 'actorid'
            if ((!(((&(reader__)))->ReadSentinel(193725159)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'mozilla::ipc::ActorId'");
                return MsgValueError;
            }
            auto maybe__loggingInfo = IPC::ReadParam<LoggingInfo>((&(reader__)));
            if (!maybe__loggingInfo) {
                FatalError("Error deserializing 'LoggingInfo'");
                return MsgValueError;

            }
            auto& loggingInfo = *maybe__loggingInfo;
            // Sentinel = 'loggingInfo'
            if ((!(((&(reader__)))->ReadSentinel(452658292)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'LoggingInfo'");
                return MsgValueError;
            }
            auto maybe__systemLocale = IPC::ReadParam<nsCString>((&(reader__)));
            if (!maybe__systemLocale) {
                FatalError("Error deserializing 'nsCString'");
                return MsgValueError;

            }
            auto& systemLocale = *maybe__systemLocale;
            // Sentinel = 'systemLocale'
            if ((!(((&(reader__)))->ReadSentinel(557253878)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsCString'");
                return MsgValueError;
            }
            reader__.EndRead();
            // Ensure the ID which was sent to us is valid, and reserve a spot
            // in the table for the new actor before we bother to alloc it.
            if (!ToplevelProtocol()->TryReserve(actorid__)) {
                NS_WARNING("Failed to reserve ActorId for constructor");
                return MsgValueError;
            }

            RefPtr<PBackgroundIDBFactoryParent> actor = (this)->AllocPBackgroundIDBFactoryParent(loggingInfo, systemLocale);

            if (!actor) {
                NS_WARNING("Alloc function returned null");
                // Clean up the reservation taken above if this fails, to avoid
                // leaving zombie entries in the map.
                ToplevelProtocol()->ClearReservation(actorid__);
                return MsgValueError;
            }

            // NOTE: SetManagerAndRegister unconditionally consumes the
            // reservation taken by TryReserve, so we don't need to clear it on
            // failure.
            if (!actor->SetManagerAndRegister(this, actorid__)) {
                NS_WARNING("Failed to set manager for constructor");
                return MsgValueError;
            }
            mozilla::ipc::IPCResult __ok = (this)->RecvPBackgroundIDBFactoryConstructor(actor, std::move(loggingInfo), std::move(systemLocale));
            if ((!(__ok))) {
                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("PBackground", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBackgroundParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBackground::Msg_PBackgroundIndexedDBUtilsConstructor", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

            auto maybe__actorid__ = IPC::ReadParam<mozilla::ipc::ActorId>((&(reader__)));
            if (!maybe__actorid__) {
                FatalError("Error deserializing 'mozilla::ipc::ActorId'");
                return MsgValueError;

            }
            auto& actorid__ = *maybe__actorid__;
            // Sentinel = 'actorid'
            if ((!(((&(reader__)))->ReadSentinel(193725159)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'mozilla::ipc::ActorId'");
                return MsgValueError;
            }
            reader__.EndRead();
            // Ensure the ID which was sent to us is valid, and reserve a spot
            // in the table for the new actor before we bother to alloc it.
            if (!ToplevelProtocol()->TryReserve(actorid__)) {
                NS_WARNING("Failed to reserve ActorId for constructor");
                return MsgValueError;
            }

            PBackgroundIndexedDBUtilsParent* actor = (this)->AllocPBackgroundIndexedDBUtilsParent();

            if (!actor) {
                NS_WARNING("Alloc function returned null");
                // Clean up the reservation taken above if this fails, to avoid
                // leaving zombie entries in the map.
                ToplevelProtocol()->ClearReservation(actorid__);
                return MsgValueError;
            }

            // NOTE: SetManagerAndRegister unconditionally consumes the
            // reservation taken by TryReserve, so we don't need to clear it on
            // failure.
            if (!actor->SetManagerAndRegister(this, actorid__)) {
                NS_WARNING("Failed to set manager for constructor");
                return MsgValueError;
            }
            mozilla::ipc::IPCResult __ok = (this)->RecvPBackgroundIndexedDBUtilsConstructor(std::move(actor));
            if ((!(__ok))) {
                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("PBackground", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBackgroundParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBackground::Msg_FlushPendingFileDeletions", OTHER);

            mozilla::ipc::IPCResult __ok = (this)->RecvFlushPendingFileDeletions();
            if ((!(__ok))) {
                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("PBackground", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBackgroundParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBackground::Msg_PBackgroundSDBConnectionConstructor", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

            auto maybe__actorid__ = IPC::ReadParam<mozilla::ipc::ActorId>((&(reader__)));
            if (!maybe__actorid__) {
                FatalError("Error deserializing 'mozilla::ipc::ActorId'");
                return MsgValueError;

            }
            auto& actorid__ = *maybe__actorid__;
            // Sentinel = 'actorid'
            if ((!(((&(reader__)))->ReadSentinel(193725159)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'mozilla::ipc::ActorId'");
                return MsgValueError;
            }
            auto maybe__persistenceType = IPC::ReadParam<PersistenceType>((&(reader__)));
            if (!maybe__persistenceType) {
                FatalError("Error deserializing 'PersistenceType'");
                return MsgValueError;

            }
            auto& persistenceType = *maybe__persistenceType;
            // Sentinel = 'persistenceType'
            if ((!(((&(reader__)))->ReadSentinel(853345864)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'PersistenceType'");
                return MsgValueError;
            }
            auto maybe__principalInfo = IPC::ReadParam<PrincipalInfo>((&(reader__)));
            if (!maybe__principalInfo) {
                FatalError("Error deserializing 'PrincipalInfo'");
                return MsgValueError;

            }
            auto& principalInfo = *maybe__principalInfo;
            // Sentinel = 'principalInfo'
            if ((!(((&(reader__)))->ReadSentinel(633472335)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'PrincipalInfo'");
                return MsgValueError;
            }
            reader__.EndRead();
            // Ensure the ID which was sent to us is valid, and reserve a spot
            // in the table for the new actor before we bother to alloc it.
            if (!ToplevelProtocol()->TryReserve(actorid__)) {
                NS_WARNING("Failed to reserve ActorId for constructor");
                return MsgValueError;
            }

            RefPtr<PBackgroundSDBConnectionParent> actor = (this)->AllocPBackgroundSDBConnectionParent(persistenceType, principalInfo);

            if (!actor) {
                NS_WARNING("Alloc function returned null");
                // Clean up the reservation taken above if this fails, to avoid
                // leaving zombie entries in the map.
                ToplevelProtocol()->ClearReservation(actorid__);
                return MsgValueError;
            }

            // NOTE: SetManagerAndRegister unconditionally consumes the
            // reservation taken by TryReserve, so we don't need to clear it on
            // failure.
            if (!actor->SetManagerAndRegister(this, actorid__)) {
                NS_WARNING("Failed to set manager for constructor");
                return MsgValueError;
            }
            mozilla::ipc::IPCResult __ok = (this)->RecvPBackgroundSDBConnectionConstructor(actor, std::move(persistenceType), std::move(principalInfo));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PBackground::Msg_PBackgroundLSObserverConstructor__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBackground", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBackgroundParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBackground::Msg_PBackgroundLSObserverConstructor", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

            auto maybe__actorid__ = IPC::ReadParam<mozilla::ipc::ActorId>((&(reader__)));
            if (!maybe__actorid__) {
                FatalError("Error deserializing 'mozilla::ipc::ActorId'");
                return MsgValueError;

            }
            auto& actorid__ = *maybe__actorid__;
            // Sentinel = 'actorid'
            if ((!(((&(reader__)))->ReadSentinel(193725159)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'mozilla::ipc::ActorId'");
                return MsgValueError;
            }
            auto maybe__observerId = IPC::ReadParam<uint64_t>((&(reader__)));
            if (!maybe__observerId) {
                FatalError("Error deserializing 'uint64_t'");
                return MsgValueError;

            }
            auto& observerId = *maybe__observerId;
            // Sentinel = 'observerId'
            if ((!(((&(reader__)))->ReadSentinel(386335766)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
                return MsgValueError;
            }
            reader__.EndRead();
            // Ensure the ID which was sent to us is valid, and reserve a spot
            // in the table for the new actor before we bother to alloc it.
            if (!ToplevelProtocol()->TryReserve(actorid__)) {
                NS_WARNING("Failed to reserve ActorId for constructor");
                return MsgValueError;
            }

            PBackgroundLSObserverParent* actor = (this)->AllocPBackgroundLSObserverParent(observerId);

            if (!actor) {
                NS_WARNING("Alloc function returned null");
                // Clean up the reservation taken above if this fails, to avoid
                // leaving zombie entries in the map.
                ToplevelProtocol()->ClearReservation(actorid__);
                return MsgValueError;
            }

            // NOTE: SetManagerAndRegister unconditionally consumes the
            // reservation taken by TryReserve, so we don't need to clear it on
            // failure.
            if (!actor->SetManagerAndRegister(this, actorid__)) {
                NS_WARNING("Failed to set manager for constructor");
                return MsgValueError;
            }
            mozilla::ipc::IPCResult __ok = (this)->RecvPBackgroundLSObserverConstructor(std::move(actor), std::move(observerId));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PBackground::Msg_PBackgroundLSRequestConstructor__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBackground", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBackgroundParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBackground::Msg_PBackgroundLSRequestConstructor", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

            auto maybe__actorid__ = IPC::ReadParam<mozilla::ipc::ActorId>((&(reader__)));
            if (!maybe__actorid__) {
                FatalError("Error deserializing 'mozilla::ipc::ActorId'");
                return MsgValueError;

            }
            auto& actorid__ = *maybe__actorid__;
            // Sentinel = 'actorid'
            if ((!(((&(reader__)))->ReadSentinel(193725159)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'mozilla::ipc::ActorId'");
                return MsgValueError;
            }
            auto maybe__params = IPC::ReadParam<LSRequestParams>((&(reader__)));
            if (!maybe__params) {
                FatalError("Error deserializing 'LSRequestParams'");
                return MsgValueError;

            }
            auto& params = *maybe__params;
            // Sentinel = 'params'
            if ((!(((&(reader__)))->ReadSentinel(146997893)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'LSRequestParams'");
                return MsgValueError;
            }
            reader__.EndRead();
            // Ensure the ID which was sent to us is valid, and reserve a spot
            // in the table for the new actor before we bother to alloc it.
            if (!ToplevelProtocol()->TryReserve(actorid__)) {
                NS_WARNING("Failed to reserve ActorId for constructor");
                return MsgValueError;
            }

            PBackgroundLSRequestParent* actor = (this)->AllocPBackgroundLSRequestParent(params);

            if (!actor) {
                NS_WARNING("Alloc function returned null");
                // Clean up the reservation taken above if this fails, to avoid
                // leaving zombie entries in the map.
                ToplevelProtocol()->ClearReservation(actorid__);
                return MsgValueError;
            }

            // NOTE: SetManagerAndRegister unconditionally consumes the
            // reservation taken by TryReserve, so we don't need to clear it on
            // failure.
            if (!actor->SetManagerAndRegister(this, actorid__)) {
                NS_WARNING("Failed to set manager for constructor");
                return MsgValueError;
            }
            mozilla::ipc::IPCResult __ok = (this)->RecvPBackgroundLSRequestConstructor(std::move(actor), std::move(params));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PBackground::Msg_PBackgroundLSSimpleRequestConstructor__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBackground", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBackgroundParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBackground::Msg_PBackgroundLSSimpleRequestConstructor", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

            auto maybe__actorid__ = IPC::ReadParam<mozilla::ipc::ActorId>((&(reader__)));
            if (!maybe__actorid__) {
                FatalError("Error deserializing 'mozilla::ipc::ActorId'");
                return MsgValueError;

            }
            auto& actorid__ = *maybe__actorid__;
            // Sentinel = 'actorid'
            if ((!(((&(reader__)))->ReadSentinel(193725159)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'mozilla::ipc::ActorId'");
                return MsgValueError;
            }
            auto maybe__params = IPC::ReadParam<LSSimpleRequestParams>((&(reader__)));
            if (!maybe__params) {
                FatalError("Error deserializing 'LSSimpleRequestParams'");
                return MsgValueError;

            }
            auto& params = *maybe__params;
            // Sentinel = 'params'
            if ((!(((&(reader__)))->ReadSentinel(146997893)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'LSSimpleRequestParams'");
                return MsgValueError;
            }
            reader__.EndRead();
            // Ensure the ID which was sent to us is valid, and reserve a spot
            // in the table for the new actor before we bother to alloc it.
            if (!ToplevelProtocol()->TryReserve(actorid__)) {
                NS_WARNING("Failed to reserve ActorId for constructor");
                return MsgValueError;
            }

            PBackgroundLSSimpleRequestParent* actor = (this)->AllocPBackgroundLSSimpleRequestParent(params);

            if (!actor) {
                NS_WARNING("Alloc function returned null");
                // Clean up the reservation taken above if this fails, to avoid
                // leaving zombie entries in the map.
                ToplevelProtocol()->ClearReservation(actorid__);
                return MsgValueError;
            }

            // NOTE: SetManagerAndRegister unconditionally consumes the
            // reservation taken by TryReserve, so we don't need to clear it on
            // failure.
            if (!actor->SetManagerAndRegister(this, actorid__)) {
                NS_WARNING("Failed to set manager for constructor");
                return MsgValueError;
            }
            mozilla::ipc::IPCResult __ok = (this)->RecvPBackgroundLSSimpleRequestConstructor(std::move(actor), std::move(params));
            if ((!(__ok))) {
                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("PBackground", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBackgroundParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBackground::Msg_PBackgroundLocalStorageCacheConstructor", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

            auto maybe__actorid__ = IPC::ReadParam<mozilla::ipc::ActorId>((&(reader__)));
            if (!maybe__actorid__) {
                FatalError("Error deserializing 'mozilla::ipc::ActorId'");
                return MsgValueError;

            }
            auto& actorid__ = *maybe__actorid__;
            // Sentinel = 'actorid'
            if ((!(((&(reader__)))->ReadSentinel(193725159)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'mozilla::ipc::ActorId'");
                return MsgValueError;
            }
            auto maybe__principalInfo = IPC::ReadParam<PrincipalInfo>((&(reader__)));
            if (!maybe__principalInfo) {
                FatalError("Error deserializing 'PrincipalInfo'");
                return MsgValueError;

            }
            auto& principalInfo = *maybe__principalInfo;
            // Sentinel = 'principalInfo'
            if ((!(((&(reader__)))->ReadSentinel(633472335)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'PrincipalInfo'");
                return MsgValueError;
            }
            auto maybe__originKey = IPC::ReadParam<nsCString>((&(reader__)));
            if (!maybe__originKey) {
                FatalError("Error deserializing 'nsCString'");
                return MsgValueError;

            }
            auto& originKey = *maybe__originKey;
            // Sentinel = 'originKey'
            if ((!(((&(reader__)))->ReadSentinel(313656242)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsCString'");
                return MsgValueError;
            }
            auto maybe__privateBrowsingId = IPC::ReadParam<uint32_t>((&(reader__)));
            if (!maybe__privateBrowsingId) {
                FatalError("Error deserializing 'uint32_t'");
                return MsgValueError;

            }
            auto& privateBrowsingId = *maybe__privateBrowsingId;
            // Sentinel = 'privateBrowsingId'
            if ((!(((&(reader__)))->ReadSentinel(1071711988)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            reader__.EndRead();
            // Ensure the ID which was sent to us is valid, and reserve a spot
            // in the table for the new actor before we bother to alloc it.
            if (!ToplevelProtocol()->TryReserve(actorid__)) {
                NS_WARNING("Failed to reserve ActorId for constructor");
                return MsgValueError;
            }

            PBackgroundLocalStorageCacheParent* actor = (this)->AllocPBackgroundLocalStorageCacheParent(principalInfo, originKey, privateBrowsingId);

            if (!actor) {
                NS_WARNING("Alloc function returned null");
                // Clean up the reservation taken above if this fails, to avoid
                // leaving zombie entries in the map.
                ToplevelProtocol()->ClearReservation(actorid__);
                return MsgValueError;
            }

            // NOTE: SetManagerAndRegister unconditionally consumes the
            // reservation taken by TryReserve, so we don't need to clear it on
            // failure.
            if (!actor->SetManagerAndRegister(this, actorid__)) {
                NS_WARNING("Failed to set manager for constructor");
                return MsgValueError;
            }
            mozilla::ipc::IPCResult __ok = (this)->RecvPBackgroundLocalStorageCacheConstructor(std::move(actor), std::move(principalInfo), std::move(originKey), std::move(privateBrowsingId));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PBackground::Msg_PBackgroundSessionStorageManagerConstructor__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBackground", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBackgroundParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBackground::Msg_PBackgroundSessionStorageManagerConstructor", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

            auto maybe__actorid__ = IPC::ReadParam<mozilla::ipc::ActorId>((&(reader__)));
            if (!maybe__actorid__) {
                FatalError("Error deserializing 'mozilla::ipc::ActorId'");
                return MsgValueError;

            }
            auto& actorid__ = *maybe__actorid__;
            // Sentinel = 'actorid'
            if ((!(((&(reader__)))->ReadSentinel(193725159)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'mozilla::ipc::ActorId'");
                return MsgValueError;
            }
            auto maybe__aTopContextId = IPC::ReadParam<uint64_t>((&(reader__)));
            if (!maybe__aTopContextId) {
                FatalError("Error deserializing 'uint64_t'");
                return MsgValueError;

            }
            auto& aTopContextId = *maybe__aTopContextId;
            // Sentinel = 'aTopContextId'
            if ((!(((&(reader__)))->ReadSentinel(600245543)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
                return MsgValueError;
            }
            reader__.EndRead();
            // Ensure the ID which was sent to us is valid, and reserve a spot
            // in the table for the new actor before we bother to alloc it.
            if (!ToplevelProtocol()->TryReserve(actorid__)) {
                NS_WARNING("Failed to reserve ActorId for constructor");
                return MsgValueError;
            }

            RefPtr<PBackgroundSessionStorageManagerParent> actor = (this)->AllocPBackgroundSessionStorageManagerParent(aTopContextId);

            if (!actor) {
                NS_WARNING("Alloc function returned null");
                // Clean up the reservation taken above if this fails, to avoid
                // leaving zombie entries in the map.
                ToplevelProtocol()->ClearReservation(actorid__);
                return MsgValueError;
            }

            // NOTE: SetManagerAndRegister unconditionally consumes the
            // reservation taken by TryReserve, so we don't need to clear it on
            // failure.
            if (!actor->SetManagerAndRegister(this, actorid__)) {
                NS_WARNING("Failed to set manager for constructor");
                return MsgValueError;
            }
            mozilla::ipc::IPCResult __ok = (this)->RecvPBackgroundSessionStorageManagerConstructor(actor, std::move(aTopContextId));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PBackground::Msg_PBackgroundSessionStorageServiceConstructor__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBackground", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBackgroundParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBackground::Msg_PBackgroundSessionStorageServiceConstructor", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

            auto maybe__actorid__ = IPC::ReadParam<mozilla::ipc::ActorId>((&(reader__)));
            if (!maybe__actorid__) {
                FatalError("Error deserializing 'mozilla::ipc::ActorId'");
                return MsgValueError;

            }
            auto& actorid__ = *maybe__actorid__;
            // Sentinel = 'actorid'
            if ((!(((&(reader__)))->ReadSentinel(193725159)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'mozilla::ipc::ActorId'");
                return MsgValueError;
            }
            reader__.EndRead();
            // Ensure the ID which was sent to us is valid, and reserve a spot
            // in the table for the new actor before we bother to alloc it.
            if (!ToplevelProtocol()->TryReserve(actorid__)) {
                NS_WARNING("Failed to reserve ActorId for constructor");
                return MsgValueError;
            }

            RefPtr<PBackgroundSessionStorageServiceParent> actor = (this)->AllocPBackgroundSessionStorageServiceParent();

            if (!actor) {
                NS_WARNING("Alloc function returned null");
                // Clean up the reservation taken above if this fails, to avoid
                // leaving zombie entries in the map.
                ToplevelProtocol()->ClearReservation(actorid__);
                return MsgValueError;
            }

            // NOTE: SetManagerAndRegister unconditionally consumes the
            // reservation taken by TryReserve, so we don't need to clear it on
            // failure.
            if (!actor->SetManagerAndRegister(this, actorid__)) {
                NS_WARNING("Failed to set manager for constructor");
                return MsgValueError;
            }
            mozilla::ipc::IPCResult __ok = (this)->RecvPBackgroundSessionStorageServiceConstructor(actor);
            if ((!(__ok))) {
                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("PBackground", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBackgroundParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBackground::Msg_PBackgroundStorageConstructor", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

            auto maybe__actorid__ = IPC::ReadParam<mozilla::ipc::ActorId>((&(reader__)));
            if (!maybe__actorid__) {
                FatalError("Error deserializing 'mozilla::ipc::ActorId'");
                return MsgValueError;

            }
            auto& actorid__ = *maybe__actorid__;
            // Sentinel = 'actorid'
            if ((!(((&(reader__)))->ReadSentinel(193725159)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'mozilla::ipc::ActorId'");
                return MsgValueError;
            }
            auto maybe__profilePath = IPC::ReadParam<nsString>((&(reader__)));
            if (!maybe__profilePath) {
                FatalError("Error deserializing 'nsString'");
                return MsgValueError;

            }
            auto& profilePath = *maybe__profilePath;
            // Sentinel = 'profilePath'
            if ((!(((&(reader__)))->ReadSentinel(460915839)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsString'");
                return MsgValueError;
            }
            auto maybe__privateBrowsingId = IPC::ReadParam<uint32_t>((&(reader__)));
            if (!maybe__privateBrowsingId) {
                FatalError("Error deserializing 'uint32_t'");
                return MsgValueError;

            }
            auto& privateBrowsingId = *maybe__privateBrowsingId;
            // Sentinel = 'privateBrowsingId'
            if ((!(((&(reader__)))->ReadSentinel(1071711988)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            reader__.EndRead();
            // Ensure the ID which was sent to us is valid, and reserve a spot
            // in the table for the new actor before we bother to alloc it.
            if (!ToplevelProtocol()->TryReserve(actorid__)) {
                NS_WARNING("Failed to reserve ActorId for constructor");
                return MsgValueError;
            }

            PBackgroundStorageParent* actor = (this)->AllocPBackgroundStorageParent(profilePath, privateBrowsingId);

            if (!actor) {
                NS_WARNING("Alloc function returned null");
                // Clean up the reservation taken above if this fails, to avoid
                // leaving zombie entries in the map.
                ToplevelProtocol()->ClearReservation(actorid__);
                return MsgValueError;
            }

            // NOTE: SetManagerAndRegister unconditionally consumes the
            // reservation taken by TryReserve, so we don't need to clear it on
            // failure.
            if (!actor->SetManagerAndRegister(this, actorid__)) {
                NS_WARNING("Failed to set manager for constructor");
                return MsgValueError;
            }
            mozilla::ipc::IPCResult __ok = (this)->RecvPBackgroundStorageConstructor(std::move(actor), std::move(profilePath), std::move(privateBrowsingId));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PBackground::Msg_CreateFileSystemManagerParent__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBackground", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBackgroundParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBackground::Msg_CreateFileSystemManagerParent", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

            auto maybe__principalInfo = IPC::ReadParam<PrincipalInfo>((&(reader__)));
            if (!maybe__principalInfo) {
                FatalError("Error deserializing 'PrincipalInfo'");
                return MsgValueError;

            }
            auto& principalInfo = *maybe__principalInfo;
            // Sentinel = 'principalInfo'
            if ((!(((&(reader__)))->ReadSentinel(633472335)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'PrincipalInfo'");
                return MsgValueError;
            }
            auto maybe__aParentEndpoint = IPC::ReadParam<Endpoint<::mozilla::dom::PFileSystemManagerParent>>((&(reader__)));
            if (!maybe__aParentEndpoint) {
                FatalError("Error deserializing 'Endpoint<::mozilla::dom::PFileSystemManagerParent>'");
                return MsgValueError;

            }
            auto& aParentEndpoint = *maybe__aParentEndpoint;
            // Sentinel = 'aParentEndpoint'
            if ((!(((&(reader__)))->ReadSentinel(789775885)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'Endpoint<::mozilla::dom::PFileSystemManagerParent>'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::ActorId id__ = MSG_ROUTING_CONTROL;
            UniquePtr<IPC::Message> reply__(PBackground::Reply_CreateFileSystemManagerParent(id__));
            reply__->set_seqno(msg__.seqno());

            RefPtr<mozilla::ipc::IPDLResolverInner> resolver__ =
                new mozilla::ipc::IPDLResolverInner(std::move(reply__), this);

            CreateFileSystemManagerParentResolver resolver = [resolver__ = std::move(resolver__)](const nsresult& aParam) {
                resolver__->Resolve([&] (IPC::Message* reply__, IProtocol* self__) {
                    IPC::MessageWriter writer__(*reply__, self__);
                    IPC::WriteParam((&(writer__)), aParam);
                    // Sentinel = 'rv'
                    ((&(writer__)))->WriteSentinel(22806761);

                    if (mozilla::ipc::LoggingEnabledFor("PBackground", mozilla::ipc::ParentSide)) {
                        mozilla::ipc::LogMessageForProtocol(
                            "PBackgroundParent",
                            self__->ToplevelProtocol()->OtherPidMaybeInvalid(),
                            "Sending reply ",
                            reply__->type(),
                            mozilla::ipc::MessageDirection::eSending);
                    }

                });
            };
            mozilla::ipc::IPCResult __ok = (this)->RecvCreateFileSystemManagerParent(std::move(principalInfo), std::move(aParentEndpoint), std::move(resolver));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PBackground::Msg_CreateWebTransportParent__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBackground", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBackgroundParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBackground::Msg_CreateWebTransportParent", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

            auto maybe__aURL = IPC::ReadParam<nsString>((&(reader__)));
            if (!maybe__aURL) {
                FatalError("Error deserializing 'nsString'");
                return MsgValueError;

            }
            auto& aURL = *maybe__aURL;
            // Sentinel = 'aURL'
            if ((!(((&(reader__)))->ReadSentinel(58130773)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsString'");
                return MsgValueError;
            }
            auto maybe__aPrincipal = IPC::ReadParam<RefPtr<nsIPrincipal>>((&(reader__)));
            if (!maybe__aPrincipal) {
                FatalError("Error deserializing 'nsIPrincipal'");
                return MsgValueError;

            }
            auto& aPrincipal = *maybe__aPrincipal;
            // Sentinel = 'aPrincipal'
            if ((!(((&(reader__)))->ReadSentinel(364381188)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsIPrincipal'");
                return MsgValueError;
            }
            auto maybe__aBrowsingContextID = IPC::ReadParam<uint64_t>((&(reader__)));
            if (!maybe__aBrowsingContextID) {
                FatalError("Error deserializing 'uint64_t'");
                return MsgValueError;

            }
            auto& aBrowsingContextID = *maybe__aBrowsingContextID;
            // Sentinel = 'aBrowsingContextID'
            if ((!(((&(reader__)))->ReadSentinel(1149503263)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
                return MsgValueError;
            }
            auto maybe__aClientInfo = IPC::ReadParam<IPCClientInfo>((&(reader__)));
            if (!maybe__aClientInfo) {
                FatalError("Error deserializing 'IPCClientInfo'");
                return MsgValueError;

            }
            auto& aClientInfo = *maybe__aClientInfo;
            // Sentinel = 'aClientInfo'
            if ((!(((&(reader__)))->ReadSentinel(422315085)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'IPCClientInfo'");
                return MsgValueError;
            }
            auto maybe__aDedicated = IPC::ReadParam<bool>((&(reader__)));
            if (!maybe__aDedicated) {
                FatalError("Error deserializing 'bool'");
                return MsgValueError;

            }
            auto& aDedicated = *maybe__aDedicated;
            // Sentinel = 'aDedicated'
            if ((!(((&(reader__)))->ReadSentinel(344916953)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
                return MsgValueError;
            }
            auto maybe__aRequireUnreliable = IPC::ReadParam<bool>((&(reader__)));
            if (!maybe__aRequireUnreliable) {
                FatalError("Error deserializing 'bool'");
                return MsgValueError;

            }
            auto& aRequireUnreliable = *maybe__aRequireUnreliable;
            // Sentinel = 'aRequireUnreliable'
            if ((!(((&(reader__)))->ReadSentinel(1152255810)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
                return MsgValueError;
            }
            auto maybe__aCongestionControl = IPC::ReadParam<uint32_t>((&(reader__)));
            if (!maybe__aCongestionControl) {
                FatalError("Error deserializing 'uint32_t'");
                return MsgValueError;

            }
            auto& aCongestionControl = *maybe__aCongestionControl;
            // Sentinel = 'aCongestionControl'
            if ((!(((&(reader__)))->ReadSentinel(1146226524)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            auto maybe__aProtocols = IPC::ReadParam<nsTArray<nsString>>((&(reader__)));
            if (!maybe__aProtocols) {
                FatalError("Error deserializing 'nsString[]'");
                return MsgValueError;

            }
            auto& aProtocols = *maybe__aProtocols;
            // Sentinel = 'aProtocols'
            if ((!(((&(reader__)))->ReadSentinel(373556263)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsString[]'");
                return MsgValueError;
            }
            auto maybe__aServerCertHashes = IPC::ReadParam<nsTArray<WebTransportHash>>((&(reader__)));
            if (!maybe__aServerCertHashes) {
                FatalError("Error deserializing 'WebTransportHash[]'");
                return MsgValueError;

            }
            auto& aServerCertHashes = *maybe__aServerCertHashes;
            // Sentinel = 'aServerCertHashes'
            if ((!(((&(reader__)))->ReadSentinel(1010173635)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'WebTransportHash[]'");
                return MsgValueError;
            }
            auto maybe__aParentEndpoint = IPC::ReadParam<Endpoint<::mozilla::dom::PWebTransportParent>>((&(reader__)));
            if (!maybe__aParentEndpoint) {
                FatalError("Error deserializing 'Endpoint<::mozilla::dom::PWebTransportParent>'");
                return MsgValueError;

            }
            auto& aParentEndpoint = *maybe__aParentEndpoint;
            // Sentinel = 'aParentEndpoint'
            if ((!(((&(reader__)))->ReadSentinel(789775885)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'Endpoint<::mozilla::dom::PWebTransportParent>'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::ActorId id__ = MSG_ROUTING_CONTROL;
            UniquePtr<IPC::Message> reply__(PBackground::Reply_CreateWebTransportParent(id__));
            reply__->set_seqno(msg__.seqno());

            RefPtr<mozilla::ipc::IPDLResolverInner> resolver__ =
                new mozilla::ipc::IPDLResolverInner(std::move(reply__), this);

            CreateWebTransportParentResolver resolver = [resolver__ = std::move(resolver__)](std::tuple<const nsresult&, const uint8_t&> aParam) {
                resolver__->Resolve([&] (IPC::Message* reply__, IProtocol* self__) {
                    IPC::MessageWriter writer__(*reply__, self__);
                    IPC::WriteParam((&(writer__)), std::get<0>(aParam));
                    // Sentinel = 'rv'
                    ((&(writer__)))->WriteSentinel(22806761);
                    IPC::WriteParam((&(writer__)), std::get<1>(aParam));
                    // Sentinel = 'aReliability'
                    ((&(writer__)))->WriteSentinel(510657756);

                    if (mozilla::ipc::LoggingEnabledFor("PBackground", mozilla::ipc::ParentSide)) {
                        mozilla::ipc::LogMessageForProtocol(
                            "PBackgroundParent",
                            self__->ToplevelProtocol()->OtherPidMaybeInvalid(),
                            "Sending reply ",
                            reply__->type(),
                            mozilla::ipc::MessageDirection::eSending);
                    }

                });
            };
            mozilla::ipc::IPCResult __ok = (this)->RecvCreateWebTransportParent(std::move(aURL), aPrincipal, std::move(aBrowsingContextID), std::move(aClientInfo), std::move(aDedicated), std::move(aRequireUnreliable), std::move(aCongestionControl), std::move(aProtocols), std::move(aServerCertHashes), std::move(aParentEndpoint), std::move(resolver));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PBackground::Msg_CreateNotificationParent__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBackground", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBackgroundParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBackground::Msg_CreateNotificationParent", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

            auto maybe__aParentEndpoint = IPC::ReadParam<Endpoint<::mozilla::dom::notification::PNotificationParent>>((&(reader__)));
            if (!maybe__aParentEndpoint) {
                FatalError("Error deserializing 'Endpoint<::mozilla::dom::notification::PNotificationParent>'");
                return MsgValueError;

            }
            auto& aParentEndpoint = *maybe__aParentEndpoint;
            // Sentinel = 'aParentEndpoint'
            if ((!(((&(reader__)))->ReadSentinel(789775885)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'Endpoint<::mozilla::dom::notification::PNotificationParent>'");
                return MsgValueError;
            }
            auto maybe__aPrincipal = IPC::ReadParam<mozilla::NotNull<RefPtr<nsIPrincipal>>>((&(reader__)));
            if (!maybe__aPrincipal) {
                FatalError("Error deserializing 'NotNull<nsIPrincipal>'");
                return MsgValueError;

            }
            auto& aPrincipal = *maybe__aPrincipal;
            // Sentinel = 'aPrincipal'
            if ((!(((&(reader__)))->ReadSentinel(364381188)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'NotNull<nsIPrincipal>'");
                return MsgValueError;
            }
            auto maybe__aEffectiveStoragePrincipal = IPC::ReadParam<mozilla::NotNull<RefPtr<nsIPrincipal>>>((&(reader__)));
            if (!maybe__aEffectiveStoragePrincipal) {
                FatalError("Error deserializing 'NotNull<nsIPrincipal>'");
                return MsgValueError;

            }
            auto& aEffectiveStoragePrincipal = *maybe__aEffectiveStoragePrincipal;
            // Sentinel = 'aEffectiveStoragePrincipal'
            if ((!(((&(reader__)))->ReadSentinel(2327513706)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'NotNull<nsIPrincipal>'");
                return MsgValueError;
            }
            auto maybe__aIsSecureContext = IPC::ReadParam<bool>((&(reader__)));
            if (!maybe__aIsSecureContext) {
                FatalError("Error deserializing 'bool'");
                return MsgValueError;

            }
            auto& aIsSecureContext = *maybe__aIsSecureContext;
            // Sentinel = 'aIsSecureContext'
            if ((!(((&(reader__)))->ReadSentinel(882443882)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
                return MsgValueError;
            }
            auto maybe__aScope = IPC::ReadParam<nsString>((&(reader__)));
            if (!maybe__aScope) {
                FatalError("Error deserializing 'nsString'");
                return MsgValueError;

            }
            auto& aScope = *maybe__aScope;
            // Sentinel = 'aScope'
            if ((!(((&(reader__)))->ReadSentinel(134808156)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsString'");
                return MsgValueError;
            }
            auto maybe__aNotification = IPC::ReadParam<IPCNotification>((&(reader__)));
            if (!maybe__aNotification) {
                FatalError("Error deserializing 'IPCNotification'");
                return MsgValueError;

            }
            auto& aNotification = *maybe__aNotification;
            // Sentinel = 'aNotification'
            if ((!(((&(reader__)))->ReadSentinel(607978825)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'IPCNotification'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::ActorId id__ = MSG_ROUTING_CONTROL;
            UniquePtr<IPC::Message> reply__(PBackground::Reply_CreateNotificationParent(id__));
            reply__->set_seqno(msg__.seqno());

            RefPtr<mozilla::ipc::IPDLResolverInner> resolver__ =
                new mozilla::ipc::IPDLResolverInner(std::move(reply__), this);

            CreateNotificationParentResolver resolver = [resolver__ = std::move(resolver__)](const bool& aParam) {
                resolver__->Resolve([&] (IPC::Message* reply__, IProtocol* self__) {
                    IPC::MessageWriter writer__(*reply__, self__);
                    IPC::WriteParam((&(writer__)), aParam);
                    // Sentinel = 'rv'
                    ((&(writer__)))->WriteSentinel(22806761);

                    if (mozilla::ipc::LoggingEnabledFor("PBackground", mozilla::ipc::ParentSide)) {
                        mozilla::ipc::LogMessageForProtocol(
                            "PBackgroundParent",
                            self__->ToplevelProtocol()->OtherPidMaybeInvalid(),
                            "Sending reply ",
                            reply__->type(),
                            mozilla::ipc::MessageDirection::eSending);
                    }

                });
            };
            mozilla::ipc::IPCResult __ok = (this)->RecvCreateNotificationParent(std::move(aParentEndpoint), aPrincipal, aEffectiveStoragePrincipal, std::move(aIsSecureContext), std::move(aScope), std::move(aNotification), std::move(resolver));
            if ((!(__ok))) {
                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("PBackground", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBackgroundParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBackground::Msg_PVsyncConstructor", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

            auto maybe__actorid__ = IPC::ReadParam<mozilla::ipc::ActorId>((&(reader__)));
            if (!maybe__actorid__) {
                FatalError("Error deserializing 'mozilla::ipc::ActorId'");
                return MsgValueError;

            }
            auto& actorid__ = *maybe__actorid__;
            // Sentinel = 'actorid'
            if ((!(((&(reader__)))->ReadSentinel(193725159)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'mozilla::ipc::ActorId'");
                return MsgValueError;
            }
            reader__.EndRead();
            // Ensure the ID which was sent to us is valid, and reserve a spot
            // in the table for the new actor before we bother to alloc it.
            if (!ToplevelProtocol()->TryReserve(actorid__)) {
                NS_WARNING("Failed to reserve ActorId for constructor");
                return MsgValueError;
            }

            RefPtr<PVsyncParent> actor = (this)->AllocPVsyncParent();

            if (!actor) {
                NS_WARNING("Alloc function returned null");
                // Clean up the reservation taken above if this fails, to avoid
                // leaving zombie entries in the map.
                ToplevelProtocol()->ClearReservation(actorid__);
                return MsgValueError;
            }

            // NOTE: SetManagerAndRegister unconditionally consumes the
            // reservation taken by TryReserve, so we don't need to clear it on
            // failure.
            if (!actor->SetManagerAndRegister(this, actorid__)) {
                NS_WARNING("Failed to set manager for constructor");
                return MsgValueError;
            }
            mozilla::ipc::IPCResult __ok = (this)->RecvPVsyncConstructor(actor);
            if ((!(__ok))) {
                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("PBackground", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBackgroundParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBackground::Msg_PCamerasConstructor", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

            auto maybe__actorid__ = IPC::ReadParam<mozilla::ipc::ActorId>((&(reader__)));
            if (!maybe__actorid__) {
                FatalError("Error deserializing 'mozilla::ipc::ActorId'");
                return MsgValueError;

            }
            auto& actorid__ = *maybe__actorid__;
            // Sentinel = 'actorid'
            if ((!(((&(reader__)))->ReadSentinel(193725159)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'mozilla::ipc::ActorId'");
                return MsgValueError;
            }
            reader__.EndRead();
            // Ensure the ID which was sent to us is valid, and reserve a spot
            // in the table for the new actor before we bother to alloc it.
            if (!ToplevelProtocol()->TryReserve(actorid__)) {
                NS_WARNING("Failed to reserve ActorId for constructor");
                return MsgValueError;
            }

            PCamerasParent* actor = (this)->AllocPCamerasParent();

            if (!actor) {
                NS_WARNING("Alloc function returned null");
                // Clean up the reservation taken above if this fails, to avoid
                // leaving zombie entries in the map.
                ToplevelProtocol()->ClearReservation(actorid__);
                return MsgValueError;
            }

            // NOTE: SetManagerAndRegister unconditionally consumes the
            // reservation taken by TryReserve, so we don't need to clear it on
            // failure.
            if (!actor->SetManagerAndRegister(this, actorid__)) {
                NS_WARNING("Failed to set manager for constructor");
                return MsgValueError;
            }
            mozilla::ipc::IPCResult __ok = (this)->RecvPCamerasConstructor(std::move(actor));
            if ((!(__ok))) {
                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("PBackground", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBackgroundParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBackground::Msg_PUDPSocketConstructor", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

            auto maybe__actorid__ = IPC::ReadParam<mozilla::ipc::ActorId>((&(reader__)));
            if (!maybe__actorid__) {
                FatalError("Error deserializing 'mozilla::ipc::ActorId'");
                return MsgValueError;

            }
            auto& actorid__ = *maybe__actorid__;
            // Sentinel = 'actorid'
            if ((!(((&(reader__)))->ReadSentinel(193725159)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'mozilla::ipc::ActorId'");
                return MsgValueError;
            }
            auto maybe__pInfo = IPC::ReadParam<mozilla::Maybe<PrincipalInfo>>((&(reader__)));
            if (!maybe__pInfo) {
                FatalError("Error deserializing 'PrincipalInfo?'");
                return MsgValueError;

            }
            auto& pInfo = *maybe__pInfo;
            // Sentinel = 'pInfo'
            if ((!(((&(reader__)))->ReadSentinel(98435581)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'PrincipalInfo?'");
                return MsgValueError;
            }
            auto maybe__filter = IPC::ReadParam<nsCString>((&(reader__)));
            if (!maybe__filter) {
                FatalError("Error deserializing 'nsCString'");
                return MsgValueError;

            }
            auto& filter = *maybe__filter;
            // Sentinel = 'filter'
            if ((!(((&(reader__)))->ReadSentinel(146735751)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsCString'");
                return MsgValueError;
            }
            reader__.EndRead();
            // Ensure the ID which was sent to us is valid, and reserve a spot
            // in the table for the new actor before we bother to alloc it.
            if (!ToplevelProtocol()->TryReserve(actorid__)) {
                NS_WARNING("Failed to reserve ActorId for constructor");
                return MsgValueError;
            }

            RefPtr<PUDPSocketParent> actor = (this)->AllocPUDPSocketParent(pInfo, filter);

            if (!actor) {
                NS_WARNING("Alloc function returned null");
                // Clean up the reservation taken above if this fails, to avoid
                // leaving zombie entries in the map.
                ToplevelProtocol()->ClearReservation(actorid__);
                return MsgValueError;
            }

            // NOTE: SetManagerAndRegister unconditionally consumes the
            // reservation taken by TryReserve, so we don't need to clear it on
            // failure.
            if (!actor->SetManagerAndRegister(this, actorid__)) {
                NS_WARNING("Failed to set manager for constructor");
                return MsgValueError;
            }
            mozilla::ipc::IPCResult __ok = (this)->RecvPUDPSocketConstructor(actor, std::move(pInfo), std::move(filter));
            if ((!(__ok))) {
                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("PBackground", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBackgroundParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBackground::Msg_PBroadcastChannelConstructor", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

            auto maybe__actorid__ = IPC::ReadParam<mozilla::ipc::ActorId>((&(reader__)));
            if (!maybe__actorid__) {
                FatalError("Error deserializing 'mozilla::ipc::ActorId'");
                return MsgValueError;

            }
            auto& actorid__ = *maybe__actorid__;
            // Sentinel = 'actorid'
            if ((!(((&(reader__)))->ReadSentinel(193725159)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'mozilla::ipc::ActorId'");
                return MsgValueError;
            }
            auto maybe__pInfo = IPC::ReadParam<PrincipalInfo>((&(reader__)));
            if (!maybe__pInfo) {
                FatalError("Error deserializing 'PrincipalInfo'");
                return MsgValueError;

            }
            auto& pInfo = *maybe__pInfo;
            // Sentinel = 'pInfo'
            if ((!(((&(reader__)))->ReadSentinel(98435581)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'PrincipalInfo'");
                return MsgValueError;
            }
            auto maybe__origin = IPC::ReadParam<nsCString>((&(reader__)));
            if (!maybe__origin) {
                FatalError("Error deserializing 'nsCString'");
                return MsgValueError;

            }
            auto& origin = *maybe__origin;
            // Sentinel = 'origin'
            if ((!(((&(reader__)))->ReadSentinel(150143625)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsCString'");
                return MsgValueError;
            }
            auto maybe__channel = IPC::ReadParam<nsString>((&(reader__)));
            if (!maybe__channel) {
                FatalError("Error deserializing 'nsString'");
                return MsgValueError;

            }
            auto& channel = *maybe__channel;
            // Sentinel = 'channel'
            if ((!(((&(reader__)))->ReadSentinel(189334234)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsString'");
                return MsgValueError;
            }
            reader__.EndRead();
            // Ensure the ID which was sent to us is valid, and reserve a spot
            // in the table for the new actor before we bother to alloc it.
            if (!ToplevelProtocol()->TryReserve(actorid__)) {
                NS_WARNING("Failed to reserve ActorId for constructor");
                return MsgValueError;
            }

            PBroadcastChannelParent* actor = (this)->AllocPBroadcastChannelParent(pInfo, origin, channel);

            if (!actor) {
                NS_WARNING("Alloc function returned null");
                // Clean up the reservation taken above if this fails, to avoid
                // leaving zombie entries in the map.
                ToplevelProtocol()->ClearReservation(actorid__);
                return MsgValueError;
            }

            // NOTE: SetManagerAndRegister unconditionally consumes the
            // reservation taken by TryReserve, so we don't need to clear it on
            // failure.
            if (!actor->SetManagerAndRegister(this, actorid__)) {
                NS_WARNING("Failed to set manager for constructor");
                return MsgValueError;
            }
            mozilla::ipc::IPCResult __ok = (this)->RecvPBroadcastChannelConstructor(std::move(actor), std::move(pInfo), std::move(origin), std::move(channel));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PBackground::Msg_PCookieStoreConstructor__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBackground", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBackgroundParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBackground::Msg_PCookieStoreConstructor", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

            auto maybe__actorid__ = IPC::ReadParam<mozilla::ipc::ActorId>((&(reader__)));
            if (!maybe__actorid__) {
                FatalError("Error deserializing 'mozilla::ipc::ActorId'");
                return MsgValueError;

            }
            auto& actorid__ = *maybe__actorid__;
            // Sentinel = 'actorid'
            if ((!(((&(reader__)))->ReadSentinel(193725159)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'mozilla::ipc::ActorId'");
                return MsgValueError;
            }
            reader__.EndRead();
            // Ensure the ID which was sent to us is valid, and reserve a spot
            // in the table for the new actor before we bother to alloc it.
            if (!ToplevelProtocol()->TryReserve(actorid__)) {
                NS_WARNING("Failed to reserve ActorId for constructor");
                return MsgValueError;
            }

            PCookieStoreParent* actor = (this)->AllocPCookieStoreParent();

            if (!actor) {
                NS_WARNING("Alloc function returned null");
                // Clean up the reservation taken above if this fails, to avoid
                // leaving zombie entries in the map.
                ToplevelProtocol()->ClearReservation(actorid__);
                return MsgValueError;
            }

            // NOTE: SetManagerAndRegister unconditionally consumes the
            // reservation taken by TryReserve, so we don't need to clear it on
            // failure.
            if (!actor->SetManagerAndRegister(this, actorid__)) {
                NS_WARNING("Failed to set manager for constructor");
                return MsgValueError;
            }
            mozilla::ipc::IPCResult __ok = (this)->RecvPCookieStoreConstructor(std::move(actor));
            if ((!(__ok))) {
                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("PBackground", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBackgroundParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBackground::Msg_PServiceWorkerManagerConstructor", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

            auto maybe__actorid__ = IPC::ReadParam<mozilla::ipc::ActorId>((&(reader__)));
            if (!maybe__actorid__) {
                FatalError("Error deserializing 'mozilla::ipc::ActorId'");
                return MsgValueError;

            }
            auto& actorid__ = *maybe__actorid__;
            // Sentinel = 'actorid'
            if ((!(((&(reader__)))->ReadSentinel(193725159)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'mozilla::ipc::ActorId'");
                return MsgValueError;
            }
            reader__.EndRead();
            // Ensure the ID which was sent to us is valid, and reserve a spot
            // in the table for the new actor before we bother to alloc it.
            if (!ToplevelProtocol()->TryReserve(actorid__)) {
                NS_WARNING("Failed to reserve ActorId for constructor");
                return MsgValueError;
            }

            PServiceWorkerManagerParent* actor = (this)->AllocPServiceWorkerManagerParent();

            if (!actor) {
                NS_WARNING("Alloc function returned null");
                // Clean up the reservation taken above if this fails, to avoid
                // leaving zombie entries in the map.
                ToplevelProtocol()->ClearReservation(actorid__);
                return MsgValueError;
            }

            // NOTE: SetManagerAndRegister unconditionally consumes the
            // reservation taken by TryReserve, so we don't need to clear it on
            // failure.
            if (!actor->SetManagerAndRegister(this, actorid__)) {
                NS_WARNING("Failed to set manager for constructor");
                return MsgValueError;
            }
            mozilla::ipc::IPCResult __ok = (this)->RecvPServiceWorkerManagerConstructor(std::move(actor));
            if ((!(__ok))) {
                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("PBackground", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBackgroundParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBackground::Msg_ShutdownServiceWorkerRegistrar", OTHER);

            mozilla::ipc::IPCResult __ok = (this)->RecvShutdownServiceWorkerRegistrar();
            if ((!(__ok))) {
                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("PBackground", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBackgroundParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBackground::Msg_PCacheStorageConstructor", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

            auto maybe__actorid__ = IPC::ReadParam<mozilla::ipc::ActorId>((&(reader__)));
            if (!maybe__actorid__) {
                FatalError("Error deserializing 'mozilla::ipc::ActorId'");
                return MsgValueError;

            }
            auto& actorid__ = *maybe__actorid__;
            // Sentinel = 'actorid'
            if ((!(((&(reader__)))->ReadSentinel(193725159)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'mozilla::ipc::ActorId'");
                return MsgValueError;
            }
            auto maybe__aNamespace = IPC::ReadParam<Namespace>((&(reader__)));
            if (!maybe__aNamespace) {
                FatalError("Error deserializing 'Namespace'");
                return MsgValueError;

            }
            auto& aNamespace = *maybe__aNamespace;
            // Sentinel = 'aNamespace'
            if ((!(((&(reader__)))->ReadSentinel(356516847)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'Namespace'");
                return MsgValueError;
            }
            auto maybe__aPrincipalInfo = IPC::ReadParam<PrincipalInfo>((&(reader__)));
            if (!maybe__aPrincipalInfo) {
                FatalError("Error deserializing 'PrincipalInfo'");
                return MsgValueError;

            }
            auto& aPrincipalInfo = *maybe__aPrincipalInfo;
            // Sentinel = 'aPrincipalInfo'
            if ((!(((&(reader__)))->ReadSentinel(695272848)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'PrincipalInfo'");
                return MsgValueError;
            }
            reader__.EndRead();
            // Ensure the ID which was sent to us is valid, and reserve a spot
            // in the table for the new actor before we bother to alloc it.
            if (!ToplevelProtocol()->TryReserve(actorid__)) {
                NS_WARNING("Failed to reserve ActorId for constructor");
                return MsgValueError;
            }

            RefPtr<PCacheStorageParent> actor = (this)->AllocPCacheStorageParent(aNamespace, aPrincipalInfo);

            if (!actor) {
                NS_WARNING("Alloc function returned null");
                // Clean up the reservation taken above if this fails, to avoid
                // leaving zombie entries in the map.
                ToplevelProtocol()->ClearReservation(actorid__);
                return MsgValueError;
            }

            // NOTE: SetManagerAndRegister unconditionally consumes the
            // reservation taken by TryReserve, so we don't need to clear it on
            // failure.
            if (!actor->SetManagerAndRegister(this, actorid__)) {
                NS_WARNING("Failed to set manager for constructor");
                return MsgValueError;
            }
            mozilla::ipc::IPCResult __ok = (this)->RecvPCacheStorageConstructor(actor, std::move(aNamespace), std::move(aPrincipalInfo));
            if ((!(__ok))) {
                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("PBackground", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBackgroundParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBackground::Msg_PMessagePortConstructor", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

            auto maybe__actorid__ = IPC::ReadParam<mozilla::ipc::ActorId>((&(reader__)));
            if (!maybe__actorid__) {
                FatalError("Error deserializing 'mozilla::ipc::ActorId'");
                return MsgValueError;

            }
            auto& actorid__ = *maybe__actorid__;
            // Sentinel = 'actorid'
            if ((!(((&(reader__)))->ReadSentinel(193725159)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'mozilla::ipc::ActorId'");
                return MsgValueError;
            }
            auto maybe__uuid = IPC::ReadParam<nsID>((&(reader__)));
            if (!maybe__uuid) {
                FatalError("Error deserializing 'nsID'");
                return MsgValueError;

            }
            auto& uuid = *maybe__uuid;
            // Sentinel = 'uuid'
            if ((!(((&(reader__)))->ReadSentinel(74252728)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsID'");
                return MsgValueError;
            }
            auto maybe__destinationUuid = IPC::ReadParam<nsID>((&(reader__)));
            if (!maybe__destinationUuid) {
                FatalError("Error deserializing 'nsID'");
                return MsgValueError;

            }
            auto& destinationUuid = *maybe__destinationUuid;
            // Sentinel = 'destinationUuid'
            if ((!(((&(reader__)))->ReadSentinel(840435258)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsID'");
                return MsgValueError;
            }
            auto maybe__sequenceId = IPC::ReadParam<uint32_t>((&(reader__)));
            if (!maybe__sequenceId) {
                FatalError("Error deserializing 'uint32_t'");
                return MsgValueError;

            }
            auto& sequenceId = *maybe__sequenceId;
            // Sentinel = 'sequenceId'
            if ((!(((&(reader__)))->ReadSentinel(386204679)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            reader__.EndRead();
            // Ensure the ID which was sent to us is valid, and reserve a spot
            // in the table for the new actor before we bother to alloc it.
            if (!ToplevelProtocol()->TryReserve(actorid__)) {
                NS_WARNING("Failed to reserve ActorId for constructor");
                return MsgValueError;
            }

            RefPtr<PMessagePortParent> actor = (this)->AllocPMessagePortParent(uuid, destinationUuid, sequenceId);

            if (!actor) {
                NS_WARNING("Alloc function returned null");
                // Clean up the reservation taken above if this fails, to avoid
                // leaving zombie entries in the map.
                ToplevelProtocol()->ClearReservation(actorid__);
                return MsgValueError;
            }

            // NOTE: SetManagerAndRegister unconditionally consumes the
            // reservation taken by TryReserve, so we don't need to clear it on
            // failure.
            if (!actor->SetManagerAndRegister(this, actorid__)) {
                NS_WARNING("Failed to set manager for constructor");
                return MsgValueError;
            }
            mozilla::ipc::IPCResult __ok = (this)->RecvPMessagePortConstructor(actor, std::move(uuid), std::move(destinationUuid), std::move(sequenceId));
            if ((!(__ok))) {
                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("PBackground", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBackgroundParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBackground::Msg_MessagePortForceClose", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

            auto maybe__uuid = IPC::ReadParam<nsID>((&(reader__)));
            if (!maybe__uuid) {
                FatalError("Error deserializing 'nsID'");
                return MsgValueError;

            }
            auto& uuid = *maybe__uuid;
            // Sentinel = 'uuid'
            if ((!(((&(reader__)))->ReadSentinel(74252728)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsID'");
                return MsgValueError;
            }
            auto maybe__destinationUuid = IPC::ReadParam<nsID>((&(reader__)));
            if (!maybe__destinationUuid) {
                FatalError("Error deserializing 'nsID'");
                return MsgValueError;

            }
            auto& destinationUuid = *maybe__destinationUuid;
            // Sentinel = 'destinationUuid'
            if ((!(((&(reader__)))->ReadSentinel(840435258)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsID'");
                return MsgValueError;
            }
            auto maybe__sequenceId = IPC::ReadParam<uint32_t>((&(reader__)));
            if (!maybe__sequenceId) {
                FatalError("Error deserializing 'uint32_t'");
                return MsgValueError;

            }
            auto& sequenceId = *maybe__sequenceId;
            // Sentinel = 'sequenceId'
            if ((!(((&(reader__)))->ReadSentinel(386204679)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (this)->RecvMessagePortForceClose(std::move(uuid), std::move(destinationUuid), std::move(sequenceId));
            if ((!(__ok))) {
                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("PBackground", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBackgroundParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBackground::Msg_PQuotaConstructor", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

            auto maybe__actorid__ = IPC::ReadParam<mozilla::ipc::ActorId>((&(reader__)));
            if (!maybe__actorid__) {
                FatalError("Error deserializing 'mozilla::ipc::ActorId'");
                return MsgValueError;

            }
            auto& actorid__ = *maybe__actorid__;
            // Sentinel = 'actorid'
            if ((!(((&(reader__)))->ReadSentinel(193725159)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'mozilla::ipc::ActorId'");
                return MsgValueError;
            }
            reader__.EndRead();
            // Ensure the ID which was sent to us is valid, and reserve a spot
            // in the table for the new actor before we bother to alloc it.
            if (!ToplevelProtocol()->TryReserve(actorid__)) {
                NS_WARNING("Failed to reserve ActorId for constructor");
                return MsgValueError;
            }

            RefPtr<PQuotaParent> actor = (this)->AllocPQuotaParent();

            if (!actor) {
                NS_WARNING("Alloc function returned null");
                // Clean up the reservation taken above if this fails, to avoid
                // leaving zombie entries in the map.
                ToplevelProtocol()->ClearReservation(actorid__);
                return MsgValueError;
            }

            // NOTE: SetManagerAndRegister unconditionally consumes the
            // reservation taken by TryReserve, so we don't need to clear it on
            // failure.
            if (!actor->SetManagerAndRegister(this, actorid__)) {
                NS_WARNING("Failed to set manager for constructor");
                return MsgValueError;
            }
            mozilla::ipc::IPCResult __ok = (this)->RecvPQuotaConstructor(actor);
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PBackground::Msg_ShutdownQuotaManager__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBackground", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBackgroundParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBackground::Msg_ShutdownQuotaManager", OTHER);

            mozilla::ipc::IPCResult __ok = (this)->RecvShutdownQuotaManager();
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PBackground::Msg_ShutdownBackgroundSessionStorageManagers__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBackground", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBackgroundParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBackground::Msg_ShutdownBackgroundSessionStorageManagers", OTHER);

            mozilla::ipc::IPCResult __ok = (this)->RecvShutdownBackgroundSessionStorageManagers();
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PBackground::Msg_PropagateBackgroundSessionStorageManager__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBackground", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBackgroundParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBackground::Msg_PropagateBackgroundSessionStorageManager", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

            auto maybe__currentTopContextId = IPC::ReadParam<uint64_t>((&(reader__)));
            if (!maybe__currentTopContextId) {
                FatalError("Error deserializing 'uint64_t'");
                return MsgValueError;

            }
            auto& currentTopContextId = *maybe__currentTopContextId;
            // Sentinel = 'currentTopContextId'
            if ((!(((&(reader__)))->ReadSentinel(1324877769)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
                return MsgValueError;
            }
            auto maybe__targetTopContextId = IPC::ReadParam<uint64_t>((&(reader__)));
            if (!maybe__targetTopContextId) {
                FatalError("Error deserializing 'uint64_t'");
                return MsgValueError;

            }
            auto& targetTopContextId = *maybe__targetTopContextId;
            // Sentinel = 'targetTopContextId'
            if ((!(((&(reader__)))->ReadSentinel(1175127885)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (this)->RecvPropagateBackgroundSessionStorageManager(std::move(currentTopContextId), std::move(targetTopContextId));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PBackground::Msg_RemoveBackgroundSessionStorageManager__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBackground", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBackgroundParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBackground::Msg_RemoveBackgroundSessionStorageManager", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

            auto maybe__topContextId = IPC::ReadParam<uint64_t>((&(reader__)));
            if (!maybe__topContextId) {
                FatalError("Error deserializing 'uint64_t'");
                return MsgValueError;

            }
            auto& topContextId = *maybe__topContextId;
            // Sentinel = 'topContextId'
            if ((!(((&(reader__)))->ReadSentinel(542704870)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (this)->RecvRemoveBackgroundSessionStorageManager(std::move(topContextId));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PBackground::Msg_GetSessionStorageManagerData__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBackground", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBackgroundParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBackground::Msg_GetSessionStorageManagerData", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

            auto maybe__aTopContextId = IPC::ReadParam<uint64_t>((&(reader__)));
            if (!maybe__aTopContextId) {
                FatalError("Error deserializing 'uint64_t'");
                return MsgValueError;

            }
            auto& aTopContextId = *maybe__aTopContextId;
            // Sentinel = 'aTopContextId'
            if ((!(((&(reader__)))->ReadSentinel(600245543)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
                return MsgValueError;
            }
            auto maybe__aSizeLimit = IPC::ReadParam<uint32_t>((&(reader__)));
            if (!maybe__aSizeLimit) {
                FatalError("Error deserializing 'uint32_t'");
                return MsgValueError;

            }
            auto& aSizeLimit = *maybe__aSizeLimit;
            // Sentinel = 'aSizeLimit'
            if ((!(((&(reader__)))->ReadSentinel(359138300)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            auto maybe__aCancelSessionStoreTimer = IPC::ReadParam<bool>((&(reader__)));
            if (!maybe__aCancelSessionStoreTimer) {
                FatalError("Error deserializing 'bool'");
                return MsgValueError;

            }
            auto& aCancelSessionStoreTimer = *maybe__aCancelSessionStoreTimer;
            // Sentinel = 'aCancelSessionStoreTimer'
            if ((!(((&(reader__)))->ReadSentinel(1972504986)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::ActorId id__ = MSG_ROUTING_CONTROL;
            UniquePtr<IPC::Message> reply__(PBackground::Reply_GetSessionStorageManagerData(id__));
            reply__->set_seqno(msg__.seqno());

            RefPtr<mozilla::ipc::IPDLResolverInner> resolver__ =
                new mozilla::ipc::IPDLResolverInner(std::move(reply__), this);

            GetSessionStorageManagerDataResolver resolver = [resolver__ = std::move(resolver__)](mozilla::Span<SSCacheCopy const> aParam) {
                resolver__->Resolve([&] (IPC::Message* reply__, IProtocol* self__) {
                    IPC::MessageWriter writer__(*reply__, self__);
                    IPC::WriteParam((&(writer__)), aParam);
                    // Sentinel = 'aCacheCopy'
                    ((&(writer__)))->WriteSentinel(336004049);

                    if (mozilla::ipc::LoggingEnabledFor("PBackground", mozilla::ipc::ParentSide)) {
                        mozilla::ipc::LogMessageForProtocol(
                            "PBackgroundParent",
                            self__->ToplevelProtocol()->OtherPidMaybeInvalid(),
                            "Sending reply ",
                            reply__->type(),
                            mozilla::ipc::MessageDirection::eSending);
                    }

                });
            };
            mozilla::ipc::IPCResult __ok = (this)->RecvGetSessionStorageManagerData(std::move(aTopContextId), std::move(aSizeLimit), std::move(aCancelSessionStoreTimer), std::move(resolver));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PBackground::Msg_LoadSessionStorageManagerData__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBackground", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBackgroundParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBackground::Msg_LoadSessionStorageManagerData", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

            auto maybe__aTopContextId = IPC::ReadParam<uint64_t>((&(reader__)));
            if (!maybe__aTopContextId) {
                FatalError("Error deserializing 'uint64_t'");
                return MsgValueError;

            }
            auto& aTopContextId = *maybe__aTopContextId;
            // Sentinel = 'aTopContextId'
            if ((!(((&(reader__)))->ReadSentinel(600245543)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
                return MsgValueError;
            }
            auto maybe__aOriginCacheCopy = IPC::ReadParam<nsTArray<SSCacheCopy>>((&(reader__)));
            if (!maybe__aOriginCacheCopy) {
                FatalError("Error deserializing 'SSCacheCopy[]'");
                return MsgValueError;

            }
            auto& aOriginCacheCopy = *maybe__aOriginCacheCopy;
            // Sentinel = 'aOriginCacheCopy'
            if ((!(((&(reader__)))->ReadSentinel(875038265)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'SSCacheCopy[]'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (this)->RecvLoadSessionStorageManagerData(std::move(aTopContextId), std::move(aOriginCacheCopy));
            if ((!(__ok))) {
                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("PBackground", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBackgroundParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBackground::Msg_PFileSystemRequestConstructor", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

            auto maybe__actorid__ = IPC::ReadParam<mozilla::ipc::ActorId>((&(reader__)));
            if (!maybe__actorid__) {
                FatalError("Error deserializing 'mozilla::ipc::ActorId'");
                return MsgValueError;

            }
            auto& actorid__ = *maybe__actorid__;
            // Sentinel = 'actorid'
            if ((!(((&(reader__)))->ReadSentinel(193725159)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'mozilla::ipc::ActorId'");
                return MsgValueError;
            }
            auto maybe__params = IPC::ReadParam<FileSystemParams>((&(reader__)));
            if (!maybe__params) {
                FatalError("Error deserializing 'FileSystemParams'");
                return MsgValueError;

            }
            auto& params = *maybe__params;
            // Sentinel = 'params'
            if ((!(((&(reader__)))->ReadSentinel(146997893)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'FileSystemParams'");
                return MsgValueError;
            }
            reader__.EndRead();
            // Ensure the ID which was sent to us is valid, and reserve a spot
            // in the table for the new actor before we bother to alloc it.
            if (!ToplevelProtocol()->TryReserve(actorid__)) {
                NS_WARNING("Failed to reserve ActorId for constructor");
                return MsgValueError;
            }

            RefPtr<PFileSystemRequestParent> actor = (this)->AllocPFileSystemRequestParent(params);

            if (!actor) {
                NS_WARNING("Alloc function returned null");
                // Clean up the reservation taken above if this fails, to avoid
                // leaving zombie entries in the map.
                ToplevelProtocol()->ClearReservation(actorid__);
                return MsgValueError;
            }

            // NOTE: SetManagerAndRegister unconditionally consumes the
            // reservation taken by TryReserve, so we don't need to clear it on
            // failure.
            if (!actor->SetManagerAndRegister(this, actorid__)) {
                NS_WARNING("Failed to set manager for constructor");
                return MsgValueError;
            }
            mozilla::ipc::IPCResult __ok = (this)->RecvPFileSystemRequestConstructor(actor, std::move(params));
            if ((!(__ok))) {
                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("PBackground", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBackgroundParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBackground::Msg_PGamepadEventChannelConstructor", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

            auto maybe__actorid__ = IPC::ReadParam<mozilla::ipc::ActorId>((&(reader__)));
            if (!maybe__actorid__) {
                FatalError("Error deserializing 'mozilla::ipc::ActorId'");
                return MsgValueError;

            }
            auto& actorid__ = *maybe__actorid__;
            // Sentinel = 'actorid'
            if ((!(((&(reader__)))->ReadSentinel(193725159)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'mozilla::ipc::ActorId'");
                return MsgValueError;
            }
            reader__.EndRead();
            // Ensure the ID which was sent to us is valid, and reserve a spot
            // in the table for the new actor before we bother to alloc it.
            if (!ToplevelProtocol()->TryReserve(actorid__)) {
                NS_WARNING("Failed to reserve ActorId for constructor");
                return MsgValueError;
            }

            RefPtr<PGamepadEventChannelParent> actor = (this)->AllocPGamepadEventChannelParent();

            if (!actor) {
                NS_WARNING("Alloc function returned null");
                // Clean up the reservation taken above if this fails, to avoid
                // leaving zombie entries in the map.
                ToplevelProtocol()->ClearReservation(actorid__);
                return MsgValueError;
            }

            // NOTE: SetManagerAndRegister unconditionally consumes the
            // reservation taken by TryReserve, so we don't need to clear it on
            // failure.
            if (!actor->SetManagerAndRegister(this, actorid__)) {
                NS_WARNING("Failed to set manager for constructor");
                return MsgValueError;
            }
            mozilla::ipc::IPCResult __ok = (this)->RecvPGamepadEventChannelConstructor(actor);
            if ((!(__ok))) {
                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("PBackground", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBackgroundParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBackground::Msg_PGamepadTestChannelConstructor", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

            auto maybe__actorid__ = IPC::ReadParam<mozilla::ipc::ActorId>((&(reader__)));
            if (!maybe__actorid__) {
                FatalError("Error deserializing 'mozilla::ipc::ActorId'");
                return MsgValueError;

            }
            auto& actorid__ = *maybe__actorid__;
            // Sentinel = 'actorid'
            if ((!(((&(reader__)))->ReadSentinel(193725159)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'mozilla::ipc::ActorId'");
                return MsgValueError;
            }
            reader__.EndRead();
            // Ensure the ID which was sent to us is valid, and reserve a spot
            // in the table for the new actor before we bother to alloc it.
            if (!ToplevelProtocol()->TryReserve(actorid__)) {
                NS_WARNING("Failed to reserve ActorId for constructor");
                return MsgValueError;
            }

            RefPtr<PGamepadTestChannelParent> actor = (this)->AllocPGamepadTestChannelParent();

            if (!actor) {
                NS_WARNING("Alloc function returned null");
                // Clean up the reservation taken above if this fails, to avoid
                // leaving zombie entries in the map.
                ToplevelProtocol()->ClearReservation(actorid__);
                return MsgValueError;
            }

            // NOTE: SetManagerAndRegister unconditionally consumes the
            // reservation taken by TryReserve, so we don't need to clear it on
            // failure.
            if (!actor->SetManagerAndRegister(this, actorid__)) {
                NS_WARNING("Failed to set manager for constructor");
                return MsgValueError;
            }
            mozilla::ipc::IPCResult __ok = (this)->RecvPGamepadTestChannelConstructor(actor);
            if ((!(__ok))) {
                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("PBackground", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBackgroundParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBackground::Msg_PHttpBackgroundChannelConstructor", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

            auto maybe__actorid__ = IPC::ReadParam<mozilla::ipc::ActorId>((&(reader__)));
            if (!maybe__actorid__) {
                FatalError("Error deserializing 'mozilla::ipc::ActorId'");
                return MsgValueError;

            }
            auto& actorid__ = *maybe__actorid__;
            // Sentinel = 'actorid'
            if ((!(((&(reader__)))->ReadSentinel(193725159)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'mozilla::ipc::ActorId'");
                return MsgValueError;
            }
            auto maybe__channelId = IPC::ReadParam<uint64_t>((&(reader__)));
            if (!maybe__channelId) {
                FatalError("Error deserializing 'uint64_t'");
                return MsgValueError;

            }
            auto& channelId = *maybe__channelId;
            // Sentinel = 'channelId'
            if ((!(((&(reader__)))->ReadSentinel(301138823)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
                return MsgValueError;
            }
            reader__.EndRead();
            // Ensure the ID which was sent to us is valid, and reserve a spot
            // in the table for the new actor before we bother to alloc it.
            if (!ToplevelProtocol()->TryReserve(actorid__)) {
                NS_WARNING("Failed to reserve ActorId for constructor");
                return MsgValueError;
            }

            RefPtr<PHttpBackgroundChannelParent> actor = (this)->AllocPHttpBackgroundChannelParent(channelId);

            if (!actor) {
                NS_WARNING("Alloc function returned null");
                // Clean up the reservation taken above if this fails, to avoid
                // leaving zombie entries in the map.
                ToplevelProtocol()->ClearReservation(actorid__);
                return MsgValueError;
            }

            // NOTE: SetManagerAndRegister unconditionally consumes the
            // reservation taken by TryReserve, so we don't need to clear it on
            // failure.
            if (!actor->SetManagerAndRegister(this, actorid__)) {
                NS_WARNING("Failed to set manager for constructor");
                return MsgValueError;
            }
            mozilla::ipc::IPCResult __ok = (this)->RecvPHttpBackgroundChannelConstructor(actor, std::move(channelId));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PBackground::Msg_PSharedWorkerConstructor__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBackground", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBackgroundParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBackground::Msg_PSharedWorkerConstructor", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

            auto maybe__actorid__ = IPC::ReadParam<mozilla::ipc::ActorId>((&(reader__)));
            if (!maybe__actorid__) {
                FatalError("Error deserializing 'mozilla::ipc::ActorId'");
                return MsgValueError;

            }
            auto& actorid__ = *maybe__actorid__;
            // Sentinel = 'actorid'
            if ((!(((&(reader__)))->ReadSentinel(193725159)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'mozilla::ipc::ActorId'");
                return MsgValueError;
            }
            auto maybe__data = IPC::ReadParam<RemoteWorkerData>((&(reader__)));
            if (!maybe__data) {
                FatalError("Error deserializing 'RemoteWorkerData'");
                return MsgValueError;

            }
            auto& data = *maybe__data;
            // Sentinel = 'data'
            if ((!(((&(reader__)))->ReadSentinel(67109275)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'RemoteWorkerData'");
                return MsgValueError;
            }
            auto maybe__windowID = IPC::ReadParam<uint64_t>((&(reader__)));
            if (!maybe__windowID) {
                FatalError("Error deserializing 'uint64_t'");
                return MsgValueError;

            }
            auto& windowID = *maybe__windowID;
            // Sentinel = 'windowID'
            if ((!(((&(reader__)))->ReadSentinel(253625126)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
                return MsgValueError;
            }
            auto maybe__portIdentifier = IPC::ReadParam<MessagePortIdentifier>((&(reader__)));
            if (!maybe__portIdentifier) {
                FatalError("Error deserializing 'MessagePortIdentifier'");
                return MsgValueError;

            }
            auto& portIdentifier = *maybe__portIdentifier;
            // Sentinel = 'portIdentifier'
            if ((!(((&(reader__)))->ReadSentinel(729875913)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'MessagePortIdentifier'");
                return MsgValueError;
            }
            reader__.EndRead();
            // Ensure the ID which was sent to us is valid, and reserve a spot
            // in the table for the new actor before we bother to alloc it.
            if (!ToplevelProtocol()->TryReserve(actorid__)) {
                NS_WARNING("Failed to reserve ActorId for constructor");
                return MsgValueError;
            }

            PSharedWorkerParent* actor = (this)->AllocPSharedWorkerParent(data, windowID, portIdentifier);

            if (!actor) {
                NS_WARNING("Alloc function returned null");
                // Clean up the reservation taken above if this fails, to avoid
                // leaving zombie entries in the map.
                ToplevelProtocol()->ClearReservation(actorid__);
                return MsgValueError;
            }

            // NOTE: SetManagerAndRegister unconditionally consumes the
            // reservation taken by TryReserve, so we don't need to clear it on
            // failure.
            if (!actor->SetManagerAndRegister(this, actorid__)) {
                NS_WARNING("Failed to set manager for constructor");
                return MsgValueError;
            }
            mozilla::ipc::IPCResult __ok = (this)->RecvPSharedWorkerConstructor(std::move(actor), std::move(data), std::move(windowID), std::move(portIdentifier));
            if ((!(__ok))) {
                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("PBackground", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBackgroundParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBackground::Msg_PTemporaryIPCBlobConstructor", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

            auto maybe__actorid__ = IPC::ReadParam<mozilla::ipc::ActorId>((&(reader__)));
            if (!maybe__actorid__) {
                FatalError("Error deserializing 'mozilla::ipc::ActorId'");
                return MsgValueError;

            }
            auto& actorid__ = *maybe__actorid__;
            // Sentinel = 'actorid'
            if ((!(((&(reader__)))->ReadSentinel(193725159)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'mozilla::ipc::ActorId'");
                return MsgValueError;
            }
            reader__.EndRead();
            // Ensure the ID which was sent to us is valid, and reserve a spot
            // in the table for the new actor before we bother to alloc it.
            if (!ToplevelProtocol()->TryReserve(actorid__)) {
                NS_WARNING("Failed to reserve ActorId for constructor");
                return MsgValueError;
            }

            PTemporaryIPCBlobParent* actor = (this)->AllocPTemporaryIPCBlobParent();

            if (!actor) {
                NS_WARNING("Alloc function returned null");
                // Clean up the reservation taken above if this fails, to avoid
                // leaving zombie entries in the map.
                ToplevelProtocol()->ClearReservation(actorid__);
                return MsgValueError;
            }

            // NOTE: SetManagerAndRegister unconditionally consumes the
            // reservation taken by TryReserve, so we don't need to clear it on
            // failure.
            if (!actor->SetManagerAndRegister(this, actorid__)) {
                NS_WARNING("Failed to set manager for constructor");
                return MsgValueError;
            }
            mozilla::ipc::IPCResult __ok = (this)->RecvPTemporaryIPCBlobConstructor(std::move(actor));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PBackground::Msg_PFileCreatorConstructor__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBackground", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBackgroundParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBackground::Msg_PFileCreatorConstructor", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

            auto maybe__actorid__ = IPC::ReadParam<mozilla::ipc::ActorId>((&(reader__)));
            if (!maybe__actorid__) {
                FatalError("Error deserializing 'mozilla::ipc::ActorId'");
                return MsgValueError;

            }
            auto& actorid__ = *maybe__actorid__;
            // Sentinel = 'actorid'
            if ((!(((&(reader__)))->ReadSentinel(193725159)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'mozilla::ipc::ActorId'");
                return MsgValueError;
            }
            auto maybe__aFullPath = IPC::ReadParam<nsString>((&(reader__)));
            if (!maybe__aFullPath) {
                FatalError("Error deserializing 'nsString'");
                return MsgValueError;

            }
            auto& aFullPath = *maybe__aFullPath;
            // Sentinel = 'aFullPath'
            if ((!(((&(reader__)))->ReadSentinel(288097154)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsString'");
                return MsgValueError;
            }
            auto maybe__aType = IPC::ReadParam<nsString>((&(reader__)));
            if (!maybe__aType) {
                FatalError("Error deserializing 'nsString'");
                return MsgValueError;

            }
            auto& aType = *maybe__aType;
            // Sentinel = 'aType'
            if ((!(((&(reader__)))->ReadSentinel(99222020)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsString'");
                return MsgValueError;
            }
            auto maybe__aName = IPC::ReadParam<nsString>((&(reader__)));
            if (!maybe__aName) {
                FatalError("Error deserializing 'nsString'");
                return MsgValueError;

            }
            auto& aName = *maybe__aName;
            // Sentinel = 'aName'
            if ((!(((&(reader__)))->ReadSentinel(92537315)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsString'");
                return MsgValueError;
            }
            auto maybe__lastModified = IPC::ReadParam<mozilla::Maybe<int64_t>>((&(reader__)));
            if (!maybe__lastModified) {
                FatalError("Error deserializing 'int64_t?'");
                return MsgValueError;

            }
            auto& lastModified = *maybe__lastModified;
            // Sentinel = 'lastModified'
            if ((!(((&(reader__)))->ReadSentinel(531629270)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'int64_t?'");
                return MsgValueError;
            }
            auto maybe__aExistenceCheck = IPC::ReadParam<bool>((&(reader__)));
            if (!maybe__aExistenceCheck) {
                FatalError("Error deserializing 'bool'");
                return MsgValueError;

            }
            auto& aExistenceCheck = *maybe__aExistenceCheck;
            // Sentinel = 'aExistenceCheck'
            if ((!(((&(reader__)))->ReadSentinel(794822120)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
                return MsgValueError;
            }
            auto maybe__aIsFromNsIFile = IPC::ReadParam<bool>((&(reader__)));
            if (!maybe__aIsFromNsIFile) {
                FatalError("Error deserializing 'bool'");
                return MsgValueError;

            }
            auto& aIsFromNsIFile = *maybe__aIsFromNsIFile;
            // Sentinel = 'aIsFromNsIFile'
            if ((!(((&(reader__)))->ReadSentinel(655033660)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
                return MsgValueError;
            }
            reader__.EndRead();
            // Ensure the ID which was sent to us is valid, and reserve a spot
            // in the table for the new actor before we bother to alloc it.
            if (!ToplevelProtocol()->TryReserve(actorid__)) {
                NS_WARNING("Failed to reserve ActorId for constructor");
                return MsgValueError;
            }

            PFileCreatorParent* actor = (this)->AllocPFileCreatorParent(aFullPath, aType, aName, lastModified, aExistenceCheck, aIsFromNsIFile);

            if (!actor) {
                NS_WARNING("Alloc function returned null");
                // Clean up the reservation taken above if this fails, to avoid
                // leaving zombie entries in the map.
                ToplevelProtocol()->ClearReservation(actorid__);
                return MsgValueError;
            }

            // NOTE: SetManagerAndRegister unconditionally consumes the
            // reservation taken by TryReserve, so we don't need to clear it on
            // failure.
            if (!actor->SetManagerAndRegister(this, actorid__)) {
                NS_WARNING("Failed to set manager for constructor");
                return MsgValueError;
            }
            mozilla::ipc::IPCResult __ok = (this)->RecvPFileCreatorConstructor(std::move(actor), std::move(aFullPath), std::move(aType), std::move(aName), std::move(lastModified), std::move(aExistenceCheck), std::move(aIsFromNsIFile));
            if ((!(__ok))) {
                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("PBackground", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBackgroundParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBackground::Msg_PClientManagerConstructor", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

            auto maybe__actorid__ = IPC::ReadParam<mozilla::ipc::ActorId>((&(reader__)));
            if (!maybe__actorid__) {
                FatalError("Error deserializing 'mozilla::ipc::ActorId'");
                return MsgValueError;

            }
            auto& actorid__ = *maybe__actorid__;
            // Sentinel = 'actorid'
            if ((!(((&(reader__)))->ReadSentinel(193725159)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'mozilla::ipc::ActorId'");
                return MsgValueError;
            }
            reader__.EndRead();
            // Ensure the ID which was sent to us is valid, and reserve a spot
            // in the table for the new actor before we bother to alloc it.
            if (!ToplevelProtocol()->TryReserve(actorid__)) {
                NS_WARNING("Failed to reserve ActorId for constructor");
                return MsgValueError;
            }

            RefPtr<PClientManagerParent> actor = (this)->AllocPClientManagerParent();

            if (!actor) {
                NS_WARNING("Alloc function returned null");
                // Clean up the reservation taken above if this fails, to avoid
                // leaving zombie entries in the map.
                ToplevelProtocol()->ClearReservation(actorid__);
                return MsgValueError;
            }

            // NOTE: SetManagerAndRegister unconditionally consumes the
            // reservation taken by TryReserve, so we don't need to clear it on
            // failure.
            if (!actor->SetManagerAndRegister(this, actorid__)) {
                NS_WARNING("Failed to set manager for constructor");
                return MsgValueError;
            }
            mozilla::ipc::IPCResult __ok = (this)->RecvPClientManagerConstructor(actor);
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PBackground::Msg_CreateBoundStorageKeyParent__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBackground", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBackgroundParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBackground::Msg_CreateBoundStorageKeyParent", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

            auto maybe__aEndPoint = IPC::ReadParam<Endpoint<::mozilla::dom::cache::PBoundStorageKeyParent>>((&(reader__)));
            if (!maybe__aEndPoint) {
                FatalError("Error deserializing 'Endpoint<::mozilla::dom::cache::PBoundStorageKeyParent>'");
                return MsgValueError;

            }
            auto& aEndPoint = *maybe__aEndPoint;
            // Sentinel = 'aEndPoint'
            if ((!(((&(reader__)))->ReadSentinel(281740163)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'Endpoint<::mozilla::dom::cache::PBoundStorageKeyParent>'");
                return MsgValueError;
            }
            auto maybe__aNamespace = IPC::ReadParam<Namespace>((&(reader__)));
            if (!maybe__aNamespace) {
                FatalError("Error deserializing 'Namespace'");
                return MsgValueError;

            }
            auto& aNamespace = *maybe__aNamespace;
            // Sentinel = 'aNamespace'
            if ((!(((&(reader__)))->ReadSentinel(356516847)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'Namespace'");
                return MsgValueError;
            }
            auto maybe__aPrincipalInfo = IPC::ReadParam<PrincipalInfo>((&(reader__)));
            if (!maybe__aPrincipalInfo) {
                FatalError("Error deserializing 'PrincipalInfo'");
                return MsgValueError;

            }
            auto& aPrincipalInfo = *maybe__aPrincipalInfo;
            // Sentinel = 'aPrincipalInfo'
            if ((!(((&(reader__)))->ReadSentinel(695272848)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'PrincipalInfo'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (this)->RecvCreateBoundStorageKeyParent(std::move(aEndPoint), std::move(aNamespace), std::move(aPrincipalInfo));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PBackground::Msg_CreateMIDIManager__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBackground", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBackgroundParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBackground::Msg_CreateMIDIManager", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

            auto maybe__aEndpoint = IPC::ReadParam<Endpoint<::mozilla::dom::PMIDIManagerParent>>((&(reader__)));
            if (!maybe__aEndpoint) {
                FatalError("Error deserializing 'Endpoint<::mozilla::dom::PMIDIManagerParent>'");
                return MsgValueError;

            }
            auto& aEndpoint = *maybe__aEndpoint;
            // Sentinel = 'aEndpoint'
            if ((!(((&(reader__)))->ReadSentinel(292225955)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'Endpoint<::mozilla::dom::PMIDIManagerParent>'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (this)->RecvCreateMIDIManager(std::move(aEndpoint));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PBackground::Msg_CreateMIDIPort__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBackground", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBackgroundParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBackground::Msg_CreateMIDIPort", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

            auto maybe__aEndpoint = IPC::ReadParam<Endpoint<::mozilla::dom::PMIDIPortParent>>((&(reader__)));
            if (!maybe__aEndpoint) {
                FatalError("Error deserializing 'Endpoint<::mozilla::dom::PMIDIPortParent>'");
                return MsgValueError;

            }
            auto& aEndpoint = *maybe__aEndpoint;
            // Sentinel = 'aEndpoint'
            if ((!(((&(reader__)))->ReadSentinel(292225955)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'Endpoint<::mozilla::dom::PMIDIPortParent>'");
                return MsgValueError;
            }
            auto maybe__portInfo = IPC::ReadParam<MIDIPortInfo>((&(reader__)));
            if (!maybe__portInfo) {
                FatalError("Error deserializing 'MIDIPortInfo'");
                return MsgValueError;

            }
            auto& portInfo = *maybe__portInfo;
            // Sentinel = 'portInfo'
            if ((!(((&(reader__)))->ReadSentinel(254411602)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'MIDIPortInfo'");
                return MsgValueError;
            }
            auto maybe__sysexEnabled = IPC::ReadParam<bool>((&(reader__)));
            if (!maybe__sysexEnabled) {
                FatalError("Error deserializing 'bool'");
                return MsgValueError;

            }
            auto& sysexEnabled = *maybe__sysexEnabled;
            // Sentinel = 'sysexEnabled'
            if ((!(((&(reader__)))->ReadSentinel(549717224)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (this)->RecvCreateMIDIPort(std::move(aEndpoint), std::move(portInfo), std::move(sysexEnabled));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PBackground::Msg_HasMIDIDevice__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBackground", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBackgroundParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBackground::Msg_HasMIDIDevice", OTHER);

            mozilla::ipc::ActorId id__ = MSG_ROUTING_CONTROL;
            UniquePtr<IPC::Message> reply__(PBackground::Reply_HasMIDIDevice(id__));
            reply__->set_seqno(msg__.seqno());

            RefPtr<mozilla::ipc::IPDLResolverInner> resolver__ =
                new mozilla::ipc::IPDLResolverInner(std::move(reply__), this);

            HasMIDIDeviceResolver resolver = [resolver__ = std::move(resolver__)](const bool& aParam) {
                resolver__->Resolve([&] (IPC::Message* reply__, IProtocol* self__) {
                    IPC::MessageWriter writer__(*reply__, self__);
                    IPC::WriteParam((&(writer__)), aParam);
                    // Sentinel = 'hasDevice'
                    ((&(writer__)))->WriteSentinel(296551309);

                    if (mozilla::ipc::LoggingEnabledFor("PBackground", mozilla::ipc::ParentSide)) {
                        mozilla::ipc::LogMessageForProtocol(
                            "PBackgroundParent",
                            self__->ToplevelProtocol()->OtherPidMaybeInvalid(),
                            "Sending reply ",
                            reply__->type(),
                            mozilla::ipc::MessageDirection::eSending);
                    }

                });
            };
            mozilla::ipc::IPCResult __ok = (this)->RecvHasMIDIDevice(std::move(resolver));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PBackground::Msg_CreateMLSTransaction__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBackground", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBackgroundParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBackground::Msg_CreateMLSTransaction", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

            auto maybe__aEndpoint = IPC::ReadParam<Endpoint<::mozilla::dom::PMLSTransactionParent>>((&(reader__)));
            if (!maybe__aEndpoint) {
                FatalError("Error deserializing 'Endpoint<::mozilla::dom::PMLSTransactionParent>'");
                return MsgValueError;

            }
            auto& aEndpoint = *maybe__aEndpoint;
            // Sentinel = 'aEndpoint'
            if ((!(((&(reader__)))->ReadSentinel(292225955)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'Endpoint<::mozilla::dom::PMLSTransactionParent>'");
                return MsgValueError;
            }
            auto maybe__aPrincipal = IPC::ReadParam<mozilla::NotNull<RefPtr<nsIPrincipal>>>((&(reader__)));
            if (!maybe__aPrincipal) {
                FatalError("Error deserializing 'NotNull<nsIPrincipal>'");
                return MsgValueError;

            }
            auto& aPrincipal = *maybe__aPrincipal;
            // Sentinel = 'aPrincipal'
            if ((!(((&(reader__)))->ReadSentinel(364381188)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'NotNull<nsIPrincipal>'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (this)->RecvCreateMLSTransaction(std::move(aEndpoint), aPrincipal);
            if ((!(__ok))) {
                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("PBackground", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBackgroundParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBackground::Msg_StorageActivity", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

            auto maybe__principalInfo = IPC::ReadParam<PrincipalInfo>((&(reader__)));
            if (!maybe__principalInfo) {
                FatalError("Error deserializing 'PrincipalInfo'");
                return MsgValueError;

            }
            auto& principalInfo = *maybe__principalInfo;
            // Sentinel = 'principalInfo'
            if ((!(((&(reader__)))->ReadSentinel(633472335)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'PrincipalInfo'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (this)->RecvStorageActivity(std::move(principalInfo));
            if ((!(__ok))) {
                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("PBackground", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBackgroundParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBackground::Msg_PServiceWorkerConstructor", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

            auto maybe__actorid__ = IPC::ReadParam<mozilla::ipc::ActorId>((&(reader__)));
            if (!maybe__actorid__) {
                FatalError("Error deserializing 'mozilla::ipc::ActorId'");
                return MsgValueError;

            }
            auto& actorid__ = *maybe__actorid__;
            // Sentinel = 'actorid'
            if ((!(((&(reader__)))->ReadSentinel(193725159)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'mozilla::ipc::ActorId'");
                return MsgValueError;
            }
            auto maybe__aDescriptor = IPC::ReadParam<IPCServiceWorkerDescriptor>((&(reader__)));
            if (!maybe__aDescriptor) {
                FatalError("Error deserializing 'IPCServiceWorkerDescriptor'");
                return MsgValueError;

            }
            auto& aDescriptor = *maybe__aDescriptor;
            // Sentinel = 'aDescriptor'
            if ((!(((&(reader__)))->ReadSentinel(433915009)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'IPCServiceWorkerDescriptor'");
                return MsgValueError;
            }
            reader__.EndRead();
            // Ensure the ID which was sent to us is valid, and reserve a spot
            // in the table for the new actor before we bother to alloc it.
            if (!ToplevelProtocol()->TryReserve(actorid__)) {
                NS_WARNING("Failed to reserve ActorId for constructor");
                return MsgValueError;
            }

            RefPtr<PServiceWorkerParent> actor = (this)->AllocPServiceWorkerParent(aDescriptor);

            if (!actor) {
                NS_WARNING("Alloc function returned null");
                // Clean up the reservation taken above if this fails, to avoid
                // leaving zombie entries in the map.
                ToplevelProtocol()->ClearReservation(actorid__);
                return MsgValueError;
            }

            // NOTE: SetManagerAndRegister unconditionally consumes the
            // reservation taken by TryReserve, so we don't need to clear it on
            // failure.
            if (!actor->SetManagerAndRegister(this, actorid__)) {
                NS_WARNING("Failed to set manager for constructor");
                return MsgValueError;
            }
            mozilla::ipc::IPCResult __ok = (this)->RecvPServiceWorkerConstructor(actor, std::move(aDescriptor));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PBackground::Msg_PRemoteWorkerControllerConstructor__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBackground", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBackgroundParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBackground::Msg_PRemoteWorkerControllerConstructor", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

            auto maybe__actorid__ = IPC::ReadParam<mozilla::ipc::ActorId>((&(reader__)));
            if (!maybe__actorid__) {
                FatalError("Error deserializing 'mozilla::ipc::ActorId'");
                return MsgValueError;

            }
            auto& actorid__ = *maybe__actorid__;
            // Sentinel = 'actorid'
            if ((!(((&(reader__)))->ReadSentinel(193725159)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'mozilla::ipc::ActorId'");
                return MsgValueError;
            }
            auto maybe__aData = IPC::ReadParam<RemoteWorkerData>((&(reader__)));
            if (!maybe__aData) {
                FatalError("Error deserializing 'RemoteWorkerData'");
                return MsgValueError;

            }
            auto& aData = *maybe__aData;
            // Sentinel = 'aData'
            if ((!(((&(reader__)))->ReadSentinel(90571228)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'RemoteWorkerData'");
                return MsgValueError;
            }
            reader__.EndRead();
            // Ensure the ID which was sent to us is valid, and reserve a spot
            // in the table for the new actor before we bother to alloc it.
            if (!ToplevelProtocol()->TryReserve(actorid__)) {
                NS_WARNING("Failed to reserve ActorId for constructor");
                return MsgValueError;
            }

            RefPtr<PRemoteWorkerControllerParent> actor = (this)->AllocPRemoteWorkerControllerParent(aData);

            if (!actor) {
                NS_WARNING("Alloc function returned null");
                // Clean up the reservation taken above if this fails, to avoid
                // leaving zombie entries in the map.
                ToplevelProtocol()->ClearReservation(actorid__);
                return MsgValueError;
            }

            // NOTE: SetManagerAndRegister unconditionally consumes the
            // reservation taken by TryReserve, so we don't need to clear it on
            // failure.
            if (!actor->SetManagerAndRegister(this, actorid__)) {
                NS_WARNING("Failed to set manager for constructor");
                return MsgValueError;
            }
            mozilla::ipc::IPCResult __ok = (this)->RecvPRemoteWorkerControllerConstructor(actor, std::move(aData));
            if ((!(__ok))) {
                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("PBackground", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBackgroundParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBackground::Msg_PServiceWorkerContainerConstructor", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

            auto maybe__actorid__ = IPC::ReadParam<mozilla::ipc::ActorId>((&(reader__)));
            if (!maybe__actorid__) {
                FatalError("Error deserializing 'mozilla::ipc::ActorId'");
                return MsgValueError;

            }
            auto& actorid__ = *maybe__actorid__;
            // Sentinel = 'actorid'
            if ((!(((&(reader__)))->ReadSentinel(193725159)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'mozilla::ipc::ActorId'");
                return MsgValueError;
            }
            reader__.EndRead();
            // Ensure the ID which was sent to us is valid, and reserve a spot
            // in the table for the new actor before we bother to alloc it.
            if (!ToplevelProtocol()->TryReserve(actorid__)) {
                NS_WARNING("Failed to reserve ActorId for constructor");
                return MsgValueError;
            }

            RefPtr<PServiceWorkerContainerParent> actor = (this)->AllocPServiceWorkerContainerParent();

            if (!actor) {
                NS_WARNING("Alloc function returned null");
                // Clean up the reservation taken above if this fails, to avoid
                // leaving zombie entries in the map.
                ToplevelProtocol()->ClearReservation(actorid__);
                return MsgValueError;
            }

            // NOTE: SetManagerAndRegister unconditionally consumes the
            // reservation taken by TryReserve, so we don't need to clear it on
            // failure.
            if (!actor->SetManagerAndRegister(this, actorid__)) {
                NS_WARNING("Failed to set manager for constructor");
                return MsgValueError;
            }
            mozilla::ipc::IPCResult __ok = (this)->RecvPServiceWorkerContainerConstructor(actor);
            if ((!(__ok))) {
                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("PBackground", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBackgroundParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBackground::Msg_PServiceWorkerRegistrationConstructor", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

            auto maybe__actorid__ = IPC::ReadParam<mozilla::ipc::ActorId>((&(reader__)));
            if (!maybe__actorid__) {
                FatalError("Error deserializing 'mozilla::ipc::ActorId'");
                return MsgValueError;

            }
            auto& actorid__ = *maybe__actorid__;
            // Sentinel = 'actorid'
            if ((!(((&(reader__)))->ReadSentinel(193725159)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'mozilla::ipc::ActorId'");
                return MsgValueError;
            }
            auto maybe__aDescriptor = IPC::ReadParam<IPCServiceWorkerRegistrationDescriptor>((&(reader__)));
            if (!maybe__aDescriptor) {
                FatalError("Error deserializing 'IPCServiceWorkerRegistrationDescriptor'");
                return MsgValueError;

            }
            auto& aDescriptor = *maybe__aDescriptor;
            // Sentinel = 'aDescriptor'
            if ((!(((&(reader__)))->ReadSentinel(433915009)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'IPCServiceWorkerRegistrationDescriptor'");
                return MsgValueError;
            }
            auto maybe__aForClient = IPC::ReadParam<IPCClientInfo>((&(reader__)));
            if (!maybe__aForClient) {
                FatalError("Error deserializing 'IPCClientInfo'");
                return MsgValueError;

            }
            auto& aForClient = *maybe__aForClient;
            // Sentinel = 'aForClient'
            if ((!(((&(reader__)))->ReadSentinel(347145192)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'IPCClientInfo'");
                return MsgValueError;
            }
            reader__.EndRead();
            // Ensure the ID which was sent to us is valid, and reserve a spot
            // in the table for the new actor before we bother to alloc it.
            if (!ToplevelProtocol()->TryReserve(actorid__)) {
                NS_WARNING("Failed to reserve ActorId for constructor");
                return MsgValueError;
            }

            RefPtr<PServiceWorkerRegistrationParent> actor = (this)->AllocPServiceWorkerRegistrationParent(aDescriptor, aForClient);

            if (!actor) {
                NS_WARNING("Alloc function returned null");
                // Clean up the reservation taken above if this fails, to avoid
                // leaving zombie entries in the map.
                ToplevelProtocol()->ClearReservation(actorid__);
                return MsgValueError;
            }

            // NOTE: SetManagerAndRegister unconditionally consumes the
            // reservation taken by TryReserve, so we don't need to clear it on
            // failure.
            if (!actor->SetManagerAndRegister(this, actorid__)) {
                NS_WARNING("Failed to set manager for constructor");
                return MsgValueError;
            }
            mozilla::ipc::IPCResult __ok = (this)->RecvPServiceWorkerRegistrationConstructor(actor, std::move(aDescriptor), std::move(aForClient));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PBackground::Msg_PIdleSchedulerConstructor__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBackground", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBackgroundParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBackground::Msg_PIdleSchedulerConstructor", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

            auto maybe__actorid__ = IPC::ReadParam<mozilla::ipc::ActorId>((&(reader__)));
            if (!maybe__actorid__) {
                FatalError("Error deserializing 'mozilla::ipc::ActorId'");
                return MsgValueError;

            }
            auto& actorid__ = *maybe__actorid__;
            // Sentinel = 'actorid'
            if ((!(((&(reader__)))->ReadSentinel(193725159)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'mozilla::ipc::ActorId'");
                return MsgValueError;
            }
            reader__.EndRead();
            // Ensure the ID which was sent to us is valid, and reserve a spot
            // in the table for the new actor before we bother to alloc it.
            if (!ToplevelProtocol()->TryReserve(actorid__)) {
                NS_WARNING("Failed to reserve ActorId for constructor");
                return MsgValueError;
            }

            RefPtr<PIdleSchedulerParent> actor = (this)->AllocPIdleSchedulerParent();

            if (!actor) {
                NS_WARNING("Alloc function returned null");
                // Clean up the reservation taken above if this fails, to avoid
                // leaving zombie entries in the map.
                ToplevelProtocol()->ClearReservation(actorid__);
                return MsgValueError;
            }

            // NOTE: SetManagerAndRegister unconditionally consumes the
            // reservation taken by TryReserve, so we don't need to clear it on
            // failure.
            if (!actor->SetManagerAndRegister(this, actorid__)) {
                NS_WARNING("Failed to set manager for constructor");
                return MsgValueError;
            }
            mozilla::ipc::IPCResult __ok = (this)->RecvPIdleSchedulerConstructor(actor);
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PBackground::Msg_EnsureRDDProcessAndCreateBridge__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBackground", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBackgroundParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBackground::Msg_EnsureRDDProcessAndCreateBridge", OTHER);

            mozilla::ipc::ActorId id__ = MSG_ROUTING_CONTROL;
            UniquePtr<IPC::Message> reply__(PBackground::Reply_EnsureRDDProcessAndCreateBridge(id__));
            reply__->set_seqno(msg__.seqno());

            RefPtr<mozilla::ipc::IPDLResolverInner> resolver__ =
                new mozilla::ipc::IPDLResolverInner(std::move(reply__), this);

            EnsureRDDProcessAndCreateBridgeResolver resolver = [resolver__ = std::move(resolver__)](std::tuple<const nsresult&, Endpoint<::mozilla::PRemoteMediaManagerChild>&&> aParam) {
                resolver__->Resolve([&] (IPC::Message* reply__, IProtocol* self__) {
                    IPC::MessageWriter writer__(*reply__, self__);
                    IPC::WriteParam((&(writer__)), std::get<0>(aParam));
                    // Sentinel = 'rv'
                    ((&(writer__)))->WriteSentinel(22806761);
                    IPC::WriteParam((&(writer__)), std::move(std::get<1>(aParam)));
                    // Sentinel = 'aEndpoint'
                    ((&(writer__)))->WriteSentinel(292225955);

                    if (mozilla::ipc::LoggingEnabledFor("PBackground", mozilla::ipc::ParentSide)) {
                        mozilla::ipc::LogMessageForProtocol(
                            "PBackgroundParent",
                            self__->ToplevelProtocol()->OtherPidMaybeInvalid(),
                            "Sending reply ",
                            reply__->type(),
                            mozilla::ipc::MessageDirection::eSending);
                    }

                });
            };
            mozilla::ipc::IPCResult __ok = (this)->RecvEnsureRDDProcessAndCreateBridge(std::move(resolver));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PBackground::Msg_EnsureUtilityProcessAndCreateBridge__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBackground", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBackgroundParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBackground::Msg_EnsureUtilityProcessAndCreateBridge", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

            auto maybe__aLocation = IPC::ReadParam<RemoteMediaIn>((&(reader__)));
            if (!maybe__aLocation) {
                FatalError("Error deserializing 'RemoteMediaIn'");
                return MsgValueError;

            }
            auto& aLocation = *maybe__aLocation;
            // Sentinel = 'aLocation'
            if ((!(((&(reader__)))->ReadSentinel(292094875)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'RemoteMediaIn'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::ActorId id__ = MSG_ROUTING_CONTROL;
            UniquePtr<IPC::Message> reply__(PBackground::Reply_EnsureUtilityProcessAndCreateBridge(id__));
            reply__->set_seqno(msg__.seqno());

            RefPtr<mozilla::ipc::IPDLResolverInner> resolver__ =
                new mozilla::ipc::IPDLResolverInner(std::move(reply__), this);

            EnsureUtilityProcessAndCreateBridgeResolver resolver = [resolver__ = std::move(resolver__)](std::tuple<const nsresult&, Endpoint<::mozilla::PRemoteMediaManagerChild>&&> aParam) {
                resolver__->Resolve([&] (IPC::Message* reply__, IProtocol* self__) {
                    IPC::MessageWriter writer__(*reply__, self__);
                    IPC::WriteParam((&(writer__)), std::get<0>(aParam));
                    // Sentinel = 'rv'
                    ((&(writer__)))->WriteSentinel(22806761);
                    IPC::WriteParam((&(writer__)), std::move(std::get<1>(aParam)));
                    // Sentinel = 'aEndpoint'
                    ((&(writer__)))->WriteSentinel(292225955);

                    if (mozilla::ipc::LoggingEnabledFor("PBackground", mozilla::ipc::ParentSide)) {
                        mozilla::ipc::LogMessageForProtocol(
                            "PBackgroundParent",
                            self__->ToplevelProtocol()->OtherPidMaybeInvalid(),
                            "Sending reply ",
                            reply__->type(),
                            mozilla::ipc::MessageDirection::eSending);
                    }

                });
            };
            mozilla::ipc::IPCResult __ok = (this)->RecvEnsureUtilityProcessAndCreateBridge(std::move(aLocation), std::move(resolver));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PBackground::Msg_PLockManagerConstructor__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBackground", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBackgroundParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBackground::Msg_PLockManagerConstructor", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

            auto maybe__actorid__ = IPC::ReadParam<mozilla::ipc::ActorId>((&(reader__)));
            if (!maybe__actorid__) {
                FatalError("Error deserializing 'mozilla::ipc::ActorId'");
                return MsgValueError;

            }
            auto& actorid__ = *maybe__actorid__;
            // Sentinel = 'actorid'
            if ((!(((&(reader__)))->ReadSentinel(193725159)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'mozilla::ipc::ActorId'");
                return MsgValueError;
            }
            auto maybe__aPrincipalInfo = IPC::ReadParam<mozilla::NotNull<RefPtr<nsIPrincipal>>>((&(reader__)));
            if (!maybe__aPrincipalInfo) {
                FatalError("Error deserializing 'NotNull<nsIPrincipal>'");
                return MsgValueError;

            }
            auto& aPrincipalInfo = *maybe__aPrincipalInfo;
            // Sentinel = 'aPrincipalInfo'
            if ((!(((&(reader__)))->ReadSentinel(695272848)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'NotNull<nsIPrincipal>'");
                return MsgValueError;
            }
            auto maybe__aClientId = IPC::ReadParam<mozilla::Maybe<nsID>>((&(reader__)));
            if (!maybe__aClientId) {
                FatalError("Error deserializing 'nsID?'");
                return MsgValueError;

            }
            auto& aClientId = *maybe__aClientId;
            // Sentinel = 'aClientId'
            if ((!(((&(reader__)))->ReadSentinel(284623726)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsID?'");
                return MsgValueError;
            }
            reader__.EndRead();
            // Ensure the ID which was sent to us is valid, and reserve a spot
            // in the table for the new actor before we bother to alloc it.
            if (!ToplevelProtocol()->TryReserve(actorid__)) {
                NS_WARNING("Failed to reserve ActorId for constructor");
                return MsgValueError;
            }

            RefPtr<PLockManagerParent> actor = (this)->AllocPLockManagerParent(aPrincipalInfo, aClientId);

            if (!actor) {
                NS_WARNING("Alloc function returned null");
                // Clean up the reservation taken above if this fails, to avoid
                // leaving zombie entries in the map.
                ToplevelProtocol()->ClearReservation(actorid__);
                return MsgValueError;
            }

            // NOTE: SetManagerAndRegister unconditionally consumes the
            // reservation taken by TryReserve, so we don't need to clear it on
            // failure.
            if (!actor->SetManagerAndRegister(this, actorid__)) {
                NS_WARNING("Failed to set manager for constructor");
                return MsgValueError;
            }
            mozilla::ipc::IPCResult __ok = (this)->RecvPLockManagerConstructor(actor, aPrincipalInfo, std::move(aClientId));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PBackground::Msg_PFetchConstructor__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBackground", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBackgroundParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBackground::Msg_PFetchConstructor", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

            auto maybe__actorid__ = IPC::ReadParam<mozilla::ipc::ActorId>((&(reader__)));
            if (!maybe__actorid__) {
                FatalError("Error deserializing 'mozilla::ipc::ActorId'");
                return MsgValueError;

            }
            auto& actorid__ = *maybe__actorid__;
            // Sentinel = 'actorid'
            if ((!(((&(reader__)))->ReadSentinel(193725159)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'mozilla::ipc::ActorId'");
                return MsgValueError;
            }
            reader__.EndRead();
            // Ensure the ID which was sent to us is valid, and reserve a spot
            // in the table for the new actor before we bother to alloc it.
            if (!ToplevelProtocol()->TryReserve(actorid__)) {
                NS_WARNING("Failed to reserve ActorId for constructor");
                return MsgValueError;
            }

            RefPtr<PFetchParent> actor = (this)->AllocPFetchParent();

            if (!actor) {
                NS_WARNING("Alloc function returned null");
                // Clean up the reservation taken above if this fails, to avoid
                // leaving zombie entries in the map.
                ToplevelProtocol()->ClearReservation(actorid__);
                return MsgValueError;
            }

            // NOTE: SetManagerAndRegister unconditionally consumes the
            // reservation taken by TryReserve, so we don't need to clear it on
            // failure.
            if (!actor->SetManagerAndRegister(this, actorid__)) {
                NS_WARNING("Failed to set manager for constructor");
                return MsgValueError;
            }
            mozilla::ipc::IPCResult __ok = (this)->RecvPFetchConstructor(actor);
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PBackground::Msg_RequestCameraAccess__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBackground", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBackgroundParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBackground::Msg_RequestCameraAccess", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

            auto maybe__aAllowPermissionRequest = IPC::ReadParam<bool>((&(reader__)));
            if (!maybe__aAllowPermissionRequest) {
                FatalError("Error deserializing 'bool'");
                return MsgValueError;

            }
            auto& aAllowPermissionRequest = *maybe__aAllowPermissionRequest;
            // Sentinel = 'aAllowPermissionRequest'
            if ((!(((&(reader__)))->ReadSentinel(1859651955)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::ActorId id__ = MSG_ROUTING_CONTROL;
            UniquePtr<IPC::Message> reply__(PBackground::Reply_RequestCameraAccess(id__));
            reply__->set_seqno(msg__.seqno());

            RefPtr<mozilla::ipc::IPDLResolverInner> resolver__ =
                new mozilla::ipc::IPDLResolverInner(std::move(reply__), this);

            RequestCameraAccessResolver resolver = [resolver__ = std::move(resolver__)](const CamerasAccessStatus& aParam) {
                resolver__->Resolve([&] (IPC::Message* reply__, IProtocol* self__) {
                    IPC::MessageWriter writer__(*reply__, self__);
                    IPC::WriteParam((&(writer__)), aParam);
                    // Sentinel = 'rv'
                    ((&(writer__)))->WriteSentinel(22806761);

                    if (mozilla::ipc::LoggingEnabledFor("PBackground", mozilla::ipc::ParentSide)) {
                        mozilla::ipc::LogMessageForProtocol(
                            "PBackgroundParent",
                            self__->ToplevelProtocol()->OtherPidMaybeInvalid(),
                            "Sending reply ",
                            reply__->type(),
                            mozilla::ipc::MessageDirection::eSending);
                    }

                });
            };
            mozilla::ipc::IPCResult __ok = (this)->RecvRequestCameraAccess(std::move(aAllowPermissionRequest), std::move(resolver));
            if ((!(__ok))) {
                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;
        }
    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__,
        UniquePtr<Message>& reply__) -> PBackgroundParent::Result
{
    if (!CanSend()) {
        return MsgDropped;

    }
    IPC::Message::routeid_t route__ = msg__.routing_id();
    if (MSG_ROUTING_CONTROL != route__) {
        IProtocol* routed__ = Lookup(route__);
        if (!routed__ || !routed__->GetLifecycleProxy()) {
            return MsgDropped;

        }

        RefPtr<mozilla::ipc::ActorLifecycleProxy> proxy__ =
            routed__->GetLifecycleProxy();
        return proxy__->Get()->OnMessageReceived(msg__, reply__);
    }

    return MsgNotKnown;
}



} // namespace ipc
} // namespace mozilla