/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at
http://mozilla.org/MPL/2.0/. */
include protocol PBackgroundDataBridge;
include protocol PBackgroundIDBFactory;
include protocol PBackgroundIndexedDBUtils;
include protocol PBackgroundSDBConnection;
include protocol PBackgroundLSObserver;
include protocol PBackgroundLSRequest;
include protocol PBackgroundLSSimpleRequest;
include protocol PBackgroundLocalStorageCache;
include protocol PBackgroundSessionStorageManager;
include protocol PBackgroundSessionStorageService;
include protocol PBackgroundStorage;
include protocol PBackgroundTest;
include protocol PBroadcastChannel;
include protocol PCache;
include protocol PCacheStorage;
include protocol PCacheStreamControl;
include protocol PClientManager;
include protocol PCookieStore;
include protocol PEndpointForReport;
include protocol PFileSystemManager;
include protocol PFileSystemRequest;
include protocol PGamepadEventChannel;
include protocol PGamepadTestChannel;
include protocol PHttpBackgroundChannel;
include protocol PIdleScheduler;
include protocol PRemoteWorkerController;
include protocol PRemoteWorkerService;
include protocol PSharedWorker;
include protocol PTemporaryIPCBlob;
include protocol PFileCreator;
include protocol PMessagePort;
include protocol PCameras;
include protocol PLockManager;
include protocol PMIDIManager;
include protocol PMIDIPort;
include protocol PMLSTransaction;
include protocol PQuota;
include protocol PServiceWorker;
include protocol PServiceWorkerContainer;
include protocol PServiceWorkerManager;
include protocol PServiceWorkerRegistration;
include protocol PWebAuthnTransaction;
include protocol PUDPSocket;
include protocol PVsync;
include protocol PRemoteDecoderManager;
include protocol PWebTransport;
include protocol PFetch;
include protocol PNotification;
include ClientIPCTypes;
include DOMTypes;
include IPCBlob;
include IPCServiceWorkerDescriptor;
include IPCServiceWorkerRegistrationDescriptor;
include PBackgroundLSSharedTypes;
include PBackgroundSharedTypes;
include PBackgroundIDBSharedTypes;
include PFileSystemParams;
include ProtocolTypes;
include RemoteWorkerTypes;
include MIDITypes;
include "mozilla/dom/cache/IPCUtils.h";
include "mozilla/dom/quota/SerializationHelpers.h";
include "mozilla/dom/PermissionMessageUtils.h";
include "mozilla/layers/LayersMessageUtils.h";
using mozilla::dom::cache::Namespace
from "mozilla/dom/cache/Types.h";
using class mozilla::dom::SSCacheCopy from "mozilla/dom/PBackgroundSessionStorageCac
he.h";
using mozilla::RemoteDecodeIn from "mozilla/RemoteDecoderManagerChild.h";
using mozilla::camera::CamerasAccessStatus from "mozilla/media/CamerasTypes.h";
namespace mozilla {
namespace ipc {
[NeedsOtherPid, ChildImpl=virtual, ParentImpl=virtual, ChildProc=anydom]
sync protocol PBackground
{
manages PBackgroundIDBFactory;
manages PBackgroundIndexedDBUtils;
manages PBackgroundSDBConnection;
manages PBackgroundLSObserver;
manages PBackgroundLSRequest;
manages PBackgroundLSSimpleRequest;
manages PBackgroundLocalStorageCache;
manages PBackgroundSessionStorageManager;
manages PBackgroundSessionStorageService;
manages PBackgroundStorage;
manages PBackgroundTest;
manages PBroadcastChannel;
manages PCache;
manages PCacheStorage;
manages PCacheStreamControl;
manages PClientManager;
manages PCookieStore;
manages PEndpointForReport;
manages PFileSystemRequest;
manages PGamepadEventChannel;
manages PGamepadTestChannel;
manages PHttpBackgroundChannel;
manages PIdleScheduler;
manages PLockManager;
manages PRemoteWorkerController;
manages PSharedWorker;
manages PTemporaryIPCBlob;
manages PFileCreator;
manages PMessagePort;
manages PCameras;
manages PQuota;
manages PServiceWorker;
manages PServiceWorkerContainer;
manages PServiceWorkerManager;
manages PServiceWorkerRegistration;
manages PWebAuthnTransaction;
manages PUDPSocket;
manages PVsync;
manages PFetch;
parent:
// Only called at startup during mochitests to check the basic infrastructure.
async PBackgroundTest(nsCString testArg);
async PBackgroundIDBFactory(LoggingInfo loggingInfo,
nsCString systemLocale);
async PBackgroundIndexedDBUtils();
// Use only for testing!
async FlushPendingFileDeletions();
async PBackgroundSDBConnection(PersistenceType persistenceType,
PrincipalInfo principalInfo);
async PBackgroundLSObserver(uint64_t observerId);
/**
* Issue an asynchronous request that will be used in a synchronous fashion
* through complex machinations described in `PBackgroundLSRequest.ipdl` and
* `LSObject.h`.
*/
async PBackgroundLSRequest(LSRequestParams params);
/**
* Issues a simple, non-cancelable asynchronous request that's used in an
* asynchronous fashion by callers. (LSRequest is not simple because it used
* in a synchronous fashion which leads to complexities regarding cancelation,
* see `PBackgroundLSRequest.ipdl` for details.)
*/
async PBackgroundLSSimpleRequest(LSSimpleRequestParams params);
async PBackgroundLocalStorageCache(PrincipalInfo principalInfo,
nsCString originKey,
uint32_t privateBrowsingId);
async PBackgroundSessionStorageManager(uint64_t aTopContextId);
async PBackgroundSessionStorageService();
async PBackgroundStorage(nsString profilePath, uint32_t privateBrowsingId);
/**
* Finish the setup of a new PFileSystemManager top level protocol.
*/
async CreateFileSystemManagerParent(
PrincipalInfo principalInfo,
Endpoint<PFileSystemManagerParent> aParentEndpoint)
returns(nsresult rv);
/**
* Finish the setup of a new PWebTransport top level protocol.
*/
async CreateWebTransportParent(
nsString aURL,
nullable nsIPrincipal aPrincipal,
IPCClientInfo? aClientInfo,
bool aDedicated,
bool aRequireUnreliable,
uint32_t aCongestionControl,
WebTransportHash[] aServerCertHashes,
Endpoint<PWebTransportParent> aParentEndpoint)
returns(nsresult rv, uint8_t aReliability); // Actually WebTransportReliabityMode enum
// XXX(krosylight): This should ultimately use nsID instead of scope, see bug 1881812.
/**
* Finish the setup of a new PNotification top level protocol.
*/
async CreateNotificationParent(
Endpoint<PNotificationParent> aParentEndpoint,
nsIPrincipal aPrincipal,
nsIPrincipal aEffectiveStoragePrincipal,
bool aIsSecureContext,
nsString aId,
nsString aScope,
IPCNotificationOptions aOptions
) returns (bool rv);
async PVsync();
async PCameras();
async PUDPSocket(PrincipalInfo? pInfo, nsCString filter);
async PBroadcastChannel(PrincipalInfo pInfo, nsCString origin, nsString channel);
async PCookieStore();
async PServiceWorkerManager();
async ShutdownServiceWorkerRegistrar();
async PCacheStorage(Namespace aNamespace, PrincipalInfo aPrincipalInfo);
async PMessagePort(nsID uuid, nsID destinationUuid, uint32_t sequenceId);
async MessagePortForceClose(nsID uuid, nsID destinationUuid, uint32_t sequenceId);
async PQuota();
async ShutdownQuotaManager();
async ShutdownBackgroundSessionStorageManagers();
async PropagateBackgroundSessionStorageManager(uint64_t currentTopContextId, uint64_t targetTopContextId);
async RemoveBackgroundSessionStorageManager(uint64_t topContextId);
async GetSessionStorageManagerData(
uint64_t aTopContextId, uint32_t aSizeLimit, bool aCancelSessionStoreTimer)
returns(SSCacheCopy[] aCacheCopy);
async LoadSessionStorageManagerData(uint64_t aTopContextId, SSCacheCopy[] aOriginCacheCopy);
async PFileSystemRequest(FileSystemParams params);
async PGamepadEventChannel();
async PGamepadTestChannel();
async PHttpBackgroundChannel(uint64_t channelId);
async PWebAuthnTransaction();
async PSharedWorker(RemoteWorkerData data,
uint64_t windowID,
MessagePortIdentifier portIdentifier);
async PTemporaryIPCBlob();
async PFileCreator(nsString aFullPath, nsString aType, nsString aName,
int64_t? lastModified, bool aExistenceCheck,
bool aIsFromNsIFile);
async PClientManager();
async CreateMIDIManager(Endpoint<PMIDIManagerParent> aEndpoint);
async CreateMIDIPort(Endpoint<PMIDIPortParent> aEndpoint,
MIDIPortInfo portInfo, bool sysexEnabled);
async HasMIDIDevice() returns (bool hasDevice);
async CreateMLSTransaction(Endpoint<PMLSTransactionParent> aEndpoint, nsIPrincipal aPrincipal);
// This method is used to propagate storage activities from the child actor
// to the parent actor. See StorageActivityService.
async StorageActivity(PrincipalInfo principalInfo);
async PServiceWorker(IPCServiceWorkerDescriptor aDescriptor);
async PRemoteWorkerController(RemoteWorkerData aData);
async PServiceWorkerContainer();
// Allows a global to listen for updates to a ServiceWorkerRegistration given
// receipt of a (static) snapshot via the descriptor. `aForClient` identifies
// the global subscribing; in the future this will be mooted by Bug 1853706
// having this actor managed by an actor explicitly tied to a global.
async PServiceWorkerRegistration(IPCServiceWorkerRegistrationDescriptor aDescriptor,
IPCClientInfo aForClient);
async PEndpointForReport(nsString aGroupName, PrincipalInfo aPrincipalInfo);
async RemoveEndpoint(nsString aGroupName, nsCString aEndpointURL,
PrincipalInfo aPrincipalInfo);
async PIdleScheduler();
async EnsureRDDProcessAndCreateBridge()
returns (nsresult rv, Endpoint<PRemoteDecoderManagerChild> aEndpoint);
async EnsureUtilityProcessAndCreateBridge(RemoteDecodeIn aLocation)
returns (nsresult rv, Endpoint<PRemoteDecoderManagerChild> aEndpoint);
async PLockManager(nsIPrincipal aPrincipalInfo, nsID? aClientId);
async PFetch();
async RequestCameraAccess(bool aAllowPermissionRequest) returns (CamerasAccessStatus rv);
child:
async PCache();
async PCacheStreamControl();
};
} // namespace ipc
} // namespace mozilla
