Copy as Markdown
Other Tools
//
// 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/dom/BindingIPCUtils.h"
#include "mozilla/dom/CSPMessageUtils.h"
#include "mozilla/dom/ClientIPCUtils.h"
#include "mozilla/dom/DocShellMessageUtils.h"
#include "mozilla/dom/PBackgroundSessionStorageCache.h"
#include "mozilla/dom/PermissionMessageUtils.h"
#include "mozilla/dom/PropertyBagUtils.h"
#include "mozilla/dom/ReferrerInfoUtils.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/localstorage/SerializationHelpers.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/SerializedStructuredCloneBuffer.h"
#include "mozilla/ipc/URIUtils.h"
#include "mozilla/layers/LayersMessageUtils.h"
#include "mozilla/net/ClassOfService.h"
#include "nsIContentSecurityPolicy.h"
#include "nsID.h"
#include "nsIPrincipal.h"
#include "nsIReferrerInfo.h"
#include "nsIURI.h"
#include "nsIVariant.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/PBackgroundLSDatabaseParent.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/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/PEndpointForReportParent.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/PRemoteWorkerParent.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/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/dom/PWebAuthnTransactionParent.h"
#include "mozilla/net/PUDPSocketParent.h"
#include "mozilla/dom/PVsyncParent.h"
#include "mozilla/PRemoteDecoderManagerParent.h"
#include "mozilla/dom/PWebTransportParent.h"
#include "mozilla/dom/PFetchParent.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::RecvPBackgroundLSDatabaseConstructor(
PBackgroundLSDatabaseParent* actor,
const PrincipalInfo& principalInfo,
const uint32_t& privateBrowsingId,
const uint64_t& datastoreId) -> 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::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::RecvPWebAuthnTransactionConstructor(PWebAuthnTransactionParent* actor) -> 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::RecvPRemoteWorkerServiceConstructor(PRemoteWorkerServiceParent* actor) -> mozilla::ipc::IPCResult
{
return IPC_OK();
}
auto PBackgroundParent::RecvPServiceWorkerContainerConstructor(PServiceWorkerContainerParent* actor) -> mozilla::ipc::IPCResult
{
return IPC_OK();
}
auto PBackgroundParent::RecvPServiceWorkerRegistrationConstructor(
PServiceWorkerRegistrationParent* actor,
const IPCServiceWorkerRegistrationDescriptor& aDescriptor) -> mozilla::ipc::IPCResult
{
return IPC_OK();
}
auto PBackgroundParent::RecvPEndpointForReportConstructor(
PEndpointForReportParent* actor,
const nsAString& aGroupName,
const PrincipalInfo& aPrincipalInfo) -> 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 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", PBackgroundMsgStart, 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::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::ManagedPBackgroundLSDatabaseParent(nsTArray<PBackgroundLSDatabaseParent*>& aArr) const -> void
{
mManagedPBackgroundLSDatabaseParent.ToArray(aArr);
}
auto PBackgroundParent::ManagedPBackgroundLSDatabaseParent() const -> const ManagedContainer<PBackgroundLSDatabaseParent>&
{
return mManagedPBackgroundLSDatabaseParent;
}
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::ManagedPEndpointForReportParent(nsTArray<PEndpointForReportParent*>& aArr) const -> void
{
mManagedPEndpointForReportParent.ToArray(aArr);
}
auto PBackgroundParent::ManagedPEndpointForReportParent() const -> const ManagedContainer<PEndpointForReportParent>&
{
return mManagedPEndpointForReportParent;
}
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::ManagedPRemoteWorkerParent(nsTArray<PRemoteWorkerParent*>& aArr) const -> void
{
mManagedPRemoteWorkerParent.ToArray(aArr);
}
auto PBackgroundParent::ManagedPRemoteWorkerParent() const -> const ManagedContainer<PRemoteWorkerParent>&
{
return mManagedPRemoteWorkerParent;
}
auto PBackgroundParent::ManagedPRemoteWorkerControllerParent(nsTArray<PRemoteWorkerControllerParent*>& aArr) const -> void
{
mManagedPRemoteWorkerControllerParent.ToArray(aArr);
}
auto PBackgroundParent::ManagedPRemoteWorkerControllerParent() const -> const ManagedContainer<PRemoteWorkerControllerParent>&
{
return mManagedPRemoteWorkerControllerParent;
}
auto PBackgroundParent::ManagedPRemoteWorkerServiceParent(nsTArray<PRemoteWorkerServiceParent*>& aArr) const -> void
{
mManagedPRemoteWorkerServiceParent.ToArray(aArr);
}
auto PBackgroundParent::ManagedPRemoteWorkerServiceParent() const -> const ManagedContainer<PRemoteWorkerServiceParent>&
{
return mManagedPRemoteWorkerServiceParent;
}
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::ManagedPWebAuthnTransactionParent(nsTArray<PWebAuthnTransactionParent*>& aArr) const -> void
{
mManagedPWebAuthnTransactionParent.ToArray(aArr);
}
auto PBackgroundParent::ManagedPWebAuthnTransactionParent() const -> const ManagedContainer<PWebAuthnTransactionParent>&
{
return mManagedPWebAuthnTransactionParent;
}
auto PBackgroundParent::ManagedPUDPSocketParent(nsTArray<PUDPSocketParent*>& aArr) const -> void
{
mManagedPUDPSocketParent.ToArray(aArr);
}
auto PBackgroundParent::ManagedPUDPSocketParent() const -> const ManagedContainer<PUDPSocketParent>&
{
return mManagedPUDPSocketParent;
}
auto PBackgroundParent::ManagedPVsyncParent(nsTArray<PVsyncParent*>& aArr) const -> void
{
mManagedPVsyncParent.ToArray(aArr);
}
auto PBackgroundParent::ManagedPVsyncParent() const -> const ManagedContainer<PVsyncParent>&
{
return mManagedPVsyncParent;
}
auto PBackgroundParent::ManagedPFetchParent(nsTArray<PFetchParent*>& aArr) const -> void
{
mManagedPFetchParent.ToArray(aArr);
}
auto PBackgroundParent::ManagedPFetchParent() const -> const ManagedContainer<PFetchParent>&
{
return mManagedPFetchParent;
}
auto PBackgroundParent::AllManagedActorsCount() const -> uint32_t
{
uint32_t total = 0;
total += mManagedPBackgroundIDBFactoryParent.Count();
total += mManagedPBackgroundIndexedDBUtilsParent.Count();
total += mManagedPBackgroundSDBConnectionParent.Count();
total += mManagedPBackgroundLSDatabaseParent.Count();
total += mManagedPBackgroundLSObserverParent.Count();
total += mManagedPBackgroundLSRequestParent.Count();
total += mManagedPBackgroundLSSimpleRequestParent.Count();
total += mManagedPBackgroundLocalStorageCacheParent.Count();
total += mManagedPBackgroundSessionStorageManagerParent.Count();
total += mManagedPBackgroundSessionStorageServiceParent.Count();
total += mManagedPBackgroundStorageParent.Count();
total += mManagedPBackgroundTestParent.Count();
total += mManagedPBroadcastChannelParent.Count();
total += mManagedPCacheParent.Count();
total += mManagedPCacheStorageParent.Count();
total += mManagedPCacheStreamControlParent.Count();
total += mManagedPClientManagerParent.Count();
total += mManagedPEndpointForReportParent.Count();
total += mManagedPFileSystemRequestParent.Count();
total += mManagedPGamepadEventChannelParent.Count();
total += mManagedPGamepadTestChannelParent.Count();
total += mManagedPHttpBackgroundChannelParent.Count();
total += mManagedPIdleSchedulerParent.Count();
total += mManagedPLockManagerParent.Count();
total += mManagedPRemoteWorkerParent.Count();
total += mManagedPRemoteWorkerControllerParent.Count();
total += mManagedPRemoteWorkerServiceParent.Count();
total += mManagedPSharedWorkerParent.Count();
total += mManagedPTemporaryIPCBlobParent.Count();
total += mManagedPFileCreatorParent.Count();
total += mManagedPMessagePortParent.Count();
total += mManagedPCamerasParent.Count();
total += mManagedPQuotaParent.Count();
total += mManagedPServiceWorkerParent.Count();
total += mManagedPServiceWorkerContainerParent.Count();
total += mManagedPServiceWorkerManagerParent.Count();
total += mManagedPServiceWorkerRegistrationParent.Count();
total += mManagedPWebAuthnTransactionParent.Count();
total += mManagedPUDPSocketParent.Count();
total += mManagedPVsyncParent.Count();
total += mManagedPFetchParent.Count();
return total;
}
auto PBackgroundParent::OpenPBackgroundIDBFactoryEndpoint(PBackgroundIDBFactoryParent* aActor) -> ManagedEndpoint<PBackgroundIDBFactoryChild>
{
if (!aActor) {
NS_WARNING("Cannot bind null PBackgroundIDBFactoryParent actor");
return ManagedEndpoint<PBackgroundIDBFactoryChild>();
}
if (aActor->SetManagerAndRegister(this)) {
mManagedPBackgroundIDBFactoryParent.Insert(aActor);
} else {
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, mManagedPBackgroundIDBFactoryParent);
}
auto PBackgroundParent::OpenPBackgroundIndexedDBUtilsEndpoint(PBackgroundIndexedDBUtilsParent* aActor) -> ManagedEndpoint<PBackgroundIndexedDBUtilsChild>
{
if (!aActor) {
NS_WARNING("Cannot bind null PBackgroundIndexedDBUtilsParent actor");
return ManagedEndpoint<PBackgroundIndexedDBUtilsChild>();
}
if (aActor->SetManagerAndRegister(this)) {
mManagedPBackgroundIndexedDBUtilsParent.Insert(aActor);
} else {
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, mManagedPBackgroundIndexedDBUtilsParent);
}
auto PBackgroundParent::OpenPBackgroundSDBConnectionEndpoint(PBackgroundSDBConnectionParent* aActor) -> ManagedEndpoint<PBackgroundSDBConnectionChild>
{
if (!aActor) {
NS_WARNING("Cannot bind null PBackgroundSDBConnectionParent actor");
return ManagedEndpoint<PBackgroundSDBConnectionChild>();
}
if (aActor->SetManagerAndRegister(this)) {
mManagedPBackgroundSDBConnectionParent.Insert(aActor);
} else {
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, mManagedPBackgroundSDBConnectionParent);
}
auto PBackgroundParent::OpenPBackgroundLSDatabaseEndpoint(PBackgroundLSDatabaseParent* aActor) -> ManagedEndpoint<PBackgroundLSDatabaseChild>
{
if (!aActor) {
NS_WARNING("Cannot bind null PBackgroundLSDatabaseParent actor");
return ManagedEndpoint<PBackgroundLSDatabaseChild>();
}
if (aActor->SetManagerAndRegister(this)) {
mManagedPBackgroundLSDatabaseParent.Insert(aActor);
} else {
NS_WARNING("Failed to bind PBackgroundLSDatabaseParent actor");
return ManagedEndpoint<PBackgroundLSDatabaseChild>();
}
// 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<PBackgroundLSDatabaseChild>(mozilla::ipc::PrivateIPDLInterface(), aActor);
}
auto PBackgroundParent::BindPBackgroundLSDatabaseEndpoint(
ManagedEndpoint<PBackgroundLSDatabaseParent> aEndpoint,
PBackgroundLSDatabaseParent* aActor) -> bool
{
return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this, mManagedPBackgroundLSDatabaseParent);
}
auto PBackgroundParent::OpenPBackgroundLSObserverEndpoint(PBackgroundLSObserverParent* aActor) -> ManagedEndpoint<PBackgroundLSObserverChild>
{
if (!aActor) {
NS_WARNING("Cannot bind null PBackgroundLSObserverParent actor");
return ManagedEndpoint<PBackgroundLSObserverChild>();
}
if (aActor->SetManagerAndRegister(this)) {
mManagedPBackgroundLSObserverParent.Insert(aActor);
} else {
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, mManagedPBackgroundLSObserverParent);
}
auto PBackgroundParent::OpenPBackgroundLSRequestEndpoint(PBackgroundLSRequestParent* aActor) -> ManagedEndpoint<PBackgroundLSRequestChild>
{
if (!aActor) {
NS_WARNING("Cannot bind null PBackgroundLSRequestParent actor");
return ManagedEndpoint<PBackgroundLSRequestChild>();
}
if (aActor->SetManagerAndRegister(this)) {
mManagedPBackgroundLSRequestParent.Insert(aActor);
} else {
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, mManagedPBackgroundLSRequestParent);
}
auto PBackgroundParent::OpenPBackgroundLSSimpleRequestEndpoint(PBackgroundLSSimpleRequestParent* aActor) -> ManagedEndpoint<PBackgroundLSSimpleRequestChild>
{
if (!aActor) {
NS_WARNING("Cannot bind null PBackgroundLSSimpleRequestParent actor");
return ManagedEndpoint<PBackgroundLSSimpleRequestChild>();
}
if (aActor->SetManagerAndRegister(this)) {
mManagedPBackgroundLSSimpleRequestParent.Insert(aActor);
} else {
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, mManagedPBackgroundLSSimpleRequestParent);
}
auto PBackgroundParent::OpenPBackgroundLocalStorageCacheEndpoint(PBackgroundLocalStorageCacheParent* aActor) -> ManagedEndpoint<PBackgroundLocalStorageCacheChild>
{
if (!aActor) {
NS_WARNING("Cannot bind null PBackgroundLocalStorageCacheParent actor");
return ManagedEndpoint<PBackgroundLocalStorageCacheChild>();
}
if (aActor->SetManagerAndRegister(this)) {
mManagedPBackgroundLocalStorageCacheParent.Insert(aActor);
} else {
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, mManagedPBackgroundLocalStorageCacheParent);
}
auto PBackgroundParent::OpenPBackgroundSessionStorageManagerEndpoint(PBackgroundSessionStorageManagerParent* aActor) -> ManagedEndpoint<PBackgroundSessionStorageManagerChild>
{
if (!aActor) {
NS_WARNING("Cannot bind null PBackgroundSessionStorageManagerParent actor");
return ManagedEndpoint<PBackgroundSessionStorageManagerChild>();
}
if (aActor->SetManagerAndRegister(this)) {
mManagedPBackgroundSessionStorageManagerParent.Insert(aActor);
} else {
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, mManagedPBackgroundSessionStorageManagerParent);
}
auto PBackgroundParent::OpenPBackgroundSessionStorageServiceEndpoint(PBackgroundSessionStorageServiceParent* aActor) -> ManagedEndpoint<PBackgroundSessionStorageServiceChild>
{
if (!aActor) {
NS_WARNING("Cannot bind null PBackgroundSessionStorageServiceParent actor");
return ManagedEndpoint<PBackgroundSessionStorageServiceChild>();
}
if (aActor->SetManagerAndRegister(this)) {
mManagedPBackgroundSessionStorageServiceParent.Insert(aActor);
} else {
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, mManagedPBackgroundSessionStorageServiceParent);
}
auto PBackgroundParent::OpenPBackgroundStorageEndpoint(PBackgroundStorageParent* aActor) -> ManagedEndpoint<PBackgroundStorageChild>
{
if (!aActor) {
NS_WARNING("Cannot bind null PBackgroundStorageParent actor");
return ManagedEndpoint<PBackgroundStorageChild>();
}
if (aActor->SetManagerAndRegister(this)) {
mManagedPBackgroundStorageParent.Insert(aActor);
} else {
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, mManagedPBackgroundStorageParent);
}
auto PBackgroundParent::OpenPBackgroundTestEndpoint(PBackgroundTestParent* aActor) -> ManagedEndpoint<PBackgroundTestChild>
{
if (!aActor) {
NS_WARNING("Cannot bind null PBackgroundTestParent actor");
return ManagedEndpoint<PBackgroundTestChild>();
}
if (aActor->SetManagerAndRegister(this)) {
mManagedPBackgroundTestParent.Insert(aActor);
} else {
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, mManagedPBackgroundTestParent);
}
auto PBackgroundParent::OpenPBroadcastChannelEndpoint(PBroadcastChannelParent* aActor) -> ManagedEndpoint<PBroadcastChannelChild>
{
if (!aActor) {
NS_WARNING("Cannot bind null PBroadcastChannelParent actor");
return ManagedEndpoint<PBroadcastChannelChild>();
}
if (aActor->SetManagerAndRegister(this)) {
mManagedPBroadcastChannelParent.Insert(aActor);
} else {
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, mManagedPBroadcastChannelParent);
}
auto PBackgroundParent::OpenPCacheEndpoint(PCacheParent* aActor) -> ManagedEndpoint<PCacheChild>
{
if (!aActor) {
NS_WARNING("Cannot bind null PCacheParent actor");
return ManagedEndpoint<PCacheChild>();
}
if (aActor->SetManagerAndRegister(this)) {
mManagedPCacheParent.Insert(aActor);
} else {
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, mManagedPCacheParent);
}
auto PBackgroundParent::OpenPCacheStorageEndpoint(PCacheStorageParent* aActor) -> ManagedEndpoint<PCacheStorageChild>
{
if (!aActor) {
NS_WARNING("Cannot bind null PCacheStorageParent actor");
return ManagedEndpoint<PCacheStorageChild>();
}
if (aActor->SetManagerAndRegister(this)) {
mManagedPCacheStorageParent.Insert(aActor);
} else {
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, mManagedPCacheStorageParent);
}
auto PBackgroundParent::OpenPCacheStreamControlEndpoint(PCacheStreamControlParent* aActor) -> ManagedEndpoint<PCacheStreamControlChild>
{
if (!aActor) {
NS_WARNING("Cannot bind null PCacheStreamControlParent actor");
return ManagedEndpoint<PCacheStreamControlChild>();
}
if (aActor->SetManagerAndRegister(this)) {
mManagedPCacheStreamControlParent.Insert(aActor);
} else {
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, mManagedPCacheStreamControlParent);
}
auto PBackgroundParent::OpenPClientManagerEndpoint(PClientManagerParent* aActor) -> ManagedEndpoint<PClientManagerChild>
{
if (!aActor) {
NS_WARNING("Cannot bind null PClientManagerParent actor");
return ManagedEndpoint<PClientManagerChild>();
}
if (aActor->SetManagerAndRegister(this)) {
mManagedPClientManagerParent.Insert(aActor);
} else {
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, mManagedPClientManagerParent);
}
auto PBackgroundParent::OpenPEndpointForReportEndpoint(PEndpointForReportParent* aActor) -> ManagedEndpoint<PEndpointForReportChild>
{
if (!aActor) {
NS_WARNING("Cannot bind null PEndpointForReportParent actor");
return ManagedEndpoint<PEndpointForReportChild>();
}
if (aActor->SetManagerAndRegister(this)) {
mManagedPEndpointForReportParent.Insert(aActor);
} else {
NS_WARNING("Failed to bind PEndpointForReportParent actor");
return ManagedEndpoint<PEndpointForReportChild>();
}
// 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<PEndpointForReportChild>(mozilla::ipc::PrivateIPDLInterface(), aActor);
}
auto PBackgroundParent::BindPEndpointForReportEndpoint(
ManagedEndpoint<PEndpointForReportParent> aEndpoint,
PEndpointForReportParent* aActor) -> bool
{
return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this, mManagedPEndpointForReportParent);
}
auto PBackgroundParent::OpenPFileSystemRequestEndpoint(PFileSystemRequestParent* aActor) -> ManagedEndpoint<PFileSystemRequestChild>
{
if (!aActor) {
NS_WARNING("Cannot bind null PFileSystemRequestParent actor");
return ManagedEndpoint<PFileSystemRequestChild>();
}
if (aActor->SetManagerAndRegister(this)) {
mManagedPFileSystemRequestParent.Insert(aActor);
} else {
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, mManagedPFileSystemRequestParent);
}
auto PBackgroundParent::OpenPGamepadEventChannelEndpoint(PGamepadEventChannelParent* aActor) -> ManagedEndpoint<PGamepadEventChannelChild>
{
if (!aActor) {
NS_WARNING("Cannot bind null PGamepadEventChannelParent actor");
return ManagedEndpoint<PGamepadEventChannelChild>();
}
if (aActor->SetManagerAndRegister(this)) {
mManagedPGamepadEventChannelParent.Insert(aActor);
} else {
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, mManagedPGamepadEventChannelParent);
}
auto PBackgroundParent::OpenPGamepadTestChannelEndpoint(PGamepadTestChannelParent* aActor) -> ManagedEndpoint<PGamepadTestChannelChild>
{
if (!aActor) {
NS_WARNING("Cannot bind null PGamepadTestChannelParent actor");
return ManagedEndpoint<PGamepadTestChannelChild>();
}
if (aActor->SetManagerAndRegister(this)) {
mManagedPGamepadTestChannelParent.Insert(aActor);
} else {
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, mManagedPGamepadTestChannelParent);
}
auto PBackgroundParent::OpenPHttpBackgroundChannelEndpoint(PHttpBackgroundChannelParent* aActor) -> ManagedEndpoint<PHttpBackgroundChannelChild>
{
if (!aActor) {
NS_WARNING("Cannot bind null PHttpBackgroundChannelParent actor");
return ManagedEndpoint<PHttpBackgroundChannelChild>();
}
if (aActor->SetManagerAndRegister(this)) {
mManagedPHttpBackgroundChannelParent.Insert(aActor);
} else {
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, mManagedPHttpBackgroundChannelParent);
}
auto PBackgroundParent::OpenPIdleSchedulerEndpoint(PIdleSchedulerParent* aActor) -> ManagedEndpoint<PIdleSchedulerChild>
{
if (!aActor) {
NS_WARNING("Cannot bind null PIdleSchedulerParent actor");
return ManagedEndpoint<PIdleSchedulerChild>();
}
if (aActor->SetManagerAndRegister(this)) {
mManagedPIdleSchedulerParent.Insert(aActor);
} else {
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, mManagedPIdleSchedulerParent);
}
auto PBackgroundParent::OpenPLockManagerEndpoint(PLockManagerParent* aActor) -> ManagedEndpoint<PLockManagerChild>
{
if (!aActor) {
NS_WARNING("Cannot bind null PLockManagerParent actor");
return ManagedEndpoint<PLockManagerChild>();
}
if (aActor->SetManagerAndRegister(this)) {
mManagedPLockManagerParent.Insert(aActor);
} else {
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, mManagedPLockManagerParent);
}
auto PBackgroundParent::OpenPRemoteWorkerEndpoint(PRemoteWorkerParent* aActor) -> ManagedEndpoint<PRemoteWorkerChild>
{
if (!aActor) {
NS_WARNING("Cannot bind null PRemoteWorkerParent actor");
return ManagedEndpoint<PRemoteWorkerChild>();
}
if (aActor->SetManagerAndRegister(this)) {
mManagedPRemoteWorkerParent.Insert(aActor);
} else {
NS_WARNING("Failed to bind PRemoteWorkerParent actor");
return ManagedEndpoint<PRemoteWorkerChild>();
}
// 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<PRemoteWorkerChild>(mozilla::ipc::PrivateIPDLInterface(), aActor);
}
auto PBackgroundParent::BindPRemoteWorkerEndpoint(
ManagedEndpoint<PRemoteWorkerParent> aEndpoint,
PRemoteWorkerParent* aActor) -> bool
{
return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this, mManagedPRemoteWorkerParent);
}
auto PBackgroundParent::OpenPRemoteWorkerControllerEndpoint(PRemoteWorkerControllerParent* aActor) -> ManagedEndpoint<PRemoteWorkerControllerChild>
{
if (!aActor) {
NS_WARNING("Cannot bind null PRemoteWorkerControllerParent actor");
return ManagedEndpoint<PRemoteWorkerControllerChild>();
}
if (aActor->SetManagerAndRegister(this)) {
mManagedPRemoteWorkerControllerParent.Insert(aActor);
} else {
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, mManagedPRemoteWorkerControllerParent);
}
auto PBackgroundParent::OpenPRemoteWorkerServiceEndpoint(PRemoteWorkerServiceParent* aActor) -> ManagedEndpoint<PRemoteWorkerServiceChild>
{
if (!aActor) {
NS_WARNING("Cannot bind null PRemoteWorkerServiceParent actor");
return ManagedEndpoint<PRemoteWorkerServiceChild>();
}
if (aActor->SetManagerAndRegister(this)) {
mManagedPRemoteWorkerServiceParent.Insert(aActor);
} else {
NS_WARNING("Failed to bind PRemoteWorkerServiceParent actor");
return ManagedEndpoint<PRemoteWorkerServiceChild>();
}
// 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<PRemoteWorkerServiceChild>(mozilla::ipc::PrivateIPDLInterface(), aActor);
}
auto PBackgroundParent::BindPRemoteWorkerServiceEndpoint(
ManagedEndpoint<PRemoteWorkerServiceParent> aEndpoint,
PRemoteWorkerServiceParent* aActor) -> bool
{
return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this, mManagedPRemoteWorkerServiceParent);
}
auto PBackgroundParent::OpenPSharedWorkerEndpoint(PSharedWorkerParent* aActor) -> ManagedEndpoint<PSharedWorkerChild>
{
if (!aActor) {
NS_WARNING("Cannot bind null PSharedWorkerParent actor");
return ManagedEndpoint<PSharedWorkerChild>();
}
if (aActor->SetManagerAndRegister(this)) {
mManagedPSharedWorkerParent.Insert(aActor);
} else {
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, mManagedPSharedWorkerParent);
}
auto PBackgroundParent::OpenPTemporaryIPCBlobEndpoint(PTemporaryIPCBlobParent* aActor) -> ManagedEndpoint<PTemporaryIPCBlobChild>
{
if (!aActor) {
NS_WARNING("Cannot bind null PTemporaryIPCBlobParent actor");
return ManagedEndpoint<PTemporaryIPCBlobChild>();
}
if (aActor->SetManagerAndRegister(this)) {
mManagedPTemporaryIPCBlobParent.Insert(aActor);
} else {
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, mManagedPTemporaryIPCBlobParent);
}
auto PBackgroundParent::OpenPFileCreatorEndpoint(PFileCreatorParent* aActor) -> ManagedEndpoint<PFileCreatorChild>
{
if (!aActor) {
NS_WARNING("Cannot bind null PFileCreatorParent actor");
return ManagedEndpoint<PFileCreatorChild>();
}
if (aActor->SetManagerAndRegister(this)) {
mManagedPFileCreatorParent.Insert(aActor);
} else {
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, mManagedPFileCreatorParent);
}
auto PBackgroundParent::OpenPMessagePortEndpoint(PMessagePortParent* aActor) -> ManagedEndpoint<PMessagePortChild>
{
if (!aActor) {
NS_WARNING("Cannot bind null PMessagePortParent actor");
return ManagedEndpoint<PMessagePortChild>();
}
if (aActor->SetManagerAndRegister(this)) {
mManagedPMessagePortParent.Insert(aActor);
} else {
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, mManagedPMessagePortParent);
}
auto PBackgroundParent::OpenPCamerasEndpoint(PCamerasParent* aActor) -> ManagedEndpoint<PCamerasChild>
{
if (!aActor) {
NS_WARNING("Cannot bind null PCamerasParent actor");
return ManagedEndpoint<PCamerasChild>();
}
if (aActor->SetManagerAndRegister(this)) {
mManagedPCamerasParent.Insert(aActor);
} else {
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, mManagedPCamerasParent);
}
auto PBackgroundParent::OpenPQuotaEndpoint(PQuotaParent* aActor) -> ManagedEndpoint<PQuotaChild>
{
if (!aActor) {
NS_WARNING("Cannot bind null PQuotaParent actor");
return ManagedEndpoint<PQuotaChild>();
}
if (aActor->SetManagerAndRegister(this)) {
mManagedPQuotaParent.Insert(aActor);
} else {
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, mManagedPQuotaParent);
}
auto PBackgroundParent::OpenPServiceWorkerEndpoint(PServiceWorkerParent* aActor) -> ManagedEndpoint<PServiceWorkerChild>
{
if (!aActor) {
NS_WARNING("Cannot bind null PServiceWorkerParent actor");
return ManagedEndpoint<PServiceWorkerChild>();
}
if (aActor->SetManagerAndRegister(this)) {
mManagedPServiceWorkerParent.Insert(aActor);
} else {
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, mManagedPServiceWorkerParent);
}
auto PBackgroundParent::OpenPServiceWorkerContainerEndpoint(PServiceWorkerContainerParent* aActor) -> ManagedEndpoint<PServiceWorkerContainerChild>
{
if (!aActor) {
NS_WARNING("Cannot bind null PServiceWorkerContainerParent actor");
return ManagedEndpoint<PServiceWorkerContainerChild>();
}
if (aActor->SetManagerAndRegister(this)) {
mManagedPServiceWorkerContainerParent.Insert(aActor);
} else {
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, mManagedPServiceWorkerContainerParent);
}
auto PBackgroundParent::OpenPServiceWorkerManagerEndpoint(PServiceWorkerManagerParent* aActor) -> ManagedEndpoint<PServiceWorkerManagerChild>
{
if (!aActor) {
NS_WARNING("Cannot bind null PServiceWorkerManagerParent actor");
return ManagedEndpoint<PServiceWorkerManagerChild>();
}
if (aActor->SetManagerAndRegister(this)) {
mManagedPServiceWorkerManagerParent.Insert(aActor);
} else {
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, mManagedPServiceWorkerManagerParent);
}
auto PBackgroundParent::OpenPServiceWorkerRegistrationEndpoint(PServiceWorkerRegistrationParent* aActor) -> ManagedEndpoint<PServiceWorkerRegistrationChild>
{
if (!aActor) {
NS_WARNING("Cannot bind null PServiceWorkerRegistrationParent actor");
return ManagedEndpoint<PServiceWorkerRegistrationChild>();
}
if (aActor->SetManagerAndRegister(this)) {
mManagedPServiceWorkerRegistrationParent.Insert(aActor);
} else {
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, mManagedPServiceWorkerRegistrationParent);
}
auto PBackgroundParent::OpenPWebAuthnTransactionEndpoint(PWebAuthnTransactionParent* aActor) -> ManagedEndpoint<PWebAuthnTransactionChild>
{
if (!aActor) {
NS_WARNING("Cannot bind null PWebAuthnTransactionParent actor");
return ManagedEndpoint<PWebAuthnTransactionChild>();
}
if (aActor->SetManagerAndRegister(this)) {
mManagedPWebAuthnTransactionParent.Insert(aActor);
} else {
NS_WARNING("Failed to bind PWebAuthnTransactionParent actor");
return ManagedEndpoint<PWebAuthnTransactionChild>();
}
// 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<PWebAuthnTransactionChild>(mozilla::ipc::PrivateIPDLInterface(), aActor);
}
auto PBackgroundParent::BindPWebAuthnTransactionEndpoint(
ManagedEndpoint<PWebAuthnTransactionParent> aEndpoint,
PWebAuthnTransactionParent* aActor) -> bool
{
return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this, mManagedPWebAuthnTransactionParent);
}
auto PBackgroundParent::OpenPUDPSocketEndpoint(PUDPSocketParent* aActor) -> ManagedEndpoint<PUDPSocketChild>
{
if (!aActor) {
NS_WARNING("Cannot bind null PUDPSocketParent actor");
return ManagedEndpoint<PUDPSocketChild>();
}
if (aActor->SetManagerAndRegister(this)) {
mManagedPUDPSocketParent.Insert(aActor);
} else {
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, mManagedPUDPSocketParent);
}
auto PBackgroundParent::OpenPVsyncEndpoint(PVsyncParent* aActor) -> ManagedEndpoint<PVsyncChild>
{
if (!aActor) {
NS_WARNING("Cannot bind null PVsyncParent actor");
return ManagedEndpoint<PVsyncChild>();
}
if (aActor->SetManagerAndRegister(this)) {
mManagedPVsyncParent.Insert(aActor);
} else {
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, mManagedPVsyncParent);
}
auto PBackgroundParent::OpenPFetchEndpoint(PFetchParent* aActor) -> ManagedEndpoint<PFetchChild>
{
if (!aActor) {
NS_WARNING("Cannot bind null PFetchParent actor");
return ManagedEndpoint<PFetchChild>();
}
if (aActor->SetManagerAndRegister(this)) {
mManagedPFetchParent.Insert(aActor);
} else {
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, mManagedPFetchParent);
}
auto PBackgroundParent::SendPCacheConstructor(PCacheParent* actor) -> PCacheParent*
{
if (!actor) {
NS_WARNING("Cannot bind null PCacheParent actor");
return nullptr;
}
if (actor->SetManagerAndRegister(this)) {
mManagedPCacheParent.Insert(actor);
} else {
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);
// Sentinel = 'actor'
((&(writer__)))->WriteSentinel(102892058);
// 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)) {
mManagedPCacheStreamControlParent.Insert(actor);
} else {
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);
// Sentinel = 'actor'
((&(writer__)))->WriteSentinel(102892058);
// 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::SendPRemoteWorkerConstructor(
PRemoteWorkerParent* actor,
const RemoteWorkerData& data) -> PRemoteWorkerParent*
{
if (!actor) {
NS_WARNING("Cannot bind null PRemoteWorkerParent actor");
return nullptr;
}
if (actor->SetManagerAndRegister(this)) {
mManagedPRemoteWorkerParent.Insert(actor);
} else {
NS_WARNING("Failed to bind PRemoteWorkerParent actor");
return nullptr;
}
// Build our constructor message.
UniquePtr<IPC::Message> msg__ = PBackground::Msg_PRemoteWorkerConstructor(MSG_ROUTING_CONTROL);
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), actor);
// Sentinel = 'actor'
((&(writer__)))->WriteSentinel(102892058);
IPC::WriteParam((&(writer__)), data);
// Sentinel = 'data'
((&(writer__)))->WriteSentinel(67109275);
// 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_PRemoteWorkerConstructor", 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 PRemoteWorkerParent constructor");
actor->ActorDisconnected(FailedConstructor);
return nullptr;
}
return actor;
}
auto PBackgroundParent::RemoveManagee(
int32_t aProtocolId,
IProtocol* aListener) -> void
{
switch (aProtocolId) {
case PBackgroundIDBFactoryMsgStart:
MOZ_ALWAYS_TRUE(mManagedPBackgroundIDBFactoryParent.EnsureRemoved(static_cast<PBackgroundIDBFactoryParent*>(aListener)));
return;
case PBackgroundIndexedDBUtilsMsgStart:
MOZ_ALWAYS_TRUE(mManagedPBackgroundIndexedDBUtilsParent.EnsureRemoved(static_cast<PBackgroundIndexedDBUtilsParent*>(aListener)));
return;
case PBackgroundSDBConnectionMsgStart:
MOZ_ALWAYS_TRUE(mManagedPBackgroundSDBConnectionParent.EnsureRemoved(static_cast<PBackgroundSDBConnectionParent*>(aListener)));
return;
case PBackgroundLSDatabaseMsgStart:
MOZ_ALWAYS_TRUE(mManagedPBackgroundLSDatabaseParent.EnsureRemoved(static_cast<PBackgroundLSDatabaseParent*>(aListener)));
return;
case PBackgroundLSObserverMsgStart:
MOZ_ALWAYS_TRUE(mManagedPBackgroundLSObserverParent.EnsureRemoved(static_cast<PBackgroundLSObserverParent*>(aListener)));
return;
case PBackgroundLSRequestMsgStart:
MOZ_ALWAYS_TRUE(mManagedPBackgroundLSRequestParent.EnsureRemoved(static_cast<PBackgroundLSRequestParent*>(aListener)));
return;
case PBackgroundLSSimpleRequestMsgStart:
MOZ_ALWAYS_TRUE(mManagedPBackgroundLSSimpleRequestParent.EnsureRemoved(static_cast<PBackgroundLSSimpleRequestParent*>(aListener)));
return;
case PBackgroundLocalStorageCacheMsgStart:
MOZ_ALWAYS_TRUE(mManagedPBackgroundLocalStorageCacheParent.EnsureRemoved(static_cast<PBackgroundLocalStorageCacheParent*>(aListener)));
return;
case PBackgroundSessionStorageManagerMsgStart:
MOZ_ALWAYS_TRUE(mManagedPBackgroundSessionStorageManagerParent.EnsureRemoved(static_cast<PBackgroundSessionStorageManagerParent*>(aListener)));
return;
case PBackgroundSessionStorageServiceMsgStart:
MOZ_ALWAYS_TRUE(mManagedPBackgroundSessionStorageServiceParent.EnsureRemoved(static_cast<PBackgroundSessionStorageServiceParent*>(aListener)));
return;
case PBackgroundStorageMsgStart:
MOZ_ALWAYS_TRUE(mManagedPBackgroundStorageParent.EnsureRemoved(static_cast<PBackgroundStorageParent*>(aListener)));
return;
case PBackgroundTestMsgStart:
MOZ_ALWAYS_TRUE(mManagedPBackgroundTestParent.EnsureRemoved(static_cast<PBackgroundTestParent*>(aListener)));
return;
case PBroadcastChannelMsgStart:
MOZ_ALWAYS_TRUE(mManagedPBroadcastChannelParent.EnsureRemoved(static_cast<PBroadcastChannelParent*>(aListener)));
return;
case PCacheMsgStart:
MOZ_ALWAYS_TRUE(mManagedPCacheParent.EnsureRemoved(static_cast<PCacheParent*>(aListener)));
return;
case PCacheStorageMsgStart:
MOZ_ALWAYS_TRUE(mManagedPCacheStorageParent.EnsureRemoved(static_cast<PCacheStorageParent*>(aListener)));
return;
case PCacheStreamControlMsgStart:
MOZ_ALWAYS_TRUE(mManagedPCacheStreamControlParent.EnsureRemoved(static_cast<PCacheStreamControlParent*>(aListener)));
return;
case PClientManagerMsgStart:
MOZ_ALWAYS_TRUE(mManagedPClientManagerParent.EnsureRemoved(static_cast<PClientManagerParent*>(aListener)));
return;
case PEndpointForReportMsgStart:
MOZ_ALWAYS_TRUE(mManagedPEndpointForReportParent.EnsureRemoved(static_cast<PEndpointForReportParent*>(aListener)));
return;
case PFileSystemRequestMsgStart:
MOZ_ALWAYS_TRUE(mManagedPFileSystemRequestParent.EnsureRemoved(static_cast<PFileSystemRequestParent*>(aListener)));
return;
case PGamepadEventChannelMsgStart:
MOZ_ALWAYS_TRUE(mManagedPGamepadEventChannelParent.EnsureRemoved(static_cast<PGamepadEventChannelParent*>(aListener)));
return;
case PGamepadTestChannelMsgStart:
MOZ_ALWAYS_TRUE(mManagedPGamepadTestChannelParent.EnsureRemoved(static_cast<PGamepadTestChannelParent*>(aListener)));
return;
case PHttpBackgroundChannelMsgStart:
MOZ_ALWAYS_TRUE(mManagedPHttpBackgroundChannelParent.EnsureRemoved(static_cast<PHttpBackgroundChannelParent*>(aListener)));
return;
case PIdleSchedulerMsgStart:
MOZ_ALWAYS_TRUE(mManagedPIdleSchedulerParent.EnsureRemoved(static_cast<PIdleSchedulerParent*>(aListener)));
return;
case PLockManagerMsgStart:
MOZ_ALWAYS_TRUE(mManagedPLockManagerParent.EnsureRemoved(static_cast<PLockManagerParent*>(aListener)));
return;
case PRemoteWorkerMsgStart:
MOZ_ALWAYS_TRUE(mManagedPRemoteWorkerParent.EnsureRemoved(static_cast<PRemoteWorkerParent*>(aListener)));
return;
case PRemoteWorkerControllerMsgStart:
MOZ_ALWAYS_TRUE(mManagedPRemoteWorkerControllerParent.EnsureRemoved(static_cast<PRemoteWorkerControllerParent*>(aListener)));
return;
case PRemoteWorkerServiceMsgStart:
MOZ_ALWAYS_TRUE(mManagedPRemoteWorkerServiceParent.EnsureRemoved(static_cast<PRemoteWorkerServiceParent*>(aListener)));
return;
case PSharedWorkerMsgStart:
MOZ_ALWAYS_TRUE(mManagedPSharedWorkerParent.EnsureRemoved(static_cast<PSharedWorkerParent*>(aListener)));
return;
case PTemporaryIPCBlobMsgStart:
MOZ_ALWAYS_TRUE(mManagedPTemporaryIPCBlobParent.EnsureRemoved(static_cast<PTemporaryIPCBlobParent*>(aListener)));
return;
case PFileCreatorMsgStart:
MOZ_ALWAYS_TRUE(mManagedPFileCreatorParent.EnsureRemoved(static_cast<PFileCreatorParent*>(aListener)));
return;
case PMessagePortMsgStart:
MOZ_ALWAYS_TRUE(mManagedPMessagePortParent.EnsureRemoved(static_cast<PMessagePortParent*>(aListener)));
return;
case PCamerasMsgStart:
MOZ_ALWAYS_TRUE(mManagedPCamerasParent.EnsureRemoved(static_cast<PCamerasParent*>(aListener)));
return;
case PQuotaMsgStart:
MOZ_ALWAYS_TRUE(mManagedPQuotaParent.EnsureRemoved(static_cast<PQuotaParent*>(aListener)));
return;
case PServiceWorkerMsgStart:
MOZ_ALWAYS_TRUE(mManagedPServiceWorkerParent.EnsureRemoved(static_cast<PServiceWorkerParent*>(aListener)));
return;
case PServiceWorkerContainerMsgStart:
MOZ_ALWAYS_TRUE(mManagedPServiceWorkerContainerParent.EnsureRemoved(static_cast<PServiceWorkerContainerParent*>(aListener)));
return;
case PServiceWorkerManagerMsgStart:
MOZ_ALWAYS_TRUE(mManagedPServiceWorkerManagerParent.EnsureRemoved(static_cast<PServiceWorkerManagerParent*>(aListener)));
return;
case PServiceWorkerRegistrationMsgStart:
MOZ_ALWAYS_TRUE(mManagedPServiceWorkerRegistrationParent.EnsureRemoved(static_cast<PServiceWorkerRegistrationParent*>(aListener)));
return;
case PWebAuthnTransactionMsgStart:
MOZ_ALWAYS_TRUE(mManagedPWebAuthnTransactionParent.EnsureRemoved(static_cast<PWebAuthnTransactionParent*>(aListener)));
return;
case PUDPSocketMsgStart:
MOZ_ALWAYS_TRUE(mManagedPUDPSocketParent.EnsureRemoved(static_cast<PUDPSocketParent*>(aListener)));
return;
case PVsyncMsgStart:
MOZ_ALWAYS_TRUE(mManagedPVsyncParent.EnsureRemoved(static_cast<PVsyncParent*>(aListener)));
return;
case PFetchMsgStart:
MOZ_ALWAYS_TRUE(mManagedPFetchParent.EnsureRemoved(static_cast<PFetchParent*>(aListener)));
return;
default:
FatalError("unreached");
return; }
}
auto PBackgroundParent::DeallocManagee(
int32_t 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 PEndpointForReportMsgStart:
this->DeallocPEndpointForReportParent(static_cast<PEndpointForReportParent*>(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 PMessagePortMsgStart:
this->DeallocPMessagePortParent(static_cast<PMessagePortParent*>(aListener));
return;
case PCamerasMsgStart:
this->DeallocPCamerasParent(static_cast<PCamerasParent*>(aListener));
return;
case PServiceWorkerManagerMsgStart:
this->DeallocPServiceWorkerManagerParent(static_cast<PServiceWorkerManagerParent*>(aListener));
return;
case PWebAuthnTransactionMsgStart:
this->DeallocPWebAuthnTransactionParent(static_cast<PWebAuthnTransactionParent*>(aListener));
return;
case PUDPSocketMsgStart:
this->DeallocPUDPSocketParent(static_cast<PUDPSocketParent*>(aListener));
return;
default:
FatalError("unreached");
return;
}
}
auto PBackgroundParent::OnMessageReceived(const Message& msg__) -> PBackgroundParent::Result
{
int32_t route__ = msg__.routing_id();
if (MSG_ROUTING_CONTROL != route__) {
IProtocol* routed__ = Lookup(route__);
if (!routed__ || !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__handle__ = IPC::ReadParam<ActorHandle>((&(reader__)));
if (!maybe__handle__) {
FatalError("Error deserializing 'ActorHandle'");
return MsgValueError;
}
auto& handle__ = *maybe__handle__;
// Sentinel = 'actor'
if ((!(((&(reader__)))->ReadSentinel(102892058)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ActorHandle'");
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();
PBackgroundTestParent* actor = (this)->AllocPBackgroundTestParent(testArg);
if (!actor) {
NS_WARNING("Cannot bind null PBackgroundTestParent actor");
return MsgValueError;
}
if (actor->SetManagerAndRegister(this, (handle__).mId)) {
mManagedPBackgroundTestParent.Insert(actor);
} else {
NS_WARNING("Failed to bind PBackgroundTestParent actor");
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__handle__ = IPC::ReadParam<ActorHandle>((&(reader__)));
if (!maybe__handle__) {
FatalError("Error deserializing 'ActorHandle'");
return MsgValueError;
}
auto& handle__ = *maybe__handle__;
// Sentinel = 'actor'
if ((!(((&(reader__)))->ReadSentinel(102892058)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ActorHandle'");
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();
RefPtr<PBackgroundIDBFactoryParent> actor = (this)->AllocPBackgroundIDBFactoryParent(loggingInfo, systemLocale);
if (!actor) {
NS_WARNING("Cannot bind null PBackgroundIDBFactoryParent actor");
return MsgValueError;
}
if (actor->SetManagerAndRegister(this, (handle__).mId)) {
mManagedPBackgroundIDBFactoryParent.Insert(actor);
} else {
NS_WARNING("Failed to bind PBackgroundIDBFactoryParent actor");
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__handle__ = IPC::ReadParam<ActorHandle>((&(reader__)));
if (!maybe__handle__) {
FatalError("Error deserializing 'ActorHandle'");
return MsgValueError;
}
auto& handle__ = *maybe__handle__;
// Sentinel = 'actor'
if ((!(((&(reader__)))->ReadSentinel(102892058)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ActorHandle'");
return MsgValueError;
}
reader__.EndRead();
PBackgroundIndexedDBUtilsParent* actor = (this)->AllocPBackgroundIndexedDBUtilsParent();
if (!actor) {
NS_WARNING("Cannot bind null PBackgroundIndexedDBUtilsParent actor");
return MsgValueError;
}
if (actor->SetManagerAndRegister(this, (handle__).mId)) {
mManagedPBackgroundIndexedDBUtilsParent.Insert(actor);
} else {
NS_WARNING("Failed to bind PBackgroundIndexedDBUtilsParent actor");
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__handle__ = IPC::ReadParam<ActorHandle>((&(reader__)));
if (!maybe__handle__) {
FatalError("Error deserializing 'ActorHandle'");
return MsgValueError;
}
auto& handle__ = *maybe__handle__;
// Sentinel = 'actor'
if ((!(((&(reader__)))->ReadSentinel(102892058)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ActorHandle'");
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();
RefPtr<PBackgroundSDBConnectionParent> actor = (this)->AllocPBackgroundSDBConnectionParent(persistenceType, principalInfo);
if (!actor) {
NS_WARNING("Cannot bind null PBackgroundSDBConnectionParent actor");
return MsgValueError;
}
if (actor->SetManagerAndRegister(this, (handle__).mId)) {
mManagedPBackgroundSDBConnectionParent.Insert(actor);
} else {
NS_WARNING("Failed to bind PBackgroundSDBConnectionParent actor");
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_PBackgroundLSDatabaseConstructor__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_PBackgroundLSDatabaseConstructor", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__handle__ = IPC::ReadParam<ActorHandle>((&(reader__)));
if (!maybe__handle__) {
FatalError("Error deserializing 'ActorHandle'");
return MsgValueError;
}
auto& handle__ = *maybe__handle__;
// Sentinel = 'actor'
if ((!(((&(reader__)))->ReadSentinel(102892058)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ActorHandle'");
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__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;
}
auto maybe__datastoreId = IPC::ReadParam<uint64_t>((&(reader__)));
if (!maybe__datastoreId) {
FatalError("Error deserializing 'uint64_t'");
return MsgValueError;
}
auto& datastoreId = *maybe__datastoreId;
// Sentinel = 'datastoreId'
if ((!(((&(reader__)))->ReadSentinel(456262773)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
return MsgValueError;
}
reader__.EndRead();
RefPtr<PBackgroundLSDatabaseParent> actor = (this)->AllocPBackgroundLSDatabaseParent(principalInfo, privateBrowsingId, datastoreId);
if (!actor) {
NS_WARNING("Cannot bind null PBackgroundLSDatabaseParent actor");
return MsgValueError;
}
if (actor->SetManagerAndRegister(this, (handle__).mId)) {
mManagedPBackgroundLSDatabaseParent.Insert(actor);
} else {
NS_WARNING("Failed to bind PBackgroundLSDatabaseParent actor");
return MsgValueError;
}
mozilla::ipc::IPCResult __ok = (this)->RecvPBackgroundLSDatabaseConstructor(actor, std::move(principalInfo), std::move(privateBrowsingId), std::move(datastoreId));
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__handle__ = IPC::ReadParam<ActorHandle>((&(reader__)));
if (!maybe__handle__) {
FatalError("Error deserializing 'ActorHandle'");
return MsgValueError;
}
auto& handle__ = *maybe__handle__;
// Sentinel = 'actor'
if ((!(((&(reader__)))->ReadSentinel(102892058)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ActorHandle'");
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();
PBackgroundLSObserverParent* actor = (this)->AllocPBackgroundLSObserverParent(observerId);
if (!actor) {
NS_WARNING("Cannot bind null PBackgroundLSObserverParent actor");
return MsgValueError;
}
if (actor->SetManagerAndRegister(this, (handle__).mId)) {
mManagedPBackgroundLSObserverParent.Insert(actor);
} else {
NS_WARNING("Failed to bind PBackgroundLSObserverParent actor");
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__handle__ = IPC::ReadParam<ActorHandle>((&(reader__)));
if (!maybe__handle__) {
FatalError("Error deserializing 'ActorHandle'");
return MsgValueError;
}
auto& handle__ = *maybe__handle__;
// Sentinel = 'actor'
if ((!(((&(reader__)))->ReadSentinel(102892058)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ActorHandle'");
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();
PBackgroundLSRequestParent* actor = (this)->AllocPBackgroundLSRequestParent(params);
if (!actor) {
NS_WARNING("Cannot bind null PBackgroundLSRequestParent actor");
return MsgValueError;
}
if (actor->SetManagerAndRegister(this, (handle__).mId)) {
mManagedPBackgroundLSRequestParent.Insert(actor);
} else {
NS_WARNING("Failed to bind PBackgroundLSRequestParent actor");
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__handle__ = IPC::ReadParam<ActorHandle>((&(reader__)));
if (!maybe__handle__) {
FatalError("Error deserializing 'ActorHandle'");
return MsgValueError;
}
auto& handle__ = *maybe__handle__;
// Sentinel = 'actor'
if ((!(((&(reader__)))->ReadSentinel(102892058)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ActorHandle'");
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();
PBackgroundLSSimpleRequestParent* actor = (this)->AllocPBackgroundLSSimpleRequestParent(params);
if (!actor) {
NS_WARNING("Cannot bind null PBackgroundLSSimpleRequestParent actor");
return MsgValueError;
}
if (actor->SetManagerAndRegister(this, (handle__).mId)) {
mManagedPBackgroundLSSimpleRequestParent.Insert(actor);
} else {
NS_WARNING("Failed to bind PBackgroundLSSimpleRequestParent actor");
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__handle__ = IPC::ReadParam<ActorHandle>((&(reader__)));
if (!maybe__handle__) {
FatalError("Error deserializing 'ActorHandle'");
return MsgValueError;
}
auto& handle__ = *maybe__handle__;
// Sentinel = 'actor'
if ((!(((&(reader__)))->ReadSentinel(102892058)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ActorHandle'");
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();
PBackgroundLocalStorageCacheParent* actor = (this)->AllocPBackgroundLocalStorageCacheParent(principalInfo, originKey, privateBrowsingId);
if (!actor) {
NS_WARNING("Cannot bind null PBackgroundLocalStorageCacheParent actor");
return MsgValueError;
}
if (actor->SetManagerAndRegister(this, (handle__).mId)) {
mManagedPBackgroundLocalStorageCacheParent.Insert(actor);
} else {
NS_WARNING("Failed to bind PBackgroundLocalStorageCacheParent actor");
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__handle__ = IPC::ReadParam<ActorHandle>((&(reader__)));
if (!maybe__handle__) {
FatalError("Error deserializing 'ActorHandle'");
return MsgValueError;
}
auto& handle__ = *maybe__handle__;
// Sentinel = 'actor'
if ((!(((&(reader__)))->ReadSentinel(102892058)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ActorHandle'");
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();
RefPtr<PBackgroundSessionStorageManagerParent> actor = (this)->AllocPBackgroundSessionStorageManagerParent(aTopContextId);
if (!actor) {
NS_WARNING("Cannot bind null PBackgroundSessionStorageManagerParent actor");
return MsgValueError;
}
if (actor->SetManagerAndRegister(this, (handle__).mId)) {
mManagedPBackgroundSessionStorageManagerParent.Insert(actor);
} else {
NS_WARNING("Failed to bind PBackgroundSessionStorageManagerParent actor");
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__handle__ = IPC::ReadParam<ActorHandle>((&(reader__)));
if (!maybe__handle__) {
FatalError("Error deserializing 'ActorHandle'");
return MsgValueError;
}
auto& handle__ = *maybe__handle__;
// Sentinel = 'actor'
if ((!(((&(reader__)))->ReadSentinel(102892058)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ActorHandle'");
return MsgValueError;
}
reader__.EndRead();
RefPtr<PBackgroundSessionStorageServiceParent> actor = (this)->AllocPBackgroundSessionStorageServiceParent();
if (!actor) {
NS_WARNING("Cannot bind null PBackgroundSessionStorageServiceParent actor");
return MsgValueError;
}
if (actor->SetManagerAndRegister(this, (handle__).mId)) {
mManagedPBackgroundSessionStorageServiceParent.Insert(actor);
} else {
NS_WARNING("Failed to bind PBackgroundSessionStorageServiceParent actor");
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__handle__ = IPC::ReadParam<ActorHandle>((&(reader__)));
if (!maybe__handle__) {
FatalError("Error deserializing 'ActorHandle'");
return MsgValueError;
}
auto& handle__ = *maybe__handle__;
// Sentinel = 'actor'
if ((!(((&(reader__)))->ReadSentinel(102892058)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ActorHandle'");
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();
PBackgroundStorageParent* actor = (this)->AllocPBackgroundStorageParent(profilePath, privateBrowsingId);
if (!actor) {
NS_WARNING("Cannot bind null PBackgroundStorageParent actor");
return MsgValueError;
}
if (actor->SetManagerAndRegister(this, (handle__).mId)) {
mManagedPBackgroundStorageParent.Insert(actor);
} else {
NS_WARNING("Failed to bind PBackgroundStorageParent actor");
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();
int32_t 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__aClientInfo = IPC::ReadParam<mozilla::Maybe<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__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();
int32_t 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(aClientInfo), std::move(aDedicated), std::move(aRequireUnreliable), std::move(aCongestionControl), 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_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__handle__ = IPC::ReadParam<ActorHandle>((&(reader__)));
if (!maybe__handle__) {
FatalError("Error deserializing 'ActorHandle'");
return MsgValueError;
}
auto& handle__ = *maybe__handle__;
// Sentinel = 'actor'
if ((!(((&(reader__)))->ReadSentinel(102892058)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ActorHandle'");
return MsgValueError;
}
reader__.EndRead();
RefPtr<PVsyncParent> actor = (this)->AllocPVsyncParent();
if (!actor) {
NS_WARNING("Cannot bind null PVsyncParent actor");
return MsgValueError;
}
if (actor->SetManagerAndRegister(this, (handle__).mId)) {
mManagedPVsyncParent.Insert(actor);
} else {
NS_WARNING("Failed to bind PVsyncParent actor");
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__handle__ = IPC::ReadParam<ActorHandle>((&(reader__)));
if (!maybe__handle__) {
FatalError("Error deserializing 'ActorHandle'");
return MsgValueError;
}
auto& handle__ = *maybe__handle__;
// Sentinel = 'actor'
if ((!(((&(reader__)))->ReadSentinel(102892058)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ActorHandle'");
return MsgValueError;
}
reader__.EndRead();
PCamerasParent* actor = (this)->AllocPCamerasParent();
if (!actor) {
NS_WARNING("Cannot bind null PCamerasParent actor");
return MsgValueError;
}
if (actor->SetManagerAndRegister(this, (handle__).mId)) {
mManagedPCamerasParent.Insert(actor);
} else {
NS_WARNING("Failed to bind PCamerasParent actor");
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__handle__ = IPC::ReadParam<ActorHandle>((&(reader__)));
if (!maybe__handle__) {
FatalError("Error deserializing 'ActorHandle'");
return MsgValueError;
}
auto& handle__ = *maybe__handle__;
// Sentinel = 'actor'
if ((!(((&(reader__)))->ReadSentinel(102892058)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ActorHandle'");
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();
PUDPSocketParent* actor = (this)->AllocPUDPSocketParent(pInfo, filter);
if (!actor) {
NS_WARNING("Cannot bind null PUDPSocketParent actor");
return MsgValueError;
}
if (actor->SetManagerAndRegister(this, (handle__).mId)) {
mManagedPUDPSocketParent.Insert(actor);
} else {
NS_WARNING("Failed to bind PUDPSocketParent actor");
return MsgValueError;
}
mozilla::ipc::IPCResult __ok = (this)->RecvPUDPSocketConstructor(std::move(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__handle__ = IPC::ReadParam<ActorHandle>((&(reader__)));
if (!maybe__handle__) {
FatalError("Error deserializing 'ActorHandle'");
return MsgValueError;
}
auto& handle__ = *maybe__handle__;
// Sentinel = 'actor'
if ((!(((&(reader__)))->ReadSentinel(102892058)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ActorHandle'");
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();
PBroadcastChannelParent* actor = (this)->AllocPBroadcastChannelParent(pInfo, origin, channel);
if (!actor) {
NS_WARNING("Cannot bind null PBroadcastChannelParent actor");
return MsgValueError;
}
if (actor->SetManagerAndRegister(this, (handle__).mId)) {
mManagedPBroadcastChannelParent.Insert(actor);
} else {
NS_WARNING("Failed to bind PBroadcastChannelParent actor");
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_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__handle__ = IPC::ReadParam<ActorHandle>((&(reader__)));
if (!maybe__handle__) {
FatalError("Error deserializing 'ActorHandle'");
return MsgValueError;
}
auto& handle__ = *maybe__handle__;
// Sentinel = 'actor'
if ((!(((&(reader__)))->ReadSentinel(102892058)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ActorHandle'");
return MsgValueError;
}
reader__.EndRead();
PServiceWorkerManagerParent* actor = (this)->AllocPServiceWorkerManagerParent();
if (!actor) {
NS_WARNING("Cannot bind null PServiceWorkerManagerParent actor");
return MsgValueError;
}
if (actor->SetManagerAndRegister(this, (handle__).mId)) {
mManagedPServiceWorkerManagerParent.Insert(actor);
} else {
NS_WARNING("Failed to bind PServiceWorkerManagerParent actor");
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__handle__ = IPC::ReadParam<ActorHandle>((&(reader__)));
if (!maybe__handle__) {
FatalError("Error deserializing 'ActorHandle'");
return MsgValueError;
}
auto& handle__ = *maybe__handle__;
// Sentinel = 'actor'
if ((!(((&(reader__)))->ReadSentinel(102892058)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ActorHandle'");
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();
RefPtr<PCacheStorageParent> actor = (this)->AllocPCacheStorageParent(aNamespace, aPrincipalInfo);
if (!actor) {
NS_WARNING("Cannot bind null PCacheStorageParent actor");
return MsgValueError;
}
if (actor->SetManagerAndRegister(this, (handle__).mId)) {
mManagedPCacheStorageParent.Insert(actor);
} else {
NS_WARNING("Failed to bind PCacheStorageParent actor");
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__handle__ = IPC::ReadParam<ActorHandle>((&(reader__)));
if (!maybe__handle__) {
FatalError("Error deserializing 'ActorHandle'");
return MsgValueError;
}
auto& handle__ = *maybe__handle__;
// Sentinel = 'actor'
if ((!(((&(reader__)))->ReadSentinel(102892058)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ActorHandle'");
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();
PMessagePortParent* actor = (this)->AllocPMessagePortParent(uuid, destinationUuid, sequenceId);
if (!actor) {
NS_WARNING("Cannot bind null PMessagePortParent actor");
return MsgValueError;
}
if (actor->SetManagerAndRegister(this, (handle__).mId)) {
mManagedPMessagePortParent.Insert(actor);
} else {
NS_WARNING("Failed to bind PMessagePortParent actor");
return MsgValueError;
}
mozilla::ipc::IPCResult __ok = (this)->RecvPMessagePortConstructor(std::move(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__handle__ = IPC::ReadParam<ActorHandle>((&(reader__)));
if (!maybe__handle__) {
FatalError("Error deserializing 'ActorHandle'");
return MsgValueError;
}
auto& handle__ = *maybe__handle__;
// Sentinel = 'actor'
if ((!(((&(reader__)))->ReadSentinel(102892058)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ActorHandle'");
return MsgValueError;
}
reader__.EndRead();
RefPtr<PQuotaParent> actor = (this)->AllocPQuotaParent();
if (!actor) {
NS_WARNING("Cannot bind null PQuotaParent actor");
return MsgValueError;
}
if (actor->SetManagerAndRegister(this, (handle__).mId)) {
mManagedPQuotaParent.Insert(actor);
} else {
NS_WARNING("Failed to bind PQuotaParent actor");
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();
int32_t 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__handle__ = IPC::ReadParam<ActorHandle>((&(reader__)));
if (!maybe__handle__) {
FatalError("Error deserializing 'ActorHandle'");
return MsgValueError;
}
auto& handle__ = *maybe__handle__;
// Sentinel = 'actor'
if ((!(((&(reader__)))->ReadSentinel(102892058)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ActorHandle'");
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();
RefPtr<PFileSystemRequestParent> actor = (this)->AllocPFileSystemRequestParent(params);
if (!actor) {
NS_WARNING("Cannot bind null PFileSystemRequestParent actor");
return MsgValueError;
}
if (actor->SetManagerAndRegister(this, (handle__).mId)) {
mManagedPFileSystemRequestParent.Insert(actor);
} else {
NS_WARNING("Failed to bind PFileSystemRequestParent actor");
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__handle__ = IPC::ReadParam<ActorHandle>((&(reader__)));
if (!maybe__handle__) {
FatalError("Error deserializing 'ActorHandle'");
return MsgValueError;
}
auto& handle__ = *maybe__handle__;
// Sentinel = 'actor'
if ((!(((&(reader__)))->ReadSentinel(102892058)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ActorHandle'");
return MsgValueError;
}
reader__.EndRead();
RefPtr<PGamepadEventChannelParent> actor = (this)->AllocPGamepadEventChannelParent();
if (!actor) {
NS_WARNING("Cannot bind null PGamepadEventChannelParent actor");
return MsgValueError;
}
if (actor->SetManagerAndRegister(this, (handle__).mId)) {
mManagedPGamepadEventChannelParent.Insert(actor);
} else {
NS_WARNING("Failed to bind PGamepadEventChannelParent actor");
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__handle__ = IPC::ReadParam<ActorHandle>((&(reader__)));
if (!maybe__handle__) {
FatalError("Error deserializing 'ActorHandle'");
return MsgValueError;
}
auto& handle__ = *maybe__handle__;
// Sentinel = 'actor'
if ((!(((&(reader__)))->ReadSentinel(102892058)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ActorHandle'");
return MsgValueError;
}
reader__.EndRead();
RefPtr<PGamepadTestChannelParent> actor = (this)->AllocPGamepadTestChannelParent();
if (!actor) {
NS_WARNING("Cannot bind null PGamepadTestChannelParent actor");
return MsgValueError;
}
if (actor->SetManagerAndRegister(this, (handle__).mId)) {
mManagedPGamepadTestChannelParent.Insert(actor);
} else {
NS_WARNING("Failed to bind PGamepadTestChannelParent actor");
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__handle__ = IPC::ReadParam<ActorHandle>((&(reader__)));
if (!maybe__handle__) {
FatalError("Error deserializing 'ActorHandle'");
return MsgValueError;
}
auto& handle__ = *maybe__handle__;
// Sentinel = 'actor'
if ((!(((&(reader__)))->ReadSentinel(102892058)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ActorHandle'");
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();
RefPtr<PHttpBackgroundChannelParent> actor = (this)->AllocPHttpBackgroundChannelParent(channelId);
if (!actor) {
NS_WARNING("Cannot bind null PHttpBackgroundChannelParent actor");
return MsgValueError;
}
if (actor->SetManagerAndRegister(this, (handle__).mId)) {
mManagedPHttpBackgroundChannelParent.Insert(actor);
} else {
NS_WARNING("Failed to bind PHttpBackgroundChannelParent actor");
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_PWebAuthnTransactionConstructor__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_PWebAuthnTransactionConstructor", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__handle__ = IPC::ReadParam<ActorHandle>((&(reader__)));
if (!maybe__handle__) {
FatalError("Error deserializing 'ActorHandle'");
return MsgValueError;
}
auto& handle__ = *maybe__handle__;
// Sentinel = 'actor'
if ((!(((&(reader__)))->ReadSentinel(102892058)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ActorHandle'");
return MsgValueError;
}
reader__.EndRead();
PWebAuthnTransactionParent* actor = (this)->AllocPWebAuthnTransactionParent();
if (!actor) {
NS_WARNING("Cannot bind null PWebAuthnTransactionParent actor");
return MsgValueError;
}
if (actor->SetManagerAndRegister(this, (handle__).mId)) {
mManagedPWebAuthnTransactionParent.Insert(actor);
} else {
NS_WARNING("Failed to bind PWebAuthnTransactionParent actor");
return MsgValueError;
}
mozilla::ipc::IPCResult __ok = (this)->RecvPWebAuthnTransactionConstructor(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_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__handle__ = IPC::ReadParam<ActorHandle>((&(reader__)));
if (!maybe__handle__) {
FatalError("Error deserializing 'ActorHandle'");
return MsgValueError;
}
auto& handle__ = *maybe__handle__;
// Sentinel = 'actor'
if ((!(((&(reader__)))->ReadSentinel(102892058)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ActorHandle'");
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();
PSharedWorkerParent* actor = (this)->AllocPSharedWorkerParent(data, windowID, portIdentifier);
if (!actor) {
NS_WARNING("Cannot bind null PSharedWorkerParent actor");
return MsgValueError;
}
if (actor->SetManagerAndRegister(this, (handle__).mId)) {
mManagedPSharedWorkerParent.Insert(actor);
} else {
NS_WARNING("Failed to bind PSharedWorkerParent actor");
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__handle__ = IPC::ReadParam<ActorHandle>((&(reader__)));
if (!maybe__handle__) {
FatalError("Error deserializing 'ActorHandle'");
return MsgValueError;
}
auto& handle__ = *maybe__handle__;
// Sentinel = 'actor'
if ((!(((&(reader__)))->ReadSentinel(102892058)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ActorHandle'");
return MsgValueError;
}
reader__.EndRead();
PTemporaryIPCBlobParent* actor = (this)->AllocPTemporaryIPCBlobParent();
if (!actor) {
NS_WARNING("Cannot bind null PTemporaryIPCBlobParent actor");
return MsgValueError;
}
if (actor->SetManagerAndRegister(this, (handle__).mId)) {
mManagedPTemporaryIPCBlobParent.Insert(actor);
} else {
NS_WARNING("Failed to bind PTemporaryIPCBlobParent actor");
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__handle__ = IPC::ReadParam<ActorHandle>((&(reader__)));
if (!maybe__handle__) {
FatalError("Error deserializing 'ActorHandle'");
return MsgValueError;
}
auto& handle__ = *maybe__handle__;
// Sentinel = 'actor'
if ((!(((&(reader__)))->ReadSentinel(102892058)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ActorHandle'");
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();
PFileCreatorParent* actor = (this)->AllocPFileCreatorParent(aFullPath, aType, aName, lastModified, aExistenceCheck, aIsFromNsIFile);
if (!actor) {
NS_WARNING("Cannot bind null PFileCreatorParent actor");
return MsgValueError;
}
if (actor->SetManagerAndRegister(this, (handle__).mId)) {
mManagedPFileCreatorParent.Insert(actor);
} else {
NS_WARNING("Failed to bind PFileCreatorParent actor");
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__handle__ = IPC::ReadParam<ActorHandle>((&(reader__)));
if (!maybe__handle__) {
FatalError("Error deserializing 'ActorHandle'");
return MsgValueError;
}
auto& handle__ = *maybe__handle__;
// Sentinel = 'actor'
if ((!(((&(reader__)))->ReadSentinel(102892058)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ActorHandle'");
return MsgValueError;
}
reader__.EndRead();
RefPtr<PClientManagerParent> actor = (this)->AllocPClientManagerParent();
if (!actor) {
NS_WARNING("Cannot bind null PClientManagerParent actor");
return MsgValueError;
}
if (actor->SetManagerAndRegister(this, (handle__).mId)) {
mManagedPClientManagerParent.Insert(actor);
} else {
NS_WARNING("Failed to bind PClientManagerParent actor");
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_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);
int32_t 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_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__handle__ = IPC::ReadParam<ActorHandle>((&(reader__)));
if (!maybe__handle__) {
FatalError("Error deserializing 'ActorHandle'");
return MsgValueError;
}
auto& handle__ = *maybe__handle__;
// Sentinel = 'actor'
if ((!(((&(reader__)))->ReadSentinel(102892058)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ActorHandle'");
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();
RefPtr<PServiceWorkerParent> actor = (this)->AllocPServiceWorkerParent(aDescriptor);
if (!actor) {
NS_WARNING("Cannot bind null PServiceWorkerParent actor");
return MsgValueError;
}
if (actor->SetManagerAndRegister(this, (handle__).mId)) {
mManagedPServiceWorkerParent.Insert(actor);
} else {
NS_WARNING("Failed to bind PServiceWorkerParent actor");
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__handle__ = IPC::ReadParam<ActorHandle>((&(reader__)));
if (!maybe__handle__) {
FatalError("Error deserializing 'ActorHandle'");
return MsgValueError;
}
auto& handle__ = *maybe__handle__;
// Sentinel = 'actor'
if ((!(((&(reader__)))->ReadSentinel(102892058)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ActorHandle'");
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();
RefPtr<PRemoteWorkerControllerParent> actor = (this)->AllocPRemoteWorkerControllerParent(aData);
if (!actor) {
NS_WARNING("Cannot bind null PRemoteWorkerControllerParent actor");
return MsgValueError;
}
if (actor->SetManagerAndRegister(this, (handle__).mId)) {
mManagedPRemoteWorkerControllerParent.Insert(actor);
} else {
NS_WARNING("Failed to bind PRemoteWorkerControllerParent actor");
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_PRemoteWorkerServiceConstructor__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_PRemoteWorkerServiceConstructor", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__handle__ = IPC::ReadParam<ActorHandle>((&(reader__)));
if (!maybe__handle__) {
FatalError("Error deserializing 'ActorHandle'");
return MsgValueError;
}
auto& handle__ = *maybe__handle__;
// Sentinel = 'actor'
if ((!(((&(reader__)))->ReadSentinel(102892058)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ActorHandle'");
return MsgValueError;
}
reader__.EndRead();
RefPtr<PRemoteWorkerServiceParent> actor = (this)->AllocPRemoteWorkerServiceParent();
if (!actor) {
NS_WARNING("Cannot bind null PRemoteWorkerServiceParent actor");
return MsgValueError;
}
if (actor->SetManagerAndRegister(this, (handle__).mId)) {
mManagedPRemoteWorkerServiceParent.Insert(actor);
} else {
NS_WARNING("Failed to bind PRemoteWorkerServiceParent actor");
return MsgValueError;
}
mozilla::ipc::IPCResult __ok = (this)->RecvPRemoteWorkerServiceConstructor(actor);
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__handle__ = IPC::ReadParam<ActorHandle>((&(reader__)));
if (!maybe__handle__) {
FatalError("Error deserializing 'ActorHandle'");
return MsgValueError;
}
auto& handle__ = *maybe__handle__;
// Sentinel = 'actor'
if ((!(((&(reader__)))->ReadSentinel(102892058)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ActorHandle'");
return MsgValueError;
}
reader__.EndRead();
RefPtr<PServiceWorkerContainerParent> actor = (this)->AllocPServiceWorkerContainerParent();
if (!actor) {
NS_WARNING("Cannot bind null PServiceWorkerContainerParent actor");
return MsgValueError;
}
if (actor->SetManagerAndRegister(this, (handle__).mId)) {
mManagedPServiceWorkerContainerParent.Insert(actor);
} else {
NS_WARNING("Failed to bind PServiceWorkerContainerParent actor");
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__handle__ = IPC::ReadParam<ActorHandle>((&(reader__)));
if (!maybe__handle__) {
FatalError("Error deserializing 'ActorHandle'");
return MsgValueError;
}
auto& handle__ = *maybe__handle__;
// Sentinel = 'actor'
if ((!(((&(reader__)))->ReadSentinel(102892058)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ActorHandle'");
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;
}
reader__.EndRead();
RefPtr<PServiceWorkerRegistrationParent> actor = (this)->AllocPServiceWorkerRegistrationParent(aDescriptor);
if (!actor) {
NS_WARNING("Cannot bind null PServiceWorkerRegistrationParent actor");
return MsgValueError;
}
if (actor->SetManagerAndRegister(this, (handle__).mId)) {
mManagedPServiceWorkerRegistrationParent.Insert(actor);
} else {
NS_WARNING("Failed to bind PServiceWorkerRegistrationParent actor");
return MsgValueError;
}
mozilla::ipc::IPCResult __ok = (this)->RecvPServiceWorkerRegistrationConstructor(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_PEndpointForReportConstructor__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_PEndpointForReportConstructor", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__handle__ = IPC::ReadParam<ActorHandle>((&(reader__)));
if (!maybe__handle__) {
FatalError("Error deserializing 'ActorHandle'");
return MsgValueError;
}
auto& handle__ = *maybe__handle__;
// Sentinel = 'actor'
if ((!(((&(reader__)))->ReadSentinel(102892058)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ActorHandle'");
return MsgValueError;
}
auto maybe__aGroupName = IPC::ReadParam<nsString>((&(reader__)));
if (!maybe__aGroupName) {
FatalError("Error deserializing 'nsString'");
return MsgValueError;
}
auto& aGroupName = *maybe__aGroupName;
// Sentinel = 'aGroupName'
if ((!(((&(reader__)))->ReadSentinel(359924720)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsString'");
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();
PEndpointForReportParent* actor = (this)->AllocPEndpointForReportParent(aGroupName, aPrincipalInfo);
if (!actor) {
NS_WARNING("Cannot bind null PEndpointForReportParent actor");
return MsgValueError;
}
if (actor->SetManagerAndRegister(this, (handle__).mId)) {
mManagedPEndpointForReportParent.Insert(actor);
} else {
NS_WARNING("Failed to bind PEndpointForReportParent actor");
return MsgValueError;
}
mozilla::ipc::IPCResult __ok = (this)->RecvPEndpointForReportConstructor(std::move(actor), std::move(aGroupName), 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_RemoveEndpoint__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_RemoveEndpoint", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__aGroupName = IPC::ReadParam<nsString>((&(reader__)));
if (!maybe__aGroupName) {
FatalError("Error deserializing 'nsString'");
return MsgValueError;
}
auto& aGroupName = *maybe__aGroupName;
// Sentinel = 'aGroupName'
if ((!(((&(reader__)))->ReadSentinel(359924720)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsString'");
return MsgValueError;
}
auto maybe__aEndpointURL = IPC::ReadParam<nsCString>((&(reader__)));
if (!maybe__aEndpointURL) {
FatalError("Error deserializing 'nsCString'");
return MsgValueError;
}
auto& aEndpointURL = *maybe__aEndpointURL;
// Sentinel = 'aEndpointURL'
if ((!(((&(reader__)))->ReadSentinel(507708566)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsCString'");
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)->RecvRemoveEndpoint(std::move(aGroupName), std::move(aEndpointURL), 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_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__handle__ = IPC::ReadParam<ActorHandle>((&(reader__)));
if (!maybe__handle__) {
FatalError("Error deserializing 'ActorHandle'");
return MsgValueError;
}
auto& handle__ = *maybe__handle__;
// Sentinel = 'actor'
if ((!(((&(reader__)))->ReadSentinel(102892058)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ActorHandle'");
return MsgValueError;
}
reader__.EndRead();
RefPtr<PIdleSchedulerParent> actor = (this)->AllocPIdleSchedulerParent();
if (!actor) {
NS_WARNING("Cannot bind null PIdleSchedulerParent actor");
return MsgValueError;
}
if (actor->SetManagerAndRegister(this, (handle__).mId)) {
mManagedPIdleSchedulerParent.Insert(actor);
} else {
NS_WARNING("Failed to bind PIdleSchedulerParent actor");
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);
int32_t 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::PRemoteDecoderManagerChild>&&> 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<RemoteDecodeIn>((&(reader__)));
if (!maybe__aLocation) {
FatalError("Error deserializing 'RemoteDecodeIn'");
return MsgValueError;
}
auto& aLocation = *maybe__aLocation;
// Sentinel = 'aLocation'
if ((!(((&(reader__)))->ReadSentinel(292094875)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'RemoteDecodeIn'");
return MsgValueError;
}
reader__.EndRead();
int32_t 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::PRemoteDecoderManagerChild>&&> 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__handle__ = IPC::ReadParam<ActorHandle>((&(reader__)));
if (!maybe__handle__) {
FatalError("Error deserializing 'ActorHandle'");
return MsgValueError;
}
auto& handle__ = *maybe__handle__;
// Sentinel = 'actor'
if ((!(((&(reader__)))->ReadSentinel(102892058)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ActorHandle'");
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<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();
RefPtr<PLockManagerParent> actor = (this)->AllocPLockManagerParent(aPrincipalInfo, aClientId);
if (!actor) {
NS_WARNING("Cannot bind null PLockManagerParent actor");
return MsgValueError;
}
if (actor->SetManagerAndRegister(this, (handle__).mId)) {
mManagedPLockManagerParent.Insert(actor);
} else {
NS_WARNING("Failed to bind PLockManagerParent actor");
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__handle__ = IPC::ReadParam<ActorHandle>((&(reader__)));
if (!maybe__handle__) {
FatalError("Error deserializing 'ActorHandle'");
return MsgValueError;
}
auto& handle__ = *maybe__handle__;
// Sentinel = 'actor'
if ((!(((&(reader__)))->ReadSentinel(102892058)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ActorHandle'");
return MsgValueError;
}
reader__.EndRead();
RefPtr<PFetchParent> actor = (this)->AllocPFetchParent();
if (!actor) {
NS_WARNING("Cannot bind null PFetchParent actor");
return MsgValueError;
}
if (actor->SetManagerAndRegister(this, (handle__).mId)) {
mManagedPFetchParent.Insert(actor);
} else {
NS_WARNING("Failed to bind PFetchParent actor");
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();
int32_t 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;
}
case PBackground::Reply_PRemoteWorkerConstructor__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
{
int32_t route__ = msg__.routing_id();
if (MSG_ROUTING_CONTROL != route__) {
IProtocol* routed__ = Lookup(route__);
if (!routed__ || !routed__->GetLifecycleProxy()) {
return MsgRouteError;
}
RefPtr<mozilla::ipc::ActorLifecycleProxy> proxy__ =
routed__->GetLifecycleProxy();
return proxy__->Get()->OnMessageReceived(msg__, reply__);
}
return MsgNotKnown;
}
auto PBackgroundParent::DoomSubtree() -> void
{
for (auto* key : mManagedPBackgroundIDBFactoryParent) {
key->DoomSubtree();
}
for (auto* key : mManagedPBackgroundIndexedDBUtilsParent) {
key->DoomSubtree();
}
for (auto* key : mManagedPBackgroundSDBConnectionParent) {
key->DoomSubtree();
}
for (auto* key : mManagedPBackgroundLSDatabaseParent) {
key->DoomSubtree();
}
for (auto* key : mManagedPBackgroundLSObserverParent) {
key->DoomSubtree();
}
for (auto* key : mManagedPBackgroundLSRequestParent) {
key->DoomSubtree();
}
for (auto* key : mManagedPBackgroundLSSimpleRequestParent) {
key->DoomSubtree();
}
for (auto* key : mManagedPBackgroundLocalStorageCacheParent) {
key->DoomSubtree();
}
for (auto* key : mManagedPBackgroundSessionStorageManagerParent) {
key->DoomSubtree();
}
for (auto* key : mManagedPBackgroundSessionStorageServiceParent) {
key->DoomSubtree();
}
for (auto* key : mManagedPBackgroundStorageParent) {
key->DoomSubtree();
}
for (auto* key : mManagedPBackgroundTestParent) {
key->DoomSubtree();
}
for (auto* key : mManagedPBroadcastChannelParent) {
key->DoomSubtree();
}
for (auto* key : mManagedPCacheParent) {
key->DoomSubtree();
}
for (auto* key : mManagedPCacheStorageParent) {
key->DoomSubtree();
}
for (auto* key : mManagedPCacheStreamControlParent) {
key->DoomSubtree();
}
for (auto* key : mManagedPClientManagerParent) {
key->DoomSubtree();
}
for (auto* key : mManagedPEndpointForReportParent) {
key->DoomSubtree();
}
for (auto* key : mManagedPFileSystemRequestParent) {
key->DoomSubtree();
}
for (auto* key : mManagedPGamepadEventChannelParent) {
key->DoomSubtree();
}
for (auto* key : mManagedPGamepadTestChannelParent) {
key->DoomSubtree();
}
for (auto* key : mManagedPHttpBackgroundChannelParent) {
key->DoomSubtree();
}
for (auto* key : mManagedPIdleSchedulerParent) {
key->DoomSubtree();
}
for (auto* key : mManagedPLockManagerParent) {
key->DoomSubtree();
}
for (auto* key : mManagedPRemoteWorkerParent) {
key->DoomSubtree();
}
for (auto* key : mManagedPRemoteWorkerControllerParent) {
key->DoomSubtree();
}
for (auto* key : mManagedPRemoteWorkerServiceParent) {
key->DoomSubtree();
}
for (auto* key : mManagedPSharedWorkerParent) {
key->DoomSubtree();
}
for (auto* key : mManagedPTemporaryIPCBlobParent) {
key->DoomSubtree();
}
for (auto* key : mManagedPFileCreatorParent) {
key->DoomSubtree();
}
for (auto* key : mManagedPMessagePortParent) {
key->DoomSubtree();
}
for (auto* key : mManagedPCamerasParent) {
key->DoomSubtree();
}
for (auto* key : mManagedPQuotaParent) {
key->DoomSubtree();
}
for (auto* key : mManagedPServiceWorkerParent) {
key->DoomSubtree();
}
for (auto* key : mManagedPServiceWorkerContainerParent) {
key->DoomSubtree();
}
for (auto* key : mManagedPServiceWorkerManagerParent) {
key->DoomSubtree();
}
for (auto* key : mManagedPServiceWorkerRegistrationParent) {
key->DoomSubtree();
}
for (auto* key : mManagedPWebAuthnTransactionParent) {
key->DoomSubtree();
}
for (auto* key : mManagedPUDPSocketParent) {
key->DoomSubtree();
}
for (auto* key : mManagedPVsyncParent) {
key->DoomSubtree();
}
for (auto* key : mManagedPFetchParent) {
key->DoomSubtree();
}
SetDoomed();
}
auto PBackgroundParent::PeekManagedActor() -> IProtocol*
{
if (IProtocol* actor = mManagedPBackgroundIDBFactoryParent.Peek()) {
return actor;
}
if (IProtocol* actor = mManagedPBackgroundIndexedDBUtilsParent.Peek()) {
return actor;
}
if (IProtocol* actor = mManagedPBackgroundSDBConnectionParent.Peek()) {
return actor;
}
if (IProtocol* actor = mManagedPBackgroundLSDatabaseParent.Peek()) {
return actor;
}
if (IProtocol* actor = mManagedPBackgroundLSObserverParent.Peek()) {
return actor;
}
if (IProtocol* actor = mManagedPBackgroundLSRequestParent.Peek()) {
return actor;
}
if (IProtocol* actor = mManagedPBackgroundLSSimpleRequestParent.Peek()) {
return actor;
}
if (IProtocol* actor = mManagedPBackgroundLocalStorageCacheParent.Peek()) {
return actor;
}
if (IProtocol* actor = mManagedPBackgroundSessionStorageManagerParent.Peek()) {
return actor;
}
if (IProtocol* actor = mManagedPBackgroundSessionStorageServiceParent.Peek()) {
return actor;
}
if (IProtocol* actor = mManagedPBackgroundStorageParent.Peek()) {
return actor;
}
if (IProtocol* actor = mManagedPBackgroundTestParent.Peek()) {
return actor;
}
if (IProtocol* actor = mManagedPBroadcastChannelParent.Peek()) {
return actor;
}
if (IProtocol* actor = mManagedPCacheParent.Peek()) {
return actor;
}
if (IProtocol* actor = mManagedPCacheStorageParent.Peek()) {
return actor;
}
if (IProtocol* actor = mManagedPCacheStreamControlParent.Peek()) {
return actor;
}
if (IProtocol* actor = mManagedPClientManagerParent.Peek()) {
return actor;
}
if (IProtocol* actor = mManagedPEndpointForReportParent.Peek()) {
return actor;
}
if (IProtocol* actor = mManagedPFileSystemRequestParent.Peek()) {
return actor;
}
if (IProtocol* actor = mManagedPGamepadEventChannelParent.Peek()) {
return actor;
}
if (IProtocol* actor = mManagedPGamepadTestChannelParent.Peek()) {
return actor;
}
if (IProtocol* actor = mManagedPHttpBackgroundChannelParent.Peek()) {
return actor;
}
if (IProtocol* actor = mManagedPIdleSchedulerParent.Peek()) {
return actor;
}
if (IProtocol* actor = mManagedPLockManagerParent.Peek()) {
return actor;
}
if (IProtocol* actor = mManagedPRemoteWorkerParent.Peek()) {
return actor;
}
if (IProtocol* actor = mManagedPRemoteWorkerControllerParent.Peek()) {
return actor;
}
if (IProtocol* actor = mManagedPRemoteWorkerServiceParent.Peek()) {
return actor;
}
if (IProtocol* actor = mManagedPSharedWorkerParent.Peek()) {
return actor;
}
if (IProtocol* actor = mManagedPTemporaryIPCBlobParent.Peek()) {
return actor;
}
if (IProtocol* actor = mManagedPFileCreatorParent.Peek()) {
return actor;
}
if (IProtocol* actor = mManagedPMessagePortParent.Peek()) {
return actor;
}
if (IProtocol* actor = mManagedPCamerasParent.Peek()) {
return actor;
}
if (IProtocol* actor = mManagedPQuotaParent.Peek()) {
return actor;
}
if (IProtocol* actor = mManagedPServiceWorkerParent.Peek()) {
return actor;
}
if (IProtocol* actor = mManagedPServiceWorkerContainerParent.Peek()) {
return actor;
}
if (IProtocol* actor = mManagedPServiceWorkerManagerParent.Peek()) {
return actor;
}
if (IProtocol* actor = mManagedPServiceWorkerRegistrationParent.Peek()) {
return actor;
}
if (IProtocol* actor = mManagedPWebAuthnTransactionParent.Peek()) {
return actor;
}
if (IProtocol* actor = mManagedPUDPSocketParent.Peek()) {
return actor;
}
if (IProtocol* actor = mManagedPVsyncParent.Peek()) {
return actor;
}
if (IProtocol* actor = mManagedPFetchParent.Peek()) {
return actor;
}
return nullptr;
}
} // namespace ipc
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::ipc::PBackgroundParent*>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
MOZ_RELEASE_ASSERT(
aWriter->GetActor(),
"Cannot serialize managed actors without an actor");
int32_t id;
if (!aVar) {
id = 0; // kNullActorId
} else {
id = aVar->Id();
if (id == 1) { // kFreedActorId
aVar->FatalError("Actor has been |delete|d");
}
MOZ_RELEASE_ASSERT(
aWriter->GetActor()->GetIPCChannel() == aVar->GetIPCChannel(),
"Actor must be from the same channel as the"
" actor it's being sent over");
MOZ_RELEASE_ASSERT(
aVar->CanSend(),
"Actor must still be open when sending");
}
IPC::WriteParam(aWriter, id);
}
auto ParamTraits<::mozilla::ipc::PBackgroundParent*>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
MOZ_RELEASE_ASSERT(
aReader->GetActor(),
"Cannot deserialize managed actors without an actor");
mozilla::Maybe<mozilla::ipc::IProtocol*> actor = aReader->GetActor()
->ReadActor(aReader, true, "PBackground", PBackgroundMsgStart);
if (actor.isSome()) {
return static_cast<::mozilla::ipc::PBackgroundParent*>(actor.ref());
}
return {};
}
} // namespace IPC