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

#ifndef PBackgroundChild_h
#define PBackgroundChild_h

#include "mozilla/ipc/PBackground.h"
#ifdef DEBUG
#include "prenv.h"
#endif  // DEBUG

#include "mozilla/Tainting.h"
#include "mozilla/ipc/MessageChannel.h"
#include "mozilla/ipc/ProtocolUtils.h"
// Headers for things that cannot be forward declared
#include "Units.h"
#include "mozilla/ErrorResult.h"
#include "mozilla/HalIPCUtils.h"
#include "mozilla/OriginTrialsIPCUtils.h"
#include "mozilla/RemoteMediaManagerChild.h"
#include "mozilla/ScrollbarPreferences.h"
#include "mozilla/StorageAccess.h"
#include "mozilla/TimeStamp.h"
#include "mozilla/dom/BindingDeclarations.h"
#include "mozilla/dom/BrowsingContext.h"
#include "mozilla/dom/ClientBinding.h"
#include "mozilla/dom/ClientsBinding.h"
#include "mozilla/dom/DocumentBinding.h"
#include "mozilla/dom/IDBCursor.h"
#include "mozilla/dom/IndexedDatabase.h"
#include "mozilla/dom/IntegrityPolicy.h"
#include "mozilla/dom/LSValue.h"
#include "mozilla/dom/LoadURIOptionsBinding.h"
#include "mozilla/dom/NavigationBinding.h"
#include "mozilla/dom/NotificationBinding.h"
#include "mozilla/dom/ServiceWorkerBinding.h"
#include "mozilla/dom/ServiceWorkerRegistrationBinding.h"
#include "mozilla/dom/UserNavigationInvolvement.h"
#include "mozilla/dom/WorkerBinding.h"
#include "mozilla/dom/cache/Types.h"
#include "mozilla/dom/quota/PersistenceType.h"
#include "mozilla/gfx/Types.h"
#include "mozilla/ipc/BackgroundUtils.h"
#include "mozilla/ipc/SerializedStructuredCloneBuffer.h"
#include "mozilla/media/CamerasTypes.h"
#include "mozilla/net/ClassOfService.h"
#include "nsIClassifiedChannel.h"
#include "nsIContentSecurityPolicy.h"
#include "nsILoadInfo.h"
#include "nsIWidgetListener.h"
#include "nsRFPService.h"

namespace mozilla {
namespace net {
class PBackgroundDataBridgeChild;
} // namespace net
} // namespace mozilla
namespace mozilla {
namespace net {
class PBackgroundDataBridgeParent;
} // namespace net
} // namespace mozilla

namespace mozilla {
namespace dom {
namespace indexedDB {
class PBackgroundIDBFactoryChild;
} // namespace indexedDB
} // namespace dom
} // namespace mozilla
namespace mozilla {
namespace dom {
namespace indexedDB {
class PBackgroundIDBFactoryParent;
} // namespace indexedDB
} // namespace dom
} // namespace mozilla

namespace mozilla {
namespace dom {
namespace indexedDB {
class PBackgroundIndexedDBUtilsChild;
} // namespace indexedDB
} // namespace dom
} // namespace mozilla
namespace mozilla {
namespace dom {
namespace indexedDB {
class PBackgroundIndexedDBUtilsParent;
} // namespace indexedDB
} // namespace dom
} // namespace mozilla

namespace mozilla {
namespace dom {
class PBackgroundSDBConnectionChild;
} // namespace dom
} // namespace mozilla
namespace mozilla {
namespace dom {
class PBackgroundSDBConnectionParent;
} // namespace dom
} // namespace mozilla

namespace mozilla {
namespace dom {
class PBackgroundLSObserverChild;
} // namespace dom
} // namespace mozilla
namespace mozilla {
namespace dom {
class PBackgroundLSObserverParent;
} // namespace dom
} // namespace mozilla

namespace mozilla {
namespace dom {
class PBackgroundLSRequestChild;
} // namespace dom
} // namespace mozilla
namespace mozilla {
namespace dom {
class PBackgroundLSRequestParent;
} // namespace dom
} // namespace mozilla

namespace mozilla {
namespace dom {
class PBackgroundLSSimpleRequestChild;
} // namespace dom
} // namespace mozilla
namespace mozilla {
namespace dom {
class PBackgroundLSSimpleRequestParent;
} // namespace dom
} // namespace mozilla

namespace mozilla {
namespace dom {
class PBackgroundLocalStorageCacheChild;
} // namespace dom
} // namespace mozilla
namespace mozilla {
namespace dom {
class PBackgroundLocalStorageCacheParent;
} // namespace dom
} // namespace mozilla

namespace mozilla {
namespace dom {
class PBackgroundSessionStorageManagerChild;
} // namespace dom
} // namespace mozilla
namespace mozilla {
namespace dom {
class PBackgroundSessionStorageManagerParent;
} // namespace dom
} // namespace mozilla

namespace mozilla {
namespace dom {
class PBackgroundSessionStorageServiceChild;
} // namespace dom
} // namespace mozilla
namespace mozilla {
namespace dom {
class PBackgroundSessionStorageServiceParent;
} // namespace dom
} // namespace mozilla

namespace mozilla {
namespace dom {
class PBackgroundStorageChild;
} // namespace dom
} // namespace mozilla
namespace mozilla {
namespace dom {
class PBackgroundStorageParent;
} // namespace dom
} // namespace mozilla

namespace mozilla {
namespace ipc {
class PBackgroundTestChild;
} // namespace ipc
} // namespace mozilla
namespace mozilla {
namespace ipc {
class PBackgroundTestParent;
} // namespace ipc
} // namespace mozilla

namespace mozilla {
namespace dom {
namespace cache {
class PBoundStorageKeyChild;
} // namespace cache
} // namespace dom
} // namespace mozilla
namespace mozilla {
namespace dom {
namespace cache {
class PBoundStorageKeyParent;
} // namespace cache
} // namespace dom
} // namespace mozilla

namespace mozilla {
namespace dom {
class PBroadcastChannelChild;
} // namespace dom
} // namespace mozilla
namespace mozilla {
namespace dom {
class PBroadcastChannelParent;
} // namespace dom
} // namespace mozilla

namespace mozilla {
namespace dom {
namespace cache {
class PCacheChild;
} // namespace cache
} // namespace dom
} // namespace mozilla
namespace mozilla {
namespace dom {
namespace cache {
class PCacheParent;
} // namespace cache
} // namespace dom
} // namespace mozilla

namespace mozilla {
namespace dom {
namespace cache {
class PCacheStorageChild;
} // namespace cache
} // namespace dom
} // namespace mozilla
namespace mozilla {
namespace dom {
namespace cache {
class PCacheStorageParent;
} // namespace cache
} // namespace dom
} // namespace mozilla

namespace mozilla {
namespace dom {
namespace cache {
class PCacheStreamControlChild;
} // namespace cache
} // namespace dom
} // namespace mozilla
namespace mozilla {
namespace dom {
namespace cache {
class PCacheStreamControlParent;
} // namespace cache
} // namespace dom
} // namespace mozilla

namespace mozilla {
namespace dom {
class PClientManagerChild;
} // namespace dom
} // namespace mozilla
namespace mozilla {
namespace dom {
class PClientManagerParent;
} // namespace dom
} // namespace mozilla

namespace mozilla {
namespace dom {
class PCookieStoreChild;
} // namespace dom
} // namespace mozilla
namespace mozilla {
namespace dom {
class PCookieStoreParent;
} // namespace dom
} // namespace mozilla

namespace mozilla {
namespace dom {
class PEndpointForReportChild;
} // namespace dom
} // namespace mozilla
namespace mozilla {
namespace dom {
class PEndpointForReportParent;
} // namespace dom
} // namespace mozilla

namespace mozilla {
namespace dom {
class PFileSystemManagerChild;
} // namespace dom
} // namespace mozilla
namespace mozilla {
namespace dom {
class PFileSystemManagerParent;
} // namespace dom
} // namespace mozilla

namespace mozilla {
namespace dom {
class PFileSystemRequestChild;
} // namespace dom
} // namespace mozilla
namespace mozilla {
namespace dom {
class PFileSystemRequestParent;
} // namespace dom
} // namespace mozilla

namespace mozilla {
namespace dom {
class PGamepadEventChannelChild;
} // namespace dom
} // namespace mozilla
namespace mozilla {
namespace dom {
class PGamepadEventChannelParent;
} // namespace dom
} // namespace mozilla

namespace mozilla {
namespace dom {
class PGamepadTestChannelChild;
} // namespace dom
} // namespace mozilla
namespace mozilla {
namespace dom {
class PGamepadTestChannelParent;
} // namespace dom
} // namespace mozilla

namespace mozilla {
namespace net {
class PHttpBackgroundChannelChild;
} // namespace net
} // namespace mozilla
namespace mozilla {
namespace net {
class PHttpBackgroundChannelParent;
} // namespace net
} // namespace mozilla

namespace mozilla {
namespace ipc {
class PIdleSchedulerChild;
} // namespace ipc
} // namespace mozilla
namespace mozilla {
namespace ipc {
class PIdleSchedulerParent;
} // namespace ipc
} // namespace mozilla

namespace mozilla {
namespace dom {
class PRemoteWorkerControllerChild;
} // namespace dom
} // namespace mozilla
namespace mozilla {
namespace dom {
class PRemoteWorkerControllerParent;
} // namespace dom
} // namespace mozilla

namespace mozilla {
namespace dom {
class PRemoteWorkerServiceChild;
} // namespace dom
} // namespace mozilla
namespace mozilla {
namespace dom {
class PRemoteWorkerServiceParent;
} // namespace dom
} // namespace mozilla

namespace mozilla {
namespace dom {
class PSharedWorkerChild;
} // namespace dom
} // namespace mozilla
namespace mozilla {
namespace dom {
class PSharedWorkerParent;
} // namespace dom
} // namespace mozilla

namespace mozilla {
namespace dom {
class PTemporaryIPCBlobChild;
} // namespace dom
} // namespace mozilla
namespace mozilla {
namespace dom {
class PTemporaryIPCBlobParent;
} // namespace dom
} // namespace mozilla

namespace mozilla {
namespace dom {
class PFileCreatorChild;
} // namespace dom
} // namespace mozilla
namespace mozilla {
namespace dom {
class PFileCreatorParent;
} // namespace dom
} // namespace mozilla

namespace mozilla {
namespace dom {
class PMessagePortChild;
} // namespace dom
} // namespace mozilla
namespace mozilla {
namespace dom {
class PMessagePortParent;
} // namespace dom
} // namespace mozilla

namespace mozilla {
namespace camera {
class PCamerasChild;
} // namespace camera
} // namespace mozilla
namespace mozilla {
namespace camera {
class PCamerasParent;
} // namespace camera
} // namespace mozilla

namespace mozilla {
namespace dom {
namespace locks {
class PLockManagerChild;
} // namespace locks
} // namespace dom
} // namespace mozilla
namespace mozilla {
namespace dom {
namespace locks {
class PLockManagerParent;
} // namespace locks
} // namespace dom
} // namespace mozilla

namespace mozilla {
namespace dom {
class PMIDIManagerChild;
} // namespace dom
} // namespace mozilla
namespace mozilla {
namespace dom {
class PMIDIManagerParent;
} // namespace dom
} // namespace mozilla

namespace mozilla {
namespace dom {
class PMIDIPortChild;
} // namespace dom
} // namespace mozilla
namespace mozilla {
namespace dom {
class PMIDIPortParent;
} // namespace dom
} // namespace mozilla

namespace mozilla {
namespace dom {
class PMLSTransactionChild;
} // namespace dom
} // namespace mozilla
namespace mozilla {
namespace dom {
class PMLSTransactionParent;
} // namespace dom
} // namespace mozilla

namespace mozilla {
namespace dom {
namespace quota {
class PQuotaChild;
} // namespace quota
} // namespace dom
} // namespace mozilla
namespace mozilla {
namespace dom {
namespace quota {
class PQuotaParent;
} // namespace quota
} // namespace dom
} // namespace mozilla

namespace mozilla {
namespace dom {
class PServiceWorkerChild;
} // namespace dom
} // namespace mozilla
namespace mozilla {
namespace dom {
class PServiceWorkerParent;
} // namespace dom
} // namespace mozilla

namespace mozilla {
namespace dom {
class PServiceWorkerContainerChild;
} // namespace dom
} // namespace mozilla
namespace mozilla {
namespace dom {
class PServiceWorkerContainerParent;
} // namespace dom
} // namespace mozilla

namespace mozilla {
namespace dom {
class PServiceWorkerManagerChild;
} // namespace dom
} // namespace mozilla
namespace mozilla {
namespace dom {
class PServiceWorkerManagerParent;
} // namespace dom
} // namespace mozilla

namespace mozilla {
namespace dom {
class PServiceWorkerRegistrationChild;
} // namespace dom
} // namespace mozilla
namespace mozilla {
namespace dom {
class PServiceWorkerRegistrationParent;
} // namespace dom
} // namespace mozilla

namespace mozilla {
namespace net {
class PUDPSocketChild;
} // namespace net
} // namespace mozilla
namespace mozilla {
namespace net {
class PUDPSocketParent;
} // namespace net
} // namespace mozilla

namespace mozilla {
namespace dom {
class PVsyncChild;
} // namespace dom
} // namespace mozilla
namespace mozilla {
namespace dom {
class PVsyncParent;
} // namespace dom
} // namespace mozilla

namespace mozilla {
class PRemoteMediaManagerChild;
} // namespace mozilla
namespace mozilla {
class PRemoteMediaManagerParent;
} // namespace mozilla

namespace mozilla {
namespace dom {
class PWebTransportChild;
} // namespace dom
} // namespace mozilla
namespace mozilla {
namespace dom {
class PWebTransportParent;
} // namespace dom
} // namespace mozilla

namespace mozilla {
namespace dom {
class PFetchChild;
} // namespace dom
} // namespace mozilla
namespace mozilla {
namespace dom {
class PFetchParent;
} // namespace dom
} // namespace mozilla

namespace mozilla {
namespace dom {
namespace notification {
class PNotificationChild;
} // namespace notification
} // namespace dom
} // namespace mozilla
namespace mozilla {
namespace dom {
namespace notification {
class PNotificationParent;
} // namespace notification
} // namespace dom
} // namespace mozilla

namespace mozilla {
namespace camera {
class PCamerasChild;
} // namespace camera
} // namespace mozilla

namespace mozilla {
namespace dom {
class PBackgroundLSObserverChild;
} // namespace dom
} // namespace mozilla

namespace mozilla {
namespace dom {
class PBackgroundLSRequestChild;
} // namespace dom
} // namespace mozilla

namespace mozilla {
namespace dom {
class PBackgroundLSSimpleRequestChild;
} // namespace dom
} // namespace mozilla

namespace mozilla {
namespace dom {
class PBackgroundLocalStorageCacheChild;
} // namespace dom
} // namespace mozilla

namespace mozilla {
namespace dom {
class PBackgroundSDBConnectionChild;
} // namespace dom
} // namespace mozilla

namespace mozilla {
namespace dom {
class PBackgroundSessionStorageManagerChild;
} // namespace dom
} // namespace mozilla

namespace mozilla {
namespace dom {
class PBackgroundSessionStorageServiceChild;
} // namespace dom
} // namespace mozilla

namespace mozilla {
namespace dom {
class PBackgroundStorageChild;
} // namespace dom
} // namespace mozilla

namespace mozilla {
namespace dom {
class PBroadcastChannelChild;
} // namespace dom
} // namespace mozilla

namespace mozilla {
namespace dom {
class PClientManagerChild;
} // namespace dom
} // namespace mozilla

namespace mozilla {
namespace dom {
class PCookieStoreChild;
} // namespace dom
} // namespace mozilla

namespace mozilla {
namespace dom {
class PEndpointForReportChild;
} // namespace dom
} // namespace mozilla

namespace mozilla {
namespace dom {
class PFetchChild;
} // namespace dom
} // namespace mozilla

namespace mozilla {
namespace dom {
class PFileCreatorChild;
} // namespace dom
} // namespace mozilla

namespace mozilla {
namespace dom {
class PFileSystemRequestChild;
} // namespace dom
} // namespace mozilla

namespace mozilla {
namespace dom {
class PGamepadEventChannelChild;
} // namespace dom
} // namespace mozilla

namespace mozilla {
namespace dom {
class PGamepadTestChannelChild;
} // namespace dom
} // namespace mozilla

namespace mozilla {
namespace dom {
class PMessagePortChild;
} // namespace dom
} // namespace mozilla

namespace mozilla {
namespace dom {
class PRemoteWorkerControllerChild;
} // namespace dom
} // namespace mozilla

namespace mozilla {
namespace dom {
class PServiceWorkerChild;
} // namespace dom
} // namespace mozilla

namespace mozilla {
namespace dom {
class PServiceWorkerContainerChild;
} // namespace dom
} // namespace mozilla

namespace mozilla {
namespace dom {
class PServiceWorkerManagerChild;
} // namespace dom
} // namespace mozilla

namespace mozilla {
namespace dom {
class PServiceWorkerRegistrationChild;
} // namespace dom
} // namespace mozilla

namespace mozilla {
namespace dom {
class PSharedWorkerChild;
} // namespace dom
} // namespace mozilla

namespace mozilla {
namespace dom {
class PTemporaryIPCBlobChild;
} // namespace dom
} // namespace mozilla

namespace mozilla {
namespace dom {
class PVsyncChild;
} // namespace dom
} // namespace mozilla

namespace mozilla {
namespace dom {
namespace cache {
class PCacheChild;
} // namespace cache
} // namespace dom
} // namespace mozilla

namespace mozilla {
namespace dom {
namespace cache {
class PCacheStorageChild;
} // namespace cache
} // namespace dom
} // namespace mozilla

namespace mozilla {
namespace dom {
namespace cache {
class PCacheStreamControlChild;
} // namespace cache
} // namespace dom
} // namespace mozilla

namespace mozilla {
namespace dom {
namespace indexedDB {
class PBackgroundIDBFactoryChild;
} // namespace indexedDB
} // namespace dom
} // namespace mozilla

namespace mozilla {
namespace dom {
namespace indexedDB {
class PBackgroundIndexedDBUtilsChild;
} // namespace indexedDB
} // namespace dom
} // namespace mozilla

namespace mozilla {
namespace dom {
namespace locks {
class PLockManagerChild;
} // namespace locks
} // namespace dom
} // namespace mozilla

namespace mozilla {
namespace dom {
namespace quota {
class PQuotaChild;
} // namespace quota
} // namespace dom
} // namespace mozilla

namespace mozilla {
namespace ipc {
class PBackgroundTestChild;
} // namespace ipc
} // namespace mozilla

namespace mozilla {
namespace ipc {
class PIdleSchedulerChild;
} // namespace ipc
} // namespace mozilla

namespace mozilla {
namespace net {
class PHttpBackgroundChannelChild;
} // namespace net
} // namespace mozilla

namespace mozilla {
namespace net {
class PUDPSocketChild;
} // namespace net
} // namespace mozilla

namespace mozilla {
struct void_t;
} // namespace mozilla

namespace mozilla {
struct SerializedStructuredCloneBuffer;
} // namespace mozilla

namespace mozilla {
namespace dom {
struct LoadingSessionHistoryInfo;
} // namespace dom
} // namespace mozilla

class nsIPrincipal;

class nsIURI;

class nsIPolicyContainer;

class nsIInputStream;

class nsIReferrerInfo;

class nsIVariant;

namespace mozilla {
class RemoteLazyInputStream;
} // namespace mozilla

namespace mozilla {
namespace ipc {
class BigBuffer;
} // namespace ipc
} // namespace mozilla

namespace mozilla {
struct void_t;
} // namespace mozilla

namespace mozilla {
class RemoteLazyInputStream;
} // namespace mozilla

namespace mozilla {
struct void_t;
} // namespace mozilla

namespace mozilla {
struct null_t;
} // namespace mozilla

namespace mozilla {
struct void_t;
} // namespace mozilla

namespace mozilla {
namespace dom {
namespace indexedDB {
class Key;
} // namespace indexedDB
} // namespace dom
} // namespace mozilla

namespace mozilla {
namespace dom {
namespace indexedDB {
class KeyPath;
} // namespace indexedDB
} // namespace dom
} // namespace mozilla

struct nsID;

namespace mozilla {
struct void_t;
} // namespace mozilla

class nsIPrincipal;

namespace mozilla {
namespace dom {
class SSCacheCopy;
} // namespace dom
} // namespace mozilla

namespace mozilla {
namespace ipc {


class PBackgroundChild :
    public mozilla::ipc::IToplevelProtocol
{
private:
    friend class ::mozilla::camera::PCamerasChild;
    friend class ::mozilla::dom::PBackgroundLSObserverChild;
    friend class ::mozilla::dom::PBackgroundLSRequestChild;
    friend class ::mozilla::dom::PBackgroundLSSimpleRequestChild;
    friend class ::mozilla::dom::PBackgroundLocalStorageCacheChild;
    friend class ::mozilla::dom::PBackgroundSDBConnectionChild;
    friend class ::mozilla::dom::PBackgroundSessionStorageManagerChild;
    friend class ::mozilla::dom::PBackgroundSessionStorageServiceChild;
    friend class ::mozilla::dom::PBackgroundStorageChild;
    friend class ::mozilla::dom::PBroadcastChannelChild;
    friend class ::mozilla::dom::PClientManagerChild;
    friend class ::mozilla::dom::PCookieStoreChild;
    friend class ::mozilla::dom::PEndpointForReportChild;
    friend class ::mozilla::dom::PFetchChild;
    friend class ::mozilla::dom::PFileCreatorChild;
    friend class ::mozilla::dom::PFileSystemRequestChild;
    friend class ::mozilla::dom::PGamepadEventChannelChild;
    friend class ::mozilla::dom::PGamepadTestChannelChild;
    friend class ::mozilla::dom::PMessagePortChild;
    friend class ::mozilla::dom::PRemoteWorkerControllerChild;
    friend class ::mozilla::dom::PServiceWorkerChild;
    friend class ::mozilla::dom::PServiceWorkerContainerChild;
    friend class ::mozilla::dom::PServiceWorkerManagerChild;
    friend class ::mozilla::dom::PServiceWorkerRegistrationChild;
    friend class ::mozilla::dom::PSharedWorkerChild;
    friend class ::mozilla::dom::PTemporaryIPCBlobChild;
    friend class ::mozilla::dom::PVsyncChild;
    friend class ::mozilla::dom::cache::PCacheChild;
    friend class ::mozilla::dom::cache::PCacheStorageChild;
    friend class ::mozilla::dom::cache::PCacheStreamControlChild;
    friend class ::mozilla::dom::indexedDB::PBackgroundIDBFactoryChild;
    friend class ::mozilla::dom::indexedDB::PBackgroundIndexedDBUtilsChild;
    friend class ::mozilla::dom::locks::PLockManagerChild;
    friend class ::mozilla::dom::quota::PQuotaChild;
    friend class ::mozilla::ipc::PBackgroundTestChild;
    friend class ::mozilla::ipc::PIdleSchedulerChild;
    friend class ::mozilla::net::PHttpBackgroundChannelChild;
    friend class ::mozilla::net::PUDPSocketChild;
public:
    static constexpr ::mozilla::ipc::ProtocolId kProtocolId = PBackgroundMsgStart;
protected:
    typedef mozilla::ipc::ActorId ActorId;
    typedef ::mozilla::ipc::BigBuffer BigBuffer;
    typedef ::mozilla::ipc::ByteBuf ByteBuf;
    typedef ::mozilla::ipc::CSPInfo CSPInfo;
    typedef ::mozilla::dom::CSPViolation CSPViolation;
    typedef ::mozilla::CSSRect CSSRect;
    typedef ::mozilla::CSSSize CSSSize;
    typedef ::mozilla::CSSToLayoutDeviceScale CSSToLayoutDeviceScale;
    typedef ::mozilla::dom::CallerType CallerType;
    typedef ::mozilla::camera::CamerasAccessStatus CamerasAccessStatus;
    typedef ::mozilla::net::ClassOfService ClassOfService;
    typedef ::mozilla::net::ClassificationFlags ClassificationFlags;
    typedef ::mozilla::dom::ClientClaimArgs ClientClaimArgs;
    typedef ::mozilla::dom::ClientControlledArgs ClientControlledArgs;
    typedef ::mozilla::dom::ClientEvictBFCacheArgs ClientEvictBFCacheArgs;
    typedef ::mozilla::dom::ClientFocusArgs ClientFocusArgs;
    typedef ::mozilla::dom::ClientGetInfoAndStateArgs ClientGetInfoAndStateArgs;
    typedef ::mozilla::dom::ClientInfoAndState ClientInfoAndState;
    typedef ::mozilla::dom::ClientList ClientList;
    typedef ::mozilla::dom::ClientMatchAllArgs ClientMatchAllArgs;
    typedef ::mozilla::dom::ClientNavigateArgs ClientNavigateArgs;
    typedef ::mozilla::dom::ClientNavigateOpConstructorArgs ClientNavigateOpConstructorArgs;
    typedef ::mozilla::dom::ClientOpConstructorArgs ClientOpConstructorArgs;
    typedef ::mozilla::dom::ClientOpResult ClientOpResult;
    typedef ::mozilla::dom::ClientOpenWindowArgs ClientOpenWindowArgs;
    typedef ::mozilla::dom::ClientPostMessageArgs ClientPostMessageArgs;
    typedef ::mozilla::dom::ClientSourceConstructorArgs ClientSourceConstructorArgs;
    typedef ::mozilla::dom::ClientSourceExecutionReadyArgs ClientSourceExecutionReadyArgs;
    typedef ::mozilla::dom::ClientType ClientType;
    typedef ::mozilla::dom::ClonedMessageData ClonedMessageData;
    typedef ::mozilla::dom::ClonedOrErrorMessageData ClonedOrErrorMessageData;
    typedef ::mozilla::dom::indexedDB::CommonIndexOpenCursorParams CommonIndexOpenCursorParams;
    typedef ::mozilla::dom::indexedDB::CommonOpenCursorParams CommonOpenCursorParams;
    typedef ::mozilla::ipc::ContentPrincipalInfo ContentPrincipalInfo;
    typedef ::mozilla::ipc::ContentSecurityPolicy ContentSecurityPolicy;
    typedef ::mozilla::CopyableErrorResult CopyableErrorResult;
    typedef ::mozilla::dom::CreatedWindowInfo CreatedWindowInfo;
    typedef ::mozilla::dom::indexedDB::DatabaseMetadata DatabaseMetadata;
    typedef ::mozilla::dom::indexedDB::DatabaseSpec DatabaseSpec;
    typedef ::mozilla::DesktopIntRect DesktopIntRect;
    typedef ::mozilla::DesktopToLayoutDeviceScale DesktopToLayoutDeviceScale;
    typedef ::mozilla::dom::IntegrityPolicy::Destinations Destinations;
    typedef ::mozilla::dom::DimensionInfo DimensionInfo;
    typedef ::mozilla::dom::IDBCursor::Direction Direction;
    typedef ::mozilla::dom::DocShellLoadStateInit DocShellLoadStateInit;
    template<class FooSide> using Endpoint = mozilla::ipc::Endpoint<FooSide>;
    typedef ::mozilla::dom::ErrorData ErrorData;
    typedef ::mozilla::dom::ErrorDataNote ErrorDataNote;
    typedef ::mozilla::dom::ErrorMessageData ErrorMessageData;
    typedef ::mozilla::dom::ErrorMismatchOptions ErrorMismatchOptions;
    typedef ::mozilla::dom::ErrorValue ErrorValue;
    typedef ::mozilla::ipc::ExpandedPrincipalInfo ExpandedPrincipalInfo;
    typedef ::mozilla::dom::indexedDB::FileAddInfo FileAddInfo;
    typedef ::mozilla::ipc::FileDescriptor FileDescriptor;
    typedef ::mozilla::dom::FileSystemGetDirectoryListingParams FileSystemGetDirectoryListingParams;
    typedef ::mozilla::dom::FileSystemGetFileOrDirectoryParams FileSystemGetFileOrDirectoryParams;
    typedef ::mozilla::dom::FileSystemGetFilesParams FileSystemGetFilesParams;
    typedef ::mozilla::dom::FileSystemParams FileSystemParams;
    typedef ::mozilla::dom::indexedDB::StructuredCloneFileBase::FileType FileType;
    typedef ::mozilla::dom::ForceMediaDocument ForceMediaDocument;
    typedef ::mozilla::dom::FrameScriptInfo FrameScriptInfo;
    typedef ::mozilla::dom::FrameType FrameType;
    typedef ::nsILoadInfo::HTTPSUpgradeTelemetryType HTTPSUpgradeTelemetryType;
    typedef ::mozilla::dom::IDPLVariant IDPLVariant;
    typedef ::mozilla::dom::IPCBlob IPCBlob;
    typedef ::mozilla::dom::IPCClientInfo IPCClientInfo;
    typedef ::mozilla::dom::IPCClientState IPCClientState;
    typedef ::mozilla::dom::IPCClientWindowState IPCClientWindowState;
    typedef ::mozilla::dom::IPCClientWorkerState IPCClientWorkerState;
    typedef ::mozilla::dom::IPCFile IPCFile;
    typedef ::mozilla::dom::IPCImage IPCImage;
    typedef ::mozilla::dom::IPCNotification IPCNotification;
    typedef ::mozilla::dom::IPCNotificationAction IPCNotificationAction;
    typedef ::mozilla::dom::IPCNotificationOptions IPCNotificationOptions;
    typedef ::mozilla::dom::IPCNotificationsOrError IPCNotificationsOrError;
    typedef ::mozilla::dom::IPCServiceWorkerDescriptor IPCServiceWorkerDescriptor;
    typedef ::mozilla::dom::IPCServiceWorkerRegistrationDescriptor IPCServiceWorkerRegistrationDescriptor;
    typedef ::mozilla::dom::IPCServiceWorkerRegistrationDescriptorList IPCServiceWorkerRegistrationDescriptorList;
    typedef ::mozilla::dom::IPCServiceWorkerRegistrationDescriptorListOrCopyableErrorResult IPCServiceWorkerRegistrationDescriptorListOrCopyableErrorResult;
    typedef ::mozilla::dom::IPCServiceWorkerRegistrationDescriptorOrCopyableErrorResult IPCServiceWorkerRegistrationDescriptorOrCopyableErrorResult;
    typedef ::mozilla::dom::IPDLProperty IPDLProperty;
    typedef ::mozilla::dom::IPDLVariantValue IPDLVariantValue;
    typedef ::mozilla::ImageIntSize ImageIntSize;
    typedef ::mozilla::dom::indexedDB::IndexCountParams IndexCountParams;
    typedef ::mozilla::dom::indexedDB::IndexGetAllKeysParams IndexGetAllKeysParams;
    typedef ::mozilla::dom::indexedDB::IndexGetAllParams IndexGetAllParams;
    typedef ::mozilla::dom::indexedDB::IndexGetKeyParams IndexGetKeyParams;
    typedef ::mozilla::dom::indexedDB::IndexGetParams IndexGetParams;
    typedef ::mozilla::dom::indexedDB::IndexMetadata IndexMetadata;
    typedef ::mozilla::dom::indexedDB::IndexOpenCursorParams IndexOpenCursorParams;
    typedef ::mozilla::dom::indexedDB::IndexOpenKeyCursorParams IndexOpenKeyCursorParams;
    typedef ::mozilla::dom::indexedDB::IndexUpdateInfo IndexUpdateInfo;
    typedef ::mozilla::ipc::IntegrityPolicyArgs IntegrityPolicyArgs;
    typedef ::mozilla::ipc::IntegrityPolicyEntry IntegrityPolicyEntry;
    typedef ::mozilla::dom::indexedDB::Key Key;
    typedef ::mozilla::dom::indexedDB::KeyPath KeyPath;
    typedef ::mozilla::dom::LSItemInfo LSItemInfo;
    typedef ::mozilla::dom::LSRequestCommonParams LSRequestCommonParams;
    typedef ::mozilla::dom::LSRequestParams LSRequestParams;
    typedef ::mozilla::dom::LSRequestPreloadDatastoreParams LSRequestPreloadDatastoreParams;
    typedef ::mozilla::dom::LSRequestPrepareDatastoreParams LSRequestPrepareDatastoreParams;
    typedef ::mozilla::dom::LSRequestPrepareObserverParams LSRequestPrepareObserverParams;
    typedef ::mozilla::dom::LSSimpleRequestGetStateParams LSSimpleRequestGetStateParams;
    typedef ::mozilla::dom::LSSimpleRequestParams LSSimpleRequestParams;
    typedef ::mozilla::dom::LSSimpleRequestPreloadedParams LSSimpleRequestPreloadedParams;
    typedef ::mozilla::dom::LSValue LSValue;
    typedef ::mozilla::LayoutDeviceIntPoint LayoutDeviceIntPoint;
    typedef ::mozilla::LayoutDeviceIntRect LayoutDeviceIntRect;
    typedef ::mozilla::LayoutDeviceIntSize LayoutDeviceIntSize;
    typedef ::mozilla::dom::LoadingSessionHistoryInfo LoadingSessionHistoryInfo;
    typedef ::mozilla::dom::indexedDB::LoggingInfo LoggingInfo;
    typedef ::mozilla::dom::MIDIMessage MIDIMessage;
    typedef ::mozilla::dom::MIDIPortInfo MIDIPortInfo;
    typedef ::mozilla::dom::MIDIPortList MIDIPortList;
    template<class FooSide> using ManagedEndpoint = mozilla::ipc::ManagedEndpoint<FooSide>;
    typedef ::mozilla::dom::MaybeDiscardedBrowsingContext MaybeDiscardedBrowsingContext;
    typedef ::mozilla::dom::MessageData MessageData;
    typedef ::mozilla::dom::MessageDataType MessageDataType;
    typedef ::mozilla::dom::MessagePortIdentifier MessagePortIdentifier;
    typedef ::mozilla::dom::cache::Namespace Namespace;
    typedef ::mozilla::dom::NavigationHistoryBehavior NavigationHistoryBehavior;
    typedef ::mozilla::dom::NotificationDirection NotificationDirection;
    typedef ::mozilla::ipc::NullPrincipalInfo NullPrincipalInfo;
    typedef ::mozilla::dom::indexedDB::NullableBlob NullableBlob;
    typedef ::mozilla::dom::indexedDB::ObjectStoreAddParams ObjectStoreAddParams;
    typedef ::mozilla::dom::indexedDB::ObjectStoreAddPutParams ObjectStoreAddPutParams;
    typedef ::mozilla::dom::indexedDB::ObjectStoreClearParams ObjectStoreClearParams;
    typedef ::mozilla::dom::indexedDB::ObjectStoreCountParams ObjectStoreCountParams;
    typedef ::mozilla::dom::indexedDB::ObjectStoreDeleteParams ObjectStoreDeleteParams;
    typedef ::mozilla::dom::indexedDB::ObjectStoreGetAllKeysParams ObjectStoreGetAllKeysParams;
    typedef ::mozilla::dom::indexedDB::ObjectStoreGetAllParams ObjectStoreGetAllParams;
    typedef ::mozilla::dom::indexedDB::ObjectStoreGetKeyParams ObjectStoreGetKeyParams;
    typedef ::mozilla::dom::indexedDB::ObjectStoreGetParams ObjectStoreGetParams;
    typedef ::mozilla::dom::indexedDB::ObjectStoreMetadata ObjectStoreMetadata;
    typedef ::mozilla::dom::indexedDB::ObjectStoreOpenCursorParams ObjectStoreOpenCursorParams;
    typedef ::mozilla::dom::indexedDB::ObjectStoreOpenKeyCursorParams ObjectStoreOpenKeyCursorParams;
    typedef ::mozilla::dom::indexedDB::ObjectStorePutParams ObjectStorePutParams;
    typedef ::mozilla::dom::indexedDB::ObjectStoreSpec ObjectStoreSpec;
    typedef ::mozilla::dom::indexedDB::OpenCursorParams OpenCursorParams;
    typedef ::mozilla::dom::OptionalServiceWorkerData OptionalServiceWorkerData;
    typedef ::mozilla::OriginAttributes OriginAttributes;
    typedef ::mozilla::OriginTrials OriginTrials;
    typedef ::mozilla::dom::OwnerShowInfo OwnerShowInfo;
    typedef ::mozilla::net::PBackgroundDataBridgeChild PBackgroundDataBridgeChild;
    typedef ::mozilla::net::PBackgroundDataBridgeParent PBackgroundDataBridgeParent;
    typedef ::mozilla::dom::indexedDB::PBackgroundIDBFactoryChild PBackgroundIDBFactoryChild;
    typedef ::mozilla::dom::indexedDB::PBackgroundIDBFactoryParent PBackgroundIDBFactoryParent;
    typedef ::mozilla::dom::indexedDB::PBackgroundIndexedDBUtilsChild PBackgroundIndexedDBUtilsChild;
    typedef ::mozilla::dom::indexedDB::PBackgroundIndexedDBUtilsParent PBackgroundIndexedDBUtilsParent;
    typedef ::mozilla::dom::PBackgroundLSObserverChild PBackgroundLSObserverChild;
    typedef ::mozilla::dom::PBackgroundLSObserverParent PBackgroundLSObserverParent;
    typedef ::mozilla::dom::PBackgroundLSRequestChild PBackgroundLSRequestChild;
    typedef ::mozilla::dom::PBackgroundLSRequestParent PBackgroundLSRequestParent;
    typedef ::mozilla::dom::PBackgroundLSSimpleRequestChild PBackgroundLSSimpleRequestChild;
    typedef ::mozilla::dom::PBackgroundLSSimpleRequestParent PBackgroundLSSimpleRequestParent;
    typedef ::mozilla::dom::PBackgroundLocalStorageCacheChild PBackgroundLocalStorageCacheChild;
    typedef ::mozilla::dom::PBackgroundLocalStorageCacheParent PBackgroundLocalStorageCacheParent;
    typedef ::mozilla::dom::PBackgroundSDBConnectionChild PBackgroundSDBConnectionChild;
    typedef ::mozilla::dom::PBackgroundSDBConnectionParent PBackgroundSDBConnectionParent;
    typedef ::mozilla::dom::PBackgroundSessionStorageManagerChild PBackgroundSessionStorageManagerChild;
    typedef ::mozilla::dom::PBackgroundSessionStorageManagerParent PBackgroundSessionStorageManagerParent;
    typedef ::mozilla::dom::PBackgroundSessionStorageServiceChild PBackgroundSessionStorageServiceChild;
    typedef ::mozilla::dom::PBackgroundSessionStorageServiceParent PBackgroundSessionStorageServiceParent;
    typedef ::mozilla::dom::PBackgroundStorageChild PBackgroundStorageChild;
    typedef ::mozilla::dom::PBackgroundStorageParent PBackgroundStorageParent;
    typedef ::mozilla::ipc::PBackgroundTestChild PBackgroundTestChild;
    typedef ::mozilla::ipc::PBackgroundTestParent PBackgroundTestParent;
    typedef ::mozilla::dom::cache::PBoundStorageKeyChild PBoundStorageKeyChild;
    typedef ::mozilla::dom::cache::PBoundStorageKeyParent PBoundStorageKeyParent;
    typedef ::mozilla::dom::PBroadcastChannelChild PBroadcastChannelChild;
    typedef ::mozilla::dom::PBroadcastChannelParent PBroadcastChannelParent;
    typedef ::mozilla::dom::cache::PCacheChild PCacheChild;
    typedef ::mozilla::dom::cache::PCacheParent PCacheParent;
    typedef ::mozilla::dom::cache::PCacheStorageChild PCacheStorageChild;
    typedef ::mozilla::dom::cache::PCacheStorageParent PCacheStorageParent;
    typedef ::mozilla::dom::cache::PCacheStreamControlChild PCacheStreamControlChild;
    typedef ::mozilla::dom::cache::PCacheStreamControlParent PCacheStreamControlParent;
    typedef ::mozilla::camera::PCamerasChild PCamerasChild;
    typedef ::mozilla::camera::PCamerasParent PCamerasParent;
    typedef ::mozilla::dom::PClientManagerChild PClientManagerChild;
    typedef ::mozilla::dom::PClientManagerParent PClientManagerParent;
    typedef ::mozilla::dom::PCookieStoreChild PCookieStoreChild;
    typedef ::mozilla::dom::PCookieStoreParent PCookieStoreParent;
    typedef ::mozilla::dom::PEndpointForReportChild PEndpointForReportChild;
    typedef ::mozilla::dom::PEndpointForReportParent PEndpointForReportParent;
    typedef ::mozilla::dom::PFetchChild PFetchChild;
    typedef ::mozilla::dom::PFetchParent PFetchParent;
    typedef ::mozilla::dom::PFileCreatorChild PFileCreatorChild;
    typedef ::mozilla::dom::PFileCreatorParent PFileCreatorParent;
    typedef ::mozilla::dom::PFileSystemManagerChild PFileSystemManagerChild;
    typedef ::mozilla::dom::PFileSystemManagerParent PFileSystemManagerParent;
    typedef ::mozilla::dom::PFileSystemRequestChild PFileSystemRequestChild;
    typedef ::mozilla::dom::PFileSystemRequestParent PFileSystemRequestParent;
    typedef ::mozilla::dom::PGamepadEventChannelChild PGamepadEventChannelChild;
    typedef ::mozilla::dom::PGamepadEventChannelParent PGamepadEventChannelParent;
    typedef ::mozilla::dom::PGamepadTestChannelChild PGamepadTestChannelChild;
    typedef ::mozilla::dom::PGamepadTestChannelParent PGamepadTestChannelParent;
    typedef ::mozilla::net::PHttpBackgroundChannelChild PHttpBackgroundChannelChild;
    typedef ::mozilla::net::PHttpBackgroundChannelParent PHttpBackgroundChannelParent;
    typedef ::mozilla::ipc::PIdleSchedulerChild PIdleSchedulerChild;
    typedef ::mozilla::ipc::PIdleSchedulerParent PIdleSchedulerParent;
    typedef ::mozilla::dom::locks::PLockManagerChild PLockManagerChild;
    typedef ::mozilla::dom::locks::PLockManagerParent PLockManagerParent;
    typedef ::mozilla::dom::PMIDIManagerChild PMIDIManagerChild;
    typedef ::mozilla::dom::PMIDIManagerParent PMIDIManagerParent;
    typedef ::mozilla::dom::PMIDIPortChild PMIDIPortChild;
    typedef ::mozilla::dom::PMIDIPortParent PMIDIPortParent;
    typedef ::mozilla::dom::PMLSTransactionChild PMLSTransactionChild;
    typedef ::mozilla::dom::PMLSTransactionParent PMLSTransactionParent;
    typedef ::mozilla::dom::PMessagePortChild PMessagePortChild;
    typedef ::mozilla::dom::PMessagePortParent PMessagePortParent;
    typedef ::mozilla::dom::notification::PNotificationChild PNotificationChild;
    typedef ::mozilla::dom::notification::PNotificationParent PNotificationParent;
    typedef ::mozilla::dom::quota::PQuotaChild PQuotaChild;
    typedef ::mozilla::dom::quota::PQuotaParent PQuotaParent;
    typedef ::mozilla::PRemoteMediaManagerChild PRemoteMediaManagerChild;
    typedef ::mozilla::PRemoteMediaManagerParent PRemoteMediaManagerParent;
    typedef ::mozilla::dom::PRemoteWorkerControllerChild PRemoteWorkerControllerChild;
    typedef ::mozilla::dom::PRemoteWorkerControllerParent PRemoteWorkerControllerParent;
    typedef ::mozilla::dom::PRemoteWorkerServiceChild PRemoteWorkerServiceChild;
    typedef ::mozilla::dom::PRemoteWorkerServiceParent PRemoteWorkerServiceParent;
    typedef ::mozilla::dom::PServiceWorkerChild PServiceWorkerChild;
    typedef ::mozilla::dom::PServiceWorkerContainerChild PServiceWorkerContainerChild;
    typedef ::mozilla::dom::PServiceWorkerContainerParent PServiceWorkerContainerParent;
    typedef ::mozilla::dom::PServiceWorkerManagerChild PServiceWorkerManagerChild;
    typedef ::mozilla::dom::PServiceWorkerManagerParent PServiceWorkerManagerParent;
    typedef ::mozilla::dom::PServiceWorkerParent PServiceWorkerParent;
    typedef ::mozilla::dom::PServiceWorkerRegistrationChild PServiceWorkerRegistrationChild;
    typedef ::mozilla::dom::PServiceWorkerRegistrationParent PServiceWorkerRegistrationParent;
    typedef ::mozilla::dom::PSharedWorkerChild PSharedWorkerChild;
    typedef ::mozilla::dom::PSharedWorkerParent PSharedWorkerParent;
    typedef ::mozilla::dom::PTemporaryIPCBlobChild PTemporaryIPCBlobChild;
    typedef ::mozilla::dom::PTemporaryIPCBlobParent PTemporaryIPCBlobParent;
    typedef ::mozilla::net::PUDPSocketChild PUDPSocketChild;
    typedef ::mozilla::net::PUDPSocketParent PUDPSocketParent;
    typedef ::mozilla::dom::PVsyncChild PVsyncChild;
    typedef ::mozilla::dom::PVsyncParent PVsyncParent;
    typedef ::mozilla::dom::PWebTransportChild PWebTransportChild;
    typedef ::mozilla::dom::PWebTransportParent PWebTransportParent;
    typedef ::mozilla::dom::ParentShowInfo ParentShowInfo;
    typedef ::mozilla::dom::quota::PersistenceType PersistenceType;
    typedef ::mozilla::ipc::PolicyContainerArgs PolicyContainerArgs;
    typedef ::mozilla::dom::PostMessageSource PostMessageSource;
    typedef ::mozilla::ipc::PrincipalInfo PrincipalInfo;
    typedef base::ProcessId ProcessId;
    typedef ::mozilla::ipc::ProtocolFdMapping ProtocolFdMapping;
    typedef mozilla::ipc::ProtocolId ProtocolId;
    typedef ::mozilla::RFPTargetSet RFPTargetSet;
    typedef ::mozilla::dom::RefMessageData RefMessageData;
    typedef ::mozilla::RemoteLazyInputStream RemoteLazyInputStream;
    typedef ::mozilla::RemoteLazyStream RemoteLazyStream;
    typedef ::mozilla::RemoteMediaIn RemoteMediaIn;
    typedef ::mozilla::dom::RemoteWorkerData RemoteWorkerData;
    typedef ::mozilla::dom::RemoteWorkerDebuggerErrorInfo RemoteWorkerDebuggerErrorInfo;
    typedef ::mozilla::dom::RemoteWorkerDebuggerInfo RemoteWorkerDebuggerInfo;
    typedef ::mozilla::dom::ReplacementChannelConfigInit ReplacementChannelConfigInit;
    typedef ::mozilla::dom::indexedDB::RequestParams RequestParams;
    typedef ::nsIContentSecurityPolicy::RequireTrustedTypesForDirectiveState RequireTrustedTypesForDirectiveState;
    typedef mozilla::ipc::ResponseRejectReason ResponseRejectReason;
    typedef ::mozilla::dom::SSCacheCopy SSCacheCopy;
    typedef ::nsILoadInfo::SchemelessInputType SchemelessInputType;
    typedef ::mozilla::dom::ScreenDetails ScreenDetails;
    typedef ::mozilla::hal::ScreenOrientation ScreenOrientation;
    typedef ::mozilla::ScrollbarPreference ScrollbarPreference;
    typedef ::mozilla::dom::indexedDB::SerializedKeyRange SerializedKeyRange;
    typedef ::mozilla::SerializedStructuredCloneBuffer SerializedStructuredCloneBuffer;
    typedef ::mozilla::dom::indexedDB::SerializedStructuredCloneFile SerializedStructuredCloneFile;
    typedef ::mozilla::dom::indexedDB::SerializedStructuredCloneReadInfo SerializedStructuredCloneReadInfo;
    typedef ::mozilla::dom::indexedDB::SerializedStructuredCloneWriteInfo SerializedStructuredCloneWriteInfo;
    typedef ::mozilla::dom::ServiceWorkerData ServiceWorkerData;
    typedef ::mozilla::dom::ServiceWorkerState ServiceWorkerState;
    typedef ::mozilla::dom::ServiceWorkerUpdateViaCache ServiceWorkerUpdateViaCache;
    typedef ::mozilla::ipc::Shmem Shmem;
    typedef ::mozilla::dom::IntegrityPolicy::Sources Sources;
    typedef ::mozilla::StorageAccess StorageAccess;
    typedef ::mozilla::gfx::SurfaceFormat SurfaceFormat;
    typedef ::mozilla::ipc::SystemPrincipalInfo SystemPrincipalInfo;
    typedef ::mozilla::TimeStamp TimeStamp;
    typedef ::mozilla::dom::TimedChannelInfo TimedChannelInfo;
    template<class T> using UniquePtr = mozilla::UniquePtr<T>;
    typedef ::mozilla::dom::UserNavigationInvolvement UserNavigationInvolvement;
    typedef ::mozilla::dom::VisibilityState VisibilityState;
    typedef ::mozilla::ipc::WebTransportHash WebTransportHash;
    typedef ::mozilla::dom::WorkerOptions WorkerOptions;
    typedef ::mozilla::dom::WorkerType WorkerType;
    typedef ::int16_t int16_t;
    typedef ::int32_t int32_t;
    typedef ::int64_t int64_t;
    typedef ::int8_t int8_t;
    typedef ::intptr_t intptr_t;
    typedef ::nsCString nsCString;
    typedef ::nsID nsID;
    typedef ::nsIInputStream nsIInputStream;
    typedef ::nsIPolicyContainer nsIPolicyContainer;
    typedef ::nsIPrincipal nsIPrincipal;
    typedef ::nsIReferrerInfo nsIReferrerInfo;
    typedef ::nsIURI nsIURI;
    typedef ::nsIVariant nsIVariant;
    typedef ::nsSizeMode nsSizeMode;
    typedef ::nsString nsString;
    typedef ::nsresult nsresult;
    typedef ::mozilla::null_t null_t;
    typedef ::uint16_t uint16_t;
    typedef ::uint32_t uint32_t;
    typedef ::uint64_t uint64_t;
    typedef ::uint8_t uint8_t;
    typedef ::uintptr_t uintptr_t;
    typedef ::mozilla::void_t void_t;

public:
    typedef MozPromise<nsresult, ResponseRejectReason, true> CreateFileSystemManagerParentPromise;
    typedef MozPromise<std::tuple<nsresult, uint8_t>, ResponseRejectReason, true> CreateWebTransportParentPromise;
    typedef MozPromise<bool, ResponseRejectReason, true> CreateNotificationParentPromise;
    typedef MozPromise<nsTArray<SSCacheCopy>, ResponseRejectReason, true> GetSessionStorageManagerDataPromise;
    typedef MozPromise<bool, ResponseRejectReason, true> HasMIDIDevicePromise;
    typedef MozPromise<std::tuple<nsresult, Endpoint<::mozilla::PRemoteMediaManagerChild>>, ResponseRejectReason, true> EnsureRDDProcessAndCreateBridgePromise;
    typedef MozPromise<std::tuple<nsresult, Endpoint<::mozilla::PRemoteMediaManagerChild>>, ResponseRejectReason, true> EnsureUtilityProcessAndCreateBridgePromise;
    typedef MozPromise<CamerasAccessStatus, ResponseRejectReason, true> RequestCameraAccessPromise;

protected:
    virtual mozilla::ipc::IPCResult
    RecvPCacheConstructor(PCacheChild* actor);
    virtual mozilla::ipc::IPCResult
    RecvPCacheStreamControlConstructor(PCacheStreamControlChild* actor);
    virtual PBackgroundTestChild*
    AllocPBackgroundTestChild(const nsACString& testArg) = 0;
    virtual PBackgroundIndexedDBUtilsChild*
    AllocPBackgroundIndexedDBUtilsChild() = 0;
    virtual PBackgroundLSObserverChild*
    AllocPBackgroundLSObserverChild(const uint64_t& observerId) = 0;
    virtual PBackgroundLSRequestChild*
    AllocPBackgroundLSRequestChild(const LSRequestParams& params) = 0;
    virtual PBackgroundLSSimpleRequestChild*
    AllocPBackgroundLSSimpleRequestChild(const LSSimpleRequestParams& params) = 0;
    virtual PBackgroundLocalStorageCacheChild*
    AllocPBackgroundLocalStorageCacheChild(
            const PrincipalInfo& principalInfo,
            const nsACString& originKey,
            const uint32_t& privateBrowsingId) = 0;
    virtual PBackgroundStorageChild*
    AllocPBackgroundStorageChild(
            const nsAString& profilePath,
            const uint32_t& privateBrowsingId) = 0;
    virtual PCamerasChild*
    AllocPCamerasChild() = 0;
    virtual PUDPSocketChild*
    AllocPUDPSocketChild(
            const mozilla::Maybe<PrincipalInfo>& pInfo,
            const nsACString& filter) = 0;
    virtual PBroadcastChannelChild*
    AllocPBroadcastChannelChild(
            const PrincipalInfo& pInfo,
            const nsACString& origin,
            const nsAString& channel) = 0;
    virtual PCookieStoreChild*
    AllocPCookieStoreChild() = 0;
    virtual PServiceWorkerManagerChild*
    AllocPServiceWorkerManagerChild() = 0;
    virtual PMessagePortChild*
    AllocPMessagePortChild(
            const nsID& uuid,
            const nsID& destinationUuid,
            const uint32_t& sequenceId) = 0;
    virtual PSharedWorkerChild*
    AllocPSharedWorkerChild(
            const RemoteWorkerData& data,
            const uint64_t& windowID,
            const MessagePortIdentifier& portIdentifier) = 0;
    virtual PTemporaryIPCBlobChild*
    AllocPTemporaryIPCBlobChild() = 0;
    virtual PFileCreatorChild*
    AllocPFileCreatorChild(
            const nsAString& aFullPath,
            const nsAString& aType,
            const nsAString& aName,
            const mozilla::Maybe<int64_t>& lastModified,
            const bool& aExistenceCheck,
            const bool& aIsFromNsIFile) = 0;
    virtual PEndpointForReportChild*
    AllocPEndpointForReportChild(
            const nsAString& aGroupName,
            const PrincipalInfo& aPrincipalInfo) = 0;
    virtual already_AddRefed<PCacheChild>
    AllocPCacheChild() = 0;
    virtual already_AddRefed<PCacheStreamControlChild>
    AllocPCacheStreamControlChild() = 0;
    virtual bool
    DeallocPBackgroundIndexedDBUtilsChild(PBackgroundIndexedDBUtilsChild* aActor) = 0;
    virtual bool
    DeallocPBackgroundLSObserverChild(PBackgroundLSObserverChild* aActor) = 0;
    virtual bool
    DeallocPBackgroundLSRequestChild(PBackgroundLSRequestChild* aActor) = 0;
    virtual bool
    DeallocPBackgroundLSSimpleRequestChild(PBackgroundLSSimpleRequestChild* aActor) = 0;
    virtual bool
    DeallocPBackgroundLocalStorageCacheChild(PBackgroundLocalStorageCacheChild* aActor) = 0;
    virtual bool
    DeallocPBackgroundStorageChild(PBackgroundStorageChild* aActor) = 0;
    virtual bool
    DeallocPBackgroundTestChild(PBackgroundTestChild* aActor) = 0;
    virtual bool
    DeallocPBroadcastChannelChild(PBroadcastChannelChild* aActor) = 0;
    virtual bool
    DeallocPCookieStoreChild(PCookieStoreChild* aActor) = 0;
    virtual bool
    DeallocPEndpointForReportChild(PEndpointForReportChild* aActor) = 0;
    virtual bool
    DeallocPSharedWorkerChild(PSharedWorkerChild* aActor) = 0;
    virtual bool
    DeallocPTemporaryIPCBlobChild(PTemporaryIPCBlobChild* aActor) = 0;
    virtual bool
    DeallocPFileCreatorChild(PFileCreatorChild* aActor) = 0;
    virtual bool
    DeallocPMessagePortChild(PMessagePortChild* aActor) = 0;
    virtual bool
    DeallocPCamerasChild(PCamerasChild* aActor) = 0;
    virtual bool
    DeallocPServiceWorkerManagerChild(PServiceWorkerManagerChild* aActor) = 0;
    virtual bool
    DeallocPUDPSocketChild(PUDPSocketChild* aActor) = 0;
    void
    ProcessingError(
            Result aCode,
            const char* aReason) override;
    bool
    ShouldContinueFromReplyTimeout() override;

public:
    typedef mozilla::ipc::IProtocol IProtocol;
    typedef IPC::Message Message;
    typedef base::ProcessHandle ProcessHandle;
    typedef mozilla::ipc::MessageChannel MessageChannel;

public:
    MOZ_IMPLICIT PBackgroundChild();

    virtual ~PBackgroundChild();

protected:
    void
    ActorAlloc() final;
    void
    ActorDealloc() final;
public:
    ::base::ProcessId
    OtherPid() const;
    ::GeckoChildID
    OtherChildID() const;
    ::mozilla::ipc::EndpointProcInfo
    OtherEndpointProcInfo() const;

    void
    ManagedPBackgroundIDBFactoryChild(nsTArray<PBackgroundIDBFactoryChild*>& aArr) const;
    const ManagedContainer<PBackgroundIDBFactoryChild>&
    ManagedPBackgroundIDBFactoryChild() const;

    void
    ManagedPBackgroundIndexedDBUtilsChild(nsTArray<PBackgroundIndexedDBUtilsChild*>& aArr) const;
    const ManagedContainer<PBackgroundIndexedDBUtilsChild>&
    ManagedPBackgroundIndexedDBUtilsChild() const;

    void
    ManagedPBackgroundSDBConnectionChild(nsTArray<PBackgroundSDBConnectionChild*>& aArr) const;
    const ManagedContainer<PBackgroundSDBConnectionChild>&
    ManagedPBackgroundSDBConnectionChild() const;

    void
    ManagedPBackgroundLSObserverChild(nsTArray<PBackgroundLSObserverChild*>& aArr) const;
    const ManagedContainer<PBackgroundLSObserverChild>&
    ManagedPBackgroundLSObserverChild() const;

    void
    ManagedPBackgroundLSRequestChild(nsTArray<PBackgroundLSRequestChild*>& aArr) const;
    const ManagedContainer<PBackgroundLSRequestChild>&
    ManagedPBackgroundLSRequestChild() const;

    void
    ManagedPBackgroundLSSimpleRequestChild(nsTArray<PBackgroundLSSimpleRequestChild*>& aArr) const;
    const ManagedContainer<PBackgroundLSSimpleRequestChild>&
    ManagedPBackgroundLSSimpleRequestChild() const;

    void
    ManagedPBackgroundLocalStorageCacheChild(nsTArray<PBackgroundLocalStorageCacheChild*>& aArr) const;
    const ManagedContainer<PBackgroundLocalStorageCacheChild>&
    ManagedPBackgroundLocalStorageCacheChild() const;

    void
    ManagedPBackgroundSessionStorageManagerChild(nsTArray<PBackgroundSessionStorageManagerChild*>& aArr) const;
    const ManagedContainer<PBackgroundSessionStorageManagerChild>&
    ManagedPBackgroundSessionStorageManagerChild() const;

    void
    ManagedPBackgroundSessionStorageServiceChild(nsTArray<PBackgroundSessionStorageServiceChild*>& aArr) const;
    const ManagedContainer<PBackgroundSessionStorageServiceChild>&
    ManagedPBackgroundSessionStorageServiceChild() const;

    void
    ManagedPBackgroundStorageChild(nsTArray<PBackgroundStorageChild*>& aArr) const;
    const ManagedContainer<PBackgroundStorageChild>&
    ManagedPBackgroundStorageChild() const;

    void
    ManagedPBackgroundTestChild(nsTArray<PBackgroundTestChild*>& aArr) const;
    const ManagedContainer<PBackgroundTestChild>&
    ManagedPBackgroundTestChild() const;

    void
    ManagedPBroadcastChannelChild(nsTArray<PBroadcastChannelChild*>& aArr) const;
    const ManagedContainer<PBroadcastChannelChild>&
    ManagedPBroadcastChannelChild() const;

    void
    ManagedPCacheChild(nsTArray<PCacheChild*>& aArr) const;
    const ManagedContainer<PCacheChild>&
    ManagedPCacheChild() const;

    void
    ManagedPCacheStorageChild(nsTArray<PCacheStorageChild*>& aArr) const;
    const ManagedContainer<PCacheStorageChild>&
    ManagedPCacheStorageChild() const;

    void
    ManagedPCacheStreamControlChild(nsTArray<PCacheStreamControlChild*>& aArr) const;
    const ManagedContainer<PCacheStreamControlChild>&
    ManagedPCacheStreamControlChild() const;

    void
    ManagedPClientManagerChild(nsTArray<PClientManagerChild*>& aArr) const;
    const ManagedContainer<PClientManagerChild>&
    ManagedPClientManagerChild() const;

    void
    ManagedPCookieStoreChild(nsTArray<PCookieStoreChild*>& aArr) const;
    const ManagedContainer<PCookieStoreChild>&
    ManagedPCookieStoreChild() const;

    void
    ManagedPEndpointForReportChild(nsTArray<PEndpointForReportChild*>& aArr) const;
    const ManagedContainer<PEndpointForReportChild>&
    ManagedPEndpointForReportChild() const;

    void
    ManagedPFileSystemRequestChild(nsTArray<PFileSystemRequestChild*>& aArr) const;
    const ManagedContainer<PFileSystemRequestChild>&
    ManagedPFileSystemRequestChild() const;

    void
    ManagedPGamepadEventChannelChild(nsTArray<PGamepadEventChannelChild*>& aArr) const;
    const ManagedContainer<PGamepadEventChannelChild>&
    ManagedPGamepadEventChannelChild() const;

    void
    ManagedPGamepadTestChannelChild(nsTArray<PGamepadTestChannelChild*>& aArr) const;
    const ManagedContainer<PGamepadTestChannelChild>&
    ManagedPGamepadTestChannelChild() const;

    void
    ManagedPHttpBackgroundChannelChild(nsTArray<PHttpBackgroundChannelChild*>& aArr) const;
    const ManagedContainer<PHttpBackgroundChannelChild>&
    ManagedPHttpBackgroundChannelChild() const;

    void
    ManagedPIdleSchedulerChild(nsTArray<PIdleSchedulerChild*>& aArr) const;
    const ManagedContainer<PIdleSchedulerChild>&
    ManagedPIdleSchedulerChild() const;

    void
    ManagedPLockManagerChild(nsTArray<PLockManagerChild*>& aArr) const;
    const ManagedContainer<PLockManagerChild>&
    ManagedPLockManagerChild() const;

    void
    ManagedPRemoteWorkerControllerChild(nsTArray<PRemoteWorkerControllerChild*>& aArr) const;
    const ManagedContainer<PRemoteWorkerControllerChild>&
    ManagedPRemoteWorkerControllerChild() const;

    void
    ManagedPSharedWorkerChild(nsTArray<PSharedWorkerChild*>& aArr) const;
    const ManagedContainer<PSharedWorkerChild>&
    ManagedPSharedWorkerChild() const;

    void
    ManagedPTemporaryIPCBlobChild(nsTArray<PTemporaryIPCBlobChild*>& aArr) const;
    const ManagedContainer<PTemporaryIPCBlobChild>&
    ManagedPTemporaryIPCBlobChild() const;

    void
    ManagedPFileCreatorChild(nsTArray<PFileCreatorChild*>& aArr) const;
    const ManagedContainer<PFileCreatorChild>&
    ManagedPFileCreatorChild() const;

    void
    ManagedPMessagePortChild(nsTArray<PMessagePortChild*>& aArr) const;
    const ManagedContainer<PMessagePortChild>&
    ManagedPMessagePortChild() const;

    void
    ManagedPCamerasChild(nsTArray<PCamerasChild*>& aArr) const;
    const ManagedContainer<PCamerasChild>&
    ManagedPCamerasChild() const;

    void
    ManagedPQuotaChild(nsTArray<PQuotaChild*>& aArr) const;
    const ManagedContainer<PQuotaChild>&
    ManagedPQuotaChild() const;

    void
    ManagedPServiceWorkerChild(nsTArray<PServiceWorkerChild*>& aArr) const;
    const ManagedContainer<PServiceWorkerChild>&
    ManagedPServiceWorkerChild() const;

    void
    ManagedPServiceWorkerContainerChild(nsTArray<PServiceWorkerContainerChild*>& aArr) const;
    const ManagedContainer<PServiceWorkerContainerChild>&
    ManagedPServiceWorkerContainerChild() const;

    void
    ManagedPServiceWorkerManagerChild(nsTArray<PServiceWorkerManagerChild*>& aArr) const;
    const ManagedContainer<PServiceWorkerManagerChild>&
    ManagedPServiceWorkerManagerChild() const;

    void
    ManagedPServiceWorkerRegistrationChild(nsTArray<PServiceWorkerRegistrationChild*>& aArr) const;
    const ManagedContainer<PServiceWorkerRegistrationChild>&
    ManagedPServiceWorkerRegistrationChild() const;

    void
    ManagedPUDPSocketChild(nsTArray<PUDPSocketChild*>& aArr) const;
    const ManagedContainer<PUDPSocketChild>&
    ManagedPUDPSocketChild() const;

    void
    ManagedPVsyncChild(nsTArray<PVsyncChild*>& aArr) const;
    const ManagedContainer<PVsyncChild>&
    ManagedPVsyncChild() const;

    void
    ManagedPFetchChild(nsTArray<PFetchChild*>& aArr) const;
    const ManagedContainer<PFetchChild>&
    ManagedPFetchChild() const;

    mozilla::Span<mozilla::ipc::ProtocolId const>
    ManagedProtocolIds() const final;

    UntypedManagedContainer*
    GetManagedActors(mozilla::ipc::ProtocolId aProtocol) final;

    void
    RejectPendingResponses(ResponseRejectReason aReason) final;

    ManagedEndpoint<PBackgroundIDBFactoryParent>
    OpenPBackgroundIDBFactoryEndpoint(PBackgroundIDBFactoryChild* aActor);
    bool
    BindPBackgroundIDBFactoryEndpoint(
            ManagedEndpoint<PBackgroundIDBFactoryChild> aEndpoint,
            PBackgroundIDBFactoryChild* aActor);

    ManagedEndpoint<PBackgroundIndexedDBUtilsParent>
    OpenPBackgroundIndexedDBUtilsEndpoint(PBackgroundIndexedDBUtilsChild* aActor);
    bool
    BindPBackgroundIndexedDBUtilsEndpoint(
            ManagedEndpoint<PBackgroundIndexedDBUtilsChild> aEndpoint,
            PBackgroundIndexedDBUtilsChild* aActor);

    ManagedEndpoint<PBackgroundSDBConnectionParent>
    OpenPBackgroundSDBConnectionEndpoint(PBackgroundSDBConnectionChild* aActor);
    bool
    BindPBackgroundSDBConnectionEndpoint(
            ManagedEndpoint<PBackgroundSDBConnectionChild> aEndpoint,
            PBackgroundSDBConnectionChild* aActor);

    ManagedEndpoint<PBackgroundLSObserverParent>
    OpenPBackgroundLSObserverEndpoint(PBackgroundLSObserverChild* aActor);
    bool
    BindPBackgroundLSObserverEndpoint(
            ManagedEndpoint<PBackgroundLSObserverChild> aEndpoint,
            PBackgroundLSObserverChild* aActor);

    ManagedEndpoint<PBackgroundLSRequestParent>
    OpenPBackgroundLSRequestEndpoint(PBackgroundLSRequestChild* aActor);
    bool
    BindPBackgroundLSRequestEndpoint(
            ManagedEndpoint<PBackgroundLSRequestChild> aEndpoint,
            PBackgroundLSRequestChild* aActor);

    ManagedEndpoint<PBackgroundLSSimpleRequestParent>
    OpenPBackgroundLSSimpleRequestEndpoint(PBackgroundLSSimpleRequestChild* aActor);
    bool
    BindPBackgroundLSSimpleRequestEndpoint(
            ManagedEndpoint<PBackgroundLSSimpleRequestChild> aEndpoint,
            PBackgroundLSSimpleRequestChild* aActor);

    ManagedEndpoint<PBackgroundLocalStorageCacheParent>
    OpenPBackgroundLocalStorageCacheEndpoint(PBackgroundLocalStorageCacheChild* aActor);
    bool
    BindPBackgroundLocalStorageCacheEndpoint(
            ManagedEndpoint<PBackgroundLocalStorageCacheChild> aEndpoint,
            PBackgroundLocalStorageCacheChild* aActor);

    ManagedEndpoint<PBackgroundSessionStorageManagerParent>
    OpenPBackgroundSessionStorageManagerEndpoint(PBackgroundSessionStorageManagerChild* aActor);
    bool
    BindPBackgroundSessionStorageManagerEndpoint(
            ManagedEndpoint<PBackgroundSessionStorageManagerChild> aEndpoint,
            PBackgroundSessionStorageManagerChild* aActor);

    ManagedEndpoint<PBackgroundSessionStorageServiceParent>
    OpenPBackgroundSessionStorageServiceEndpoint(PBackgroundSessionStorageServiceChild* aActor);
    bool
    BindPBackgroundSessionStorageServiceEndpoint(
            ManagedEndpoint<PBackgroundSessionStorageServiceChild> aEndpoint,
            PBackgroundSessionStorageServiceChild* aActor);

    ManagedEndpoint<PBackgroundStorageParent>
    OpenPBackgroundStorageEndpoint(PBackgroundStorageChild* aActor);
    bool
    BindPBackgroundStorageEndpoint(
            ManagedEndpoint<PBackgroundStorageChild> aEndpoint,
            PBackgroundStorageChild* aActor);

    ManagedEndpoint<PBackgroundTestParent>
    OpenPBackgroundTestEndpoint(PBackgroundTestChild* aActor);
    bool
    BindPBackgroundTestEndpoint(
            ManagedEndpoint<PBackgroundTestChild> aEndpoint,
            PBackgroundTestChild* aActor);

    ManagedEndpoint<PBroadcastChannelParent>
    OpenPBroadcastChannelEndpoint(PBroadcastChannelChild* aActor);
    bool
    BindPBroadcastChannelEndpoint(
            ManagedEndpoint<PBroadcastChannelChild> aEndpoint,
            PBroadcastChannelChild* aActor);

    ManagedEndpoint<PCacheParent>
    OpenPCacheEndpoint(PCacheChild* aActor);
    bool
    BindPCacheEndpoint(
            ManagedEndpoint<PCacheChild> aEndpoint,
            PCacheChild* aActor);

    ManagedEndpoint<PCacheStorageParent>
    OpenPCacheStorageEndpoint(PCacheStorageChild* aActor);
    bool
    BindPCacheStorageEndpoint(
            ManagedEndpoint<PCacheStorageChild> aEndpoint,
            PCacheStorageChild* aActor);

    ManagedEndpoint<PCacheStreamControlParent>
    OpenPCacheStreamControlEndpoint(PCacheStreamControlChild* aActor);
    bool
    BindPCacheStreamControlEndpoint(
            ManagedEndpoint<PCacheStreamControlChild> aEndpoint,
            PCacheStreamControlChild* aActor);

    ManagedEndpoint<PClientManagerParent>
    OpenPClientManagerEndpoint(PClientManagerChild* aActor);
    bool
    BindPClientManagerEndpoint(
            ManagedEndpoint<PClientManagerChild> aEndpoint,
            PClientManagerChild* aActor);

    ManagedEndpoint<PCookieStoreParent>
    OpenPCookieStoreEndpoint(PCookieStoreChild* aActor);
    bool
    BindPCookieStoreEndpoint(
            ManagedEndpoint<PCookieStoreChild> aEndpoint,
            PCookieStoreChild* aActor);

    ManagedEndpoint<PEndpointForReportParent>
    OpenPEndpointForReportEndpoint(PEndpointForReportChild* aActor);
    bool
    BindPEndpointForReportEndpoint(
            ManagedEndpoint<PEndpointForReportChild> aEndpoint,
            PEndpointForReportChild* aActor);

    ManagedEndpoint<PFileSystemRequestParent>
    OpenPFileSystemRequestEndpoint(PFileSystemRequestChild* aActor);
    bool
    BindPFileSystemRequestEndpoint(
            ManagedEndpoint<PFileSystemRequestChild> aEndpoint,
            PFileSystemRequestChild* aActor);

    ManagedEndpoint<PGamepadEventChannelParent>
    OpenPGamepadEventChannelEndpoint(PGamepadEventChannelChild* aActor);
    bool
    BindPGamepadEventChannelEndpoint(
            ManagedEndpoint<PGamepadEventChannelChild> aEndpoint,
            PGamepadEventChannelChild* aActor);

    ManagedEndpoint<PGamepadTestChannelParent>
    OpenPGamepadTestChannelEndpoint(PGamepadTestChannelChild* aActor);
    bool
    BindPGamepadTestChannelEndpoint(
            ManagedEndpoint<PGamepadTestChannelChild> aEndpoint,
            PGamepadTestChannelChild* aActor);

    ManagedEndpoint<PHttpBackgroundChannelParent>
    OpenPHttpBackgroundChannelEndpoint(PHttpBackgroundChannelChild* aActor);
    bool
    BindPHttpBackgroundChannelEndpoint(
            ManagedEndpoint<PHttpBackgroundChannelChild> aEndpoint,
            PHttpBackgroundChannelChild* aActor);

    ManagedEndpoint<PIdleSchedulerParent>
    OpenPIdleSchedulerEndpoint(PIdleSchedulerChild* aActor);
    bool
    BindPIdleSchedulerEndpoint(
            ManagedEndpoint<PIdleSchedulerChild> aEndpoint,
            PIdleSchedulerChild* aActor);

    ManagedEndpoint<PLockManagerParent>
    OpenPLockManagerEndpoint(PLockManagerChild* aActor);
    bool
    BindPLockManagerEndpoint(
            ManagedEndpoint<PLockManagerChild> aEndpoint,
            PLockManagerChild* aActor);

    ManagedEndpoint<PRemoteWorkerControllerParent>
    OpenPRemoteWorkerControllerEndpoint(PRemoteWorkerControllerChild* aActor);
    bool
    BindPRemoteWorkerControllerEndpoint(
            ManagedEndpoint<PRemoteWorkerControllerChild> aEndpoint,
            PRemoteWorkerControllerChild* aActor);

    ManagedEndpoint<PSharedWorkerParent>
    OpenPSharedWorkerEndpoint(PSharedWorkerChild* aActor);
    bool
    BindPSharedWorkerEndpoint(
            ManagedEndpoint<PSharedWorkerChild> aEndpoint,
            PSharedWorkerChild* aActor);

    ManagedEndpoint<PTemporaryIPCBlobParent>
    OpenPTemporaryIPCBlobEndpoint(PTemporaryIPCBlobChild* aActor);
    bool
    BindPTemporaryIPCBlobEndpoint(
            ManagedEndpoint<PTemporaryIPCBlobChild> aEndpoint,
            PTemporaryIPCBlobChild* aActor);

    ManagedEndpoint<PFileCreatorParent>
    OpenPFileCreatorEndpoint(PFileCreatorChild* aActor);
    bool
    BindPFileCreatorEndpoint(
            ManagedEndpoint<PFileCreatorChild> aEndpoint,
            PFileCreatorChild* aActor);

    ManagedEndpoint<PMessagePortParent>
    OpenPMessagePortEndpoint(PMessagePortChild* aActor);
    bool
    BindPMessagePortEndpoint(
            ManagedEndpoint<PMessagePortChild> aEndpoint,
            PMessagePortChild* aActor);

    ManagedEndpoint<PCamerasParent>
    OpenPCamerasEndpoint(PCamerasChild* aActor);
    bool
    BindPCamerasEndpoint(
            ManagedEndpoint<PCamerasChild> aEndpoint,
            PCamerasChild* aActor);

    ManagedEndpoint<PQuotaParent>
    OpenPQuotaEndpoint(PQuotaChild* aActor);
    bool
    BindPQuotaEndpoint(
            ManagedEndpoint<PQuotaChild> aEndpoint,
            PQuotaChild* aActor);

    ManagedEndpoint<PServiceWorkerParent>
    OpenPServiceWorkerEndpoint(PServiceWorkerChild* aActor);
    bool
    BindPServiceWorkerEndpoint(
            ManagedEndpoint<PServiceWorkerChild> aEndpoint,
            PServiceWorkerChild* aActor);

    ManagedEndpoint<PServiceWorkerContainerParent>
    OpenPServiceWorkerContainerEndpoint(PServiceWorkerContainerChild* aActor);
    bool
    BindPServiceWorkerContainerEndpoint(
            ManagedEndpoint<PServiceWorkerContainerChild> aEndpoint,
            PServiceWorkerContainerChild* aActor);

    ManagedEndpoint<PServiceWorkerManagerParent>
    OpenPServiceWorkerManagerEndpoint(PServiceWorkerManagerChild* aActor);
    bool
    BindPServiceWorkerManagerEndpoint(
            ManagedEndpoint<PServiceWorkerManagerChild> aEndpoint,
            PServiceWorkerManagerChild* aActor);

    ManagedEndpoint<PServiceWorkerRegistrationParent>
    OpenPServiceWorkerRegistrationEndpoint(PServiceWorkerRegistrationChild* aActor);
    bool
    BindPServiceWorkerRegistrationEndpoint(
            ManagedEndpoint<PServiceWorkerRegistrationChild> aEndpoint,
            PServiceWorkerRegistrationChild* aActor);

    ManagedEndpoint<PUDPSocketParent>
    OpenPUDPSocketEndpoint(PUDPSocketChild* aActor);
    bool
    BindPUDPSocketEndpoint(
            ManagedEndpoint<PUDPSocketChild> aEndpoint,
            PUDPSocketChild* aActor);

    ManagedEndpoint<PVsyncParent>
    OpenPVsyncEndpoint(PVsyncChild* aActor);
    bool
    BindPVsyncEndpoint(
            ManagedEndpoint<PVsyncChild> aEndpoint,
            PVsyncChild* aActor);

    ManagedEndpoint<PFetchParent>
    OpenPFetchEndpoint(PFetchChild* aActor);
    bool
    BindPFetchEndpoint(
            ManagedEndpoint<PFetchChild> aEndpoint,
            PFetchChild* aActor);

    PBackgroundTestChild*
    SendPBackgroundTestConstructor(const nsACString& testArg);

    PBackgroundTestChild*
    SendPBackgroundTestConstructor(
            PBackgroundTestChild* actor,
            const nsACString& testArg);

    PBackgroundIDBFactoryChild*
    SendPBackgroundIDBFactoryConstructor(
            PBackgroundIDBFactoryChild* actor,
            const LoggingInfo& loggingInfo,
            const nsACString& systemLocale);

    PBackgroundIndexedDBUtilsChild*
    SendPBackgroundIndexedDBUtilsConstructor();

    PBackgroundIndexedDBUtilsChild*
    SendPBackgroundIndexedDBUtilsConstructor(PBackgroundIndexedDBUtilsChild* actor);

    bool
    SendFlushPendingFileDeletions();

    PBackgroundSDBConnectionChild*
    SendPBackgroundSDBConnectionConstructor(
            PBackgroundSDBConnectionChild* actor,
            const PersistenceType& persistenceType,
            const PrincipalInfo& principalInfo);

    PBackgroundLSObserverChild*
    SendPBackgroundLSObserverConstructor(const uint64_t& observerId);

    PBackgroundLSObserverChild*
    SendPBackgroundLSObserverConstructor(
            PBackgroundLSObserverChild* actor,
            const uint64_t& observerId);

    PBackgroundLSRequestChild*
    SendPBackgroundLSRequestConstructor(const LSRequestParams& params);

    PBackgroundLSRequestChild*
    SendPBackgroundLSRequestConstructor(
            PBackgroundLSRequestChild* actor,
            const LSRequestParams& params);

    PBackgroundLSSimpleRequestChild*
    SendPBackgroundLSSimpleRequestConstructor(const LSSimpleRequestParams& params);

    PBackgroundLSSimpleRequestChild*
    SendPBackgroundLSSimpleRequestConstructor(
            PBackgroundLSSimpleRequestChild* actor,
            const LSSimpleRequestParams& params);

    PBackgroundLocalStorageCacheChild*
    SendPBackgroundLocalStorageCacheConstructor(
            const PrincipalInfo& principalInfo,
            const nsACString& originKey,
            const uint32_t& privateBrowsingId);

    PBackgroundLocalStorageCacheChild*
    SendPBackgroundLocalStorageCacheConstructor(
            PBackgroundLocalStorageCacheChild* actor,
            const PrincipalInfo& principalInfo,
            const nsACString& originKey,
            const uint32_t& privateBrowsingId);

    PBackgroundSessionStorageManagerChild*
    SendPBackgroundSessionStorageManagerConstructor(
            PBackgroundSessionStorageManagerChild* actor,
            const uint64_t& aTopContextId);

    PBackgroundSessionStorageServiceChild*
    SendPBackgroundSessionStorageServiceConstructor(PBackgroundSessionStorageServiceChild* actor);

    PBackgroundStorageChild*
    SendPBackgroundStorageConstructor(
            const nsAString& profilePath,
            const uint32_t& privateBrowsingId);

    PBackgroundStorageChild*
    SendPBackgroundStorageConstructor(
            PBackgroundStorageChild* actor,
            const nsAString& profilePath,
            const uint32_t& privateBrowsingId);

    void
    SendCreateFileSystemManagerParent(
            const PrincipalInfo& principalInfo,
            Endpoint<::mozilla::dom::PFileSystemManagerParent>&& aParentEndpoint,
            mozilla::ipc::ResolveCallback<nsresult>&& aResolve,
            mozilla::ipc::RejectCallback&& aReject);

    RefPtr<CreateFileSystemManagerParentPromise>
    SendCreateFileSystemManagerParent(
            const PrincipalInfo& principalInfo,
            Endpoint<::mozilla::dom::PFileSystemManagerParent>&& aParentEndpoint);

    void
    SendCreateWebTransportParent(
            const nsAString& aURL,
            nsIPrincipal* aPrincipal,
            const mozilla::Maybe<IPCClientInfo>& aClientInfo,
            const bool& aDedicated,
            const bool& aRequireUnreliable,
            const uint32_t& aCongestionControl,
            mozilla::Span<WebTransportHash const> aServerCertHashes,
            Endpoint<::mozilla::dom::PWebTransportParent>&& aParentEndpoint,
            mozilla::ipc::ResolveCallback<std::tuple<nsresult, uint8_t>>&& aResolve,
            mozilla::ipc::RejectCallback&& aReject);

    RefPtr<CreateWebTransportParentPromise>
    SendCreateWebTransportParent(
            const nsAString& aURL,
            nsIPrincipal* aPrincipal,
            const mozilla::Maybe<IPCClientInfo>& aClientInfo,
            const bool& aDedicated,
            const bool& aRequireUnreliable,
            const uint32_t& aCongestionControl,
            mozilla::Span<WebTransportHash const> aServerCertHashes,
            Endpoint<::mozilla::dom::PWebTransportParent>&& aParentEndpoint);

    void
    SendCreateNotificationParent(
            Endpoint<::mozilla::dom::notification::PNotificationParent>&& aParentEndpoint,
            mozilla::NotNull<nsIPrincipal*> aPrincipal,
            mozilla::NotNull<nsIPrincipal*> aEffectiveStoragePrincipal,
            const bool& aIsSecureContext,
            const nsAString& aScope,
            const IPCNotification& aNotification,
            mozilla::ipc::ResolveCallback<bool>&& aResolve,
            mozilla::ipc::RejectCallback&& aReject);

    RefPtr<CreateNotificationParentPromise>
    SendCreateNotificationParent(
            Endpoint<::mozilla::dom::notification::PNotificationParent>&& aParentEndpoint,
            mozilla::NotNull<nsIPrincipal*> aPrincipal,
            mozilla::NotNull<nsIPrincipal*> aEffectiveStoragePrincipal,
            const bool& aIsSecureContext,
            const nsAString& aScope,
            const IPCNotification& aNotification);

    PVsyncChild*
    SendPVsyncConstructor(PVsyncChild* actor);

    PCamerasChild*
    SendPCamerasConstructor();

    PCamerasChild*
    SendPCamerasConstructor(PCamerasChild* actor);

    PUDPSocketChild*
    SendPUDPSocketConstructor(
            const mozilla::Maybe<PrincipalInfo>& pInfo,
            const nsACString& filter);

    PUDPSocketChild*
    SendPUDPSocketConstructor(
            PUDPSocketChild* actor,
            const mozilla::Maybe<PrincipalInfo>& pInfo,
            const nsACString& filter);

    PBroadcastChannelChild*
    SendPBroadcastChannelConstructor(
            const PrincipalInfo& pInfo,
            const nsACString& origin,
            const nsAString& channel);

    PBroadcastChannelChild*
    SendPBroadcastChannelConstructor(
            PBroadcastChannelChild* actor,
            const PrincipalInfo& pInfo,
            const nsACString& origin,
            const nsAString& channel);

    PCookieStoreChild*
    SendPCookieStoreConstructor();

    PCookieStoreChild*
    SendPCookieStoreConstructor(PCookieStoreChild* actor);

    PServiceWorkerManagerChild*
    SendPServiceWorkerManagerConstructor();

    PServiceWorkerManagerChild*
    SendPServiceWorkerManagerConstructor(PServiceWorkerManagerChild* actor);

    bool
    SendShutdownServiceWorkerRegistrar();

    PCacheStorageChild*
    SendPCacheStorageConstructor(
            PCacheStorageChild* actor,
            const Namespace& aNamespace,
            const PrincipalInfo& aPrincipalInfo);

    PMessagePortChild*
    SendPMessagePortConstructor(
            const nsID& uuid,
            const nsID& destinationUuid,
            const uint32_t& sequenceId);

    PMessagePortChild*
    SendPMessagePortConstructor(
            PMessagePortChild* actor,
            const nsID& uuid,
            const nsID& destinationUuid,
            const uint32_t& sequenceId);

    bool
    SendMessagePortForceClose(
            const nsID& uuid,
            const nsID& destinationUuid,
            const uint32_t& sequenceId);

    PQuotaChild*
    SendPQuotaConstructor(PQuotaChild* actor);

    bool
    SendShutdownQuotaManager();

    bool
    SendShutdownBackgroundSessionStorageManagers();

    bool
    SendPropagateBackgroundSessionStorageManager(
            const uint64_t& currentTopContextId,
            const uint64_t& targetTopContextId);

    bool
    SendRemoveBackgroundSessionStorageManager(const uint64_t& topContextId);

    void
    SendGetSessionStorageManagerData(
            const uint64_t& aTopContextId,
            const uint32_t& aSizeLimit,
            const bool& aCancelSessionStoreTimer,
            mozilla::ipc::ResolveCallback<nsTArray<SSCacheCopy>>&& aResolve,
            mozilla::ipc::RejectCallback&& aReject);

    RefPtr<GetSessionStorageManagerDataPromise>
    SendGetSessionStorageManagerData(
            const uint64_t& aTopContextId,
            const uint32_t& aSizeLimit,
            const bool& aCancelSessionStoreTimer);

    bool
    SendLoadSessionStorageManagerData(
            const uint64_t& aTopContextId,
            mozilla::Span<SSCacheCopy const> aOriginCacheCopy);

    PFileSystemRequestChild*
    SendPFileSystemRequestConstructor(
            PFileSystemRequestChild* actor,
            const FileSystemParams& params);

    PGamepadEventChannelChild*
    SendPGamepadEventChannelConstructor(PGamepadEventChannelChild* actor);

    PGamepadTestChannelChild*
    SendPGamepadTestChannelConstructor(PGamepadTestChannelChild* actor);

    PHttpBackgroundChannelChild*
    SendPHttpBackgroundChannelConstructor(
            PHttpBackgroundChannelChild* actor,
            const uint64_t& channelId);

    PSharedWorkerChild*
    SendPSharedWorkerConstructor(
            const RemoteWorkerData& data,
            const uint64_t& windowID,
            const MessagePortIdentifier& portIdentifier);

    PSharedWorkerChild*
    SendPSharedWorkerConstructor(
            PSharedWorkerChild* actor,
            const RemoteWorkerData& data,
            const uint64_t& windowID,
            const MessagePortIdentifier& portIdentifier);

    PTemporaryIPCBlobChild*
    SendPTemporaryIPCBlobConstructor();

    PTemporaryIPCBlobChild*
    SendPTemporaryIPCBlobConstructor(PTemporaryIPCBlobChild* actor);

    PFileCreatorChild*
    SendPFileCreatorConstructor(
            const nsAString& aFullPath,
            const nsAString& aType,
            const nsAString& aName,
            const mozilla::Maybe<int64_t>& lastModified,
            const bool& aExistenceCheck,
            const bool& aIsFromNsIFile);

    PFileCreatorChild*
    SendPFileCreatorConstructor(
            PFileCreatorChild* actor,
            const nsAString& aFullPath,
            const nsAString& aType,
            const nsAString& aName,
            const mozilla::Maybe<int64_t>& lastModified,
            const bool& aExistenceCheck,
            const bool& aIsFromNsIFile);

    PClientManagerChild*
    SendPClientManagerConstructor(PClientManagerChild* actor);

    bool
    SendCreateBoundStorageKeyParent(
            Endpoint<::mozilla::dom::cache::PBoundStorageKeyParent>&& aEndPoint,
            const Namespace& aNamespace,
            const PrincipalInfo& aPrincipalInfo);

    bool
    SendCreateMIDIManager(Endpoint<::mozilla::dom::PMIDIManagerParent>&& aEndpoint);

    bool
    SendCreateMIDIPort(
            Endpoint<::mozilla::dom::PMIDIPortParent>&& aEndpoint,
            const MIDIPortInfo& portInfo,
            const bool& sysexEnabled);

    void
    SendHasMIDIDevice(
            mozilla::ipc::ResolveCallback<bool>&& aResolve,
            mozilla::ipc::RejectCallback&& aReject);

    RefPtr<HasMIDIDevicePromise>
    SendHasMIDIDevice();

    bool
    SendCreateMLSTransaction(
            Endpoint<::mozilla::dom::PMLSTransactionParent>&& aEndpoint,
            mozilla::NotNull<nsIPrincipal*> aPrincipal);

    bool
    SendStorageActivity(const PrincipalInfo& principalInfo);

    PServiceWorkerChild*
    SendPServiceWorkerConstructor(
            PServiceWorkerChild* actor,
            const IPCServiceWorkerDescriptor& aDescriptor);

    PRemoteWorkerControllerChild*
    SendPRemoteWorkerControllerConstructor(
            PRemoteWorkerControllerChild* actor,
            const RemoteWorkerData& aData);

    PServiceWorkerContainerChild*
    SendPServiceWorkerContainerConstructor(PServiceWorkerContainerChild* actor);

    PServiceWorkerRegistrationChild*
    SendPServiceWorkerRegistrationConstructor(
            PServiceWorkerRegistrationChild* actor,
            const IPCServiceWorkerRegistrationDescriptor& aDescriptor,
            const IPCClientInfo& aForClient);

    PEndpointForReportChild*
    SendPEndpointForReportConstructor(
            const nsAString& aGroupName,
            const PrincipalInfo& aPrincipalInfo);

    PEndpointForReportChild*
    SendPEndpointForReportConstructor(
            PEndpointForReportChild* actor,
            const nsAString& aGroupName,
            const PrincipalInfo& aPrincipalInfo);

    bool
    SendRemoveEndpoint(
            const nsAString& aGroupName,
            const nsACString& aEndpointURL,
            const PrincipalInfo& aPrincipalInfo);

    PIdleSchedulerChild*
    SendPIdleSchedulerConstructor(PIdleSchedulerChild* actor);

    void
    SendEnsureRDDProcessAndCreateBridge(
            mozilla::ipc::ResolveCallback<std::tuple<nsresult, Endpoint<::mozilla::PRemoteMediaManagerChild>>>&& aResolve,
            mozilla::ipc::RejectCallback&& aReject);

    RefPtr<EnsureRDDProcessAndCreateBridgePromise>
    SendEnsureRDDProcessAndCreateBridge();

    void
    SendEnsureUtilityProcessAndCreateBridge(
            const RemoteMediaIn& aLocation,
            mozilla::ipc::ResolveCallback<std::tuple<nsresult, Endpoint<::mozilla::PRemoteMediaManagerChild>>>&& aResolve,
            mozilla::ipc::RejectCallback&& aReject);

    RefPtr<EnsureUtilityProcessAndCreateBridgePromise>
    SendEnsureUtilityProcessAndCreateBridge(const RemoteMediaIn& aLocation);

    PLockManagerChild*
    SendPLockManagerConstructor(
            PLockManagerChild* actor,
            mozilla::NotNull<nsIPrincipal*> aPrincipalInfo,
            const mozilla::Maybe<nsID>& aClientId);

    PFetchChild*
    SendPFetchConstructor(PFetchChild* actor);

    void
    SendRequestCameraAccess(
            const bool& aAllowPermissionRequest,
            mozilla::ipc::ResolveCallback<CamerasAccessStatus>&& aResolve,
            mozilla::ipc::RejectCallback&& aReject);

    RefPtr<RequestCameraAccessPromise>
    SendRequestCameraAccess(const bool& aAllowPermissionRequest);

    void
    DeallocManagee(
            mozilla::ipc::ProtocolId aProtocolId,
            IProtocol* aListener) override;

    Result
    OnMessageReceived(const Message& msg__) override;

    Result
    OnMessageReceived(
            const Message& msg__,
            UniquePtr<Message>& reply__) override;

private:
    mozilla::ipc::IPDLAsyncReturnsCallbacks mAsyncCallbacks;

    ManagedContainer<PBackgroundIDBFactoryChild> mManagedPBackgroundIDBFactoryChild;
    ManagedContainer<PBackgroundIndexedDBUtilsChild> mManagedPBackgroundIndexedDBUtilsChild;
    ManagedContainer<PBackgroundSDBConnectionChild> mManagedPBackgroundSDBConnectionChild;
    ManagedContainer<PBackgroundLSObserverChild> mManagedPBackgroundLSObserverChild;
    ManagedContainer<PBackgroundLSRequestChild> mManagedPBackgroundLSRequestChild;
    ManagedContainer<PBackgroundLSSimpleRequestChild> mManagedPBackgroundLSSimpleRequestChild;
    ManagedContainer<PBackgroundLocalStorageCacheChild> mManagedPBackgroundLocalStorageCacheChild;
    ManagedContainer<PBackgroundSessionStorageManagerChild> mManagedPBackgroundSessionStorageManagerChild;
    ManagedContainer<PBackgroundSessionStorageServiceChild> mManagedPBackgroundSessionStorageServiceChild;
    ManagedContainer<PBackgroundStorageChild> mManagedPBackgroundStorageChild;
    ManagedContainer<PBackgroundTestChild> mManagedPBackgroundTestChild;
    ManagedContainer<PBroadcastChannelChild> mManagedPBroadcastChannelChild;
    ManagedContainer<PCacheChild> mManagedPCacheChild;
    ManagedContainer<PCacheStorageChild> mManagedPCacheStorageChild;
    ManagedContainer<PCacheStreamControlChild> mManagedPCacheStreamControlChild;
    ManagedContainer<PClientManagerChild> mManagedPClientManagerChild;
    ManagedContainer<PCookieStoreChild> mManagedPCookieStoreChild;
    ManagedContainer<PEndpointForReportChild> mManagedPEndpointForReportChild;
    ManagedContainer<PFileSystemRequestChild> mManagedPFileSystemRequestChild;
    ManagedContainer<PGamepadEventChannelChild> mManagedPGamepadEventChannelChild;
    ManagedContainer<PGamepadTestChannelChild> mManagedPGamepadTestChannelChild;
    ManagedContainer<PHttpBackgroundChannelChild> mManagedPHttpBackgroundChannelChild;
    ManagedContainer<PIdleSchedulerChild> mManagedPIdleSchedulerChild;
    ManagedContainer<PLockManagerChild> mManagedPLockManagerChild;
    ManagedContainer<PRemoteWorkerControllerChild> mManagedPRemoteWorkerControllerChild;
    ManagedContainer<PSharedWorkerChild> mManagedPSharedWorkerChild;
    ManagedContainer<PTemporaryIPCBlobChild> mManagedPTemporaryIPCBlobChild;
    ManagedContainer<PFileCreatorChild> mManagedPFileCreatorChild;
    ManagedContainer<PMessagePortChild> mManagedPMessagePortChild;
    ManagedContainer<PCamerasChild> mManagedPCamerasChild;
    ManagedContainer<PQuotaChild> mManagedPQuotaChild;
    ManagedContainer<PServiceWorkerChild> mManagedPServiceWorkerChild;
    ManagedContainer<PServiceWorkerContainerChild> mManagedPServiceWorkerContainerChild;
    ManagedContainer<PServiceWorkerManagerChild> mManagedPServiceWorkerManagerChild;
    ManagedContainer<PServiceWorkerRegistrationChild> mManagedPServiceWorkerRegistrationChild;
    ManagedContainer<PUDPSocketChild> mManagedPUDPSocketChild;
    ManagedContainer<PVsyncChild> mManagedPVsyncChild;
    ManagedContainer<PFetchChild> mManagedPFetchChild;
};


} // namespace ipc
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::ipc::PBackgroundChild*>
{
    typedef ::mozilla::ipc::PBackgroundChild* paramType;
    static void
    Write(
            IPC::MessageWriter* aWriter,
            const paramType& aVar);
    static IPC::ReadResult<paramType>
    Read(IPC::MessageReader* aReader);
};
} // namespace IPC

#endif // ifndef PBackgroundChild_h
