зеркало из https://github.com/mozilla/gecko-dev.git
1213 строки
43 KiB
C++
1213 строки
43 KiB
C++
/* -*- Mode: C++; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 8 -*- */
|
|
/* vim: set sw=4 ts=8 et tw=80 ft=cpp : */
|
|
/* 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 PBackground;
|
|
include protocol PBrowser;
|
|
include protocol PClientOpenWindowOp;
|
|
include protocol PCompositorManager;
|
|
include protocol PContentBridge;
|
|
include protocol PContentPermissionRequest;
|
|
include protocol PCycleCollectWithLogs;
|
|
include protocol PPSMContentDownloader;
|
|
include protocol PExternalHelperApp;
|
|
include protocol PHandlerService;
|
|
include protocol PFileDescriptorSet;
|
|
include protocol PHal;
|
|
include protocol PHeapSnapshotTempFileHelper;
|
|
include protocol PProcessHangMonitor;
|
|
include protocol PImageBridge;
|
|
include protocol PIPCBlobInputStream;
|
|
include protocol PLoginReputation;
|
|
include protocol PMedia;
|
|
include protocol PNecko;
|
|
include protocol PStreamFilter;
|
|
include protocol PGMPContent;
|
|
include protocol PGMPService;
|
|
include protocol PPluginModule;
|
|
include protocol PGMP;
|
|
include protocol PPrinting;
|
|
include protocol PChildToParentStream;
|
|
include protocol PParentToChildStream;
|
|
include protocol POfflineCacheUpdate;
|
|
include protocol PRenderFrame;
|
|
include protocol PSpeechSynthesis;
|
|
include protocol PTestShell;
|
|
include protocol PJavaScript;
|
|
include protocol PRemoteSpellcheckEngine;
|
|
include protocol PWebBrowserPersistDocument;
|
|
include protocol PWebrtcGlobal;
|
|
include protocol PPresentation;
|
|
include protocol PURLClassifier;
|
|
include protocol PURLClassifierLocal;
|
|
include protocol PVRManager;
|
|
include protocol PVideoDecoderManager;
|
|
include protocol PProfiler;
|
|
include protocol PScriptCache;
|
|
include DOMTypes;
|
|
include JavaScriptTypes;
|
|
include IPCBlob;
|
|
include PTabContext;
|
|
include URIParams;
|
|
include PluginTypes;
|
|
include ProtocolTypes;
|
|
include PBackgroundSharedTypes;
|
|
include PContentPermission;
|
|
include ServiceWorkerConfiguration;
|
|
include GraphicsMessages;
|
|
include MemoryReportTypes;
|
|
include ClientIPCTypes;
|
|
include HangTypes;
|
|
|
|
// Workaround to prevent error if PContentChild.cpp & PContentBridgeParent.cpp
|
|
// are put into different UnifiedProtocolsXX.cpp files.
|
|
// XXX Remove this once bug 1069073 is fixed
|
|
include "mozilla/dom/PContentBridgeParent.h";
|
|
|
|
using refcounted class nsIDOMGeoPosition from "nsGeoPositionIPCSerialiser.h";
|
|
using refcounted class nsIAlertNotification from "mozilla/AlertNotificationIPCSerializer.h";
|
|
|
|
using struct ChromePackage from "mozilla/chrome/RegistryMessageUtils.h";
|
|
using struct SubstitutionMapping from "mozilla/chrome/RegistryMessageUtils.h";
|
|
using struct OverrideMapping from "mozilla/chrome/RegistryMessageUtils.h";
|
|
using base::ProcessId from "base/process.h";
|
|
using struct IPC::Permission from "mozilla/net/NeckoMessageUtils.h";
|
|
using class IPC::Principal from "mozilla/dom/PermissionMessageUtils.h";
|
|
using struct mozilla::null_t from "ipc/IPCMessageUtils.h";
|
|
using mozilla::a11y::IHandlerControlHolder from "mozilla/a11y/IPCTypes.h";
|
|
using mozilla::dom::NativeThreadId from "mozilla/dom/TabMessageUtils.h";
|
|
using mozilla::hal::ProcessPriority from "mozilla/HalTypes.h";
|
|
using mozilla::gfx::IntSize from "mozilla/gfx/2D.h";
|
|
using mozilla::dom::TabId from "mozilla/dom/ipc/IdType.h";
|
|
using mozilla::dom::ContentParentId from "mozilla/dom/ipc/IdType.h";
|
|
using mozilla::LayoutDeviceIntPoint from "Units.h";
|
|
using struct LookAndFeelInt from "mozilla/widget/WidgetMessageUtils.h";
|
|
using class mozilla::dom::MessagePort from "mozilla/dom/MessagePort.h";
|
|
using class mozilla::dom::ipc::StructuredCloneData from "mozilla/dom/ipc/StructuredCloneData.h";
|
|
using mozilla::DataStorageType from "ipc/DataStorageIPCUtils.h";
|
|
using mozilla::OriginAttributes from "mozilla/ipc/BackgroundUtils.h";
|
|
using struct mozilla::layers::TextureFactoryIdentifier from "mozilla/layers/CompositorTypes.h";
|
|
using mozilla::layers::CompositorOptions from "mozilla/layers/CompositorOptions.h";
|
|
using mozilla::layers::LayersId from "mozilla/layers/LayersTypes.h";
|
|
using mozilla::Telemetry::HistogramAccumulation from "mozilla/TelemetryComms.h";
|
|
using mozilla::Telemetry::KeyedHistogramAccumulation from "mozilla/TelemetryComms.h";
|
|
using mozilla::Telemetry::ScalarAction from "mozilla/TelemetryComms.h";
|
|
using mozilla::Telemetry::KeyedScalarAction from "mozilla/TelemetryComms.h";
|
|
using mozilla::Telemetry::DynamicScalarDefinition from "mozilla/TelemetryComms.h";
|
|
using mozilla::Telemetry::ChildEventData from "mozilla/TelemetryComms.h";
|
|
using mozilla::Telemetry::DiscardedData from "mozilla/TelemetryComms.h";
|
|
using mozilla::CrossProcessMutexHandle from "mozilla/ipc/CrossProcessMutex.h";
|
|
using refcounted class nsIInputStream from "mozilla/ipc/IPCStreamUtils.h";
|
|
using mozilla::dom::BrowsingContextId from "mozilla/dom/ipc/IdType.h";
|
|
|
|
union ChromeRegistryItem
|
|
{
|
|
ChromePackage;
|
|
OverrideMapping;
|
|
SubstitutionMapping;
|
|
};
|
|
|
|
namespace mozilla {
|
|
namespace dom {
|
|
|
|
// Used on Android/B2G to pass the list of fonts on the device
|
|
// to the child process
|
|
struct FontListEntry {
|
|
nsCString familyName;
|
|
nsCString faceName;
|
|
nsCString filepath;
|
|
uint32_t weightRange;
|
|
uint32_t stretchRange;
|
|
uint32_t styleRange;
|
|
uint8_t index;
|
|
};
|
|
|
|
// Used on Mac OS X to pass the list of font families (not faces)
|
|
// from chrome to content processes.
|
|
// The entryType field distinguishes several types of font family
|
|
// record; see gfxMacPlatformFontList.h for values and meaning.
|
|
struct FontFamilyListEntry {
|
|
nsCString familyName;
|
|
uint8_t entryType;
|
|
};
|
|
|
|
// Used on Linux to pass list of font patterns from chrome to content.
|
|
struct FontPatternListEntry {
|
|
nsCString pattern;
|
|
bool appFontFamily;
|
|
};
|
|
|
|
// Wrap the Font*ListEntry records in a union so the SetXPCOMProcessAttributes
|
|
// message can pass an array of either type.
|
|
union SystemFontListEntry {
|
|
FontFamilyListEntry;
|
|
FontPatternListEntry;
|
|
};
|
|
|
|
union PrefValue {
|
|
nsCString;
|
|
int32_t;
|
|
bool;
|
|
};
|
|
|
|
union MaybePrefValue {
|
|
PrefValue;
|
|
null_t;
|
|
};
|
|
|
|
// This serialization form mirrors that used in mozilla::Pref in
|
|
// Preferences.cpp. The two should be kept in sync, e.g. if something is added
|
|
// to one it should also be added to the other.
|
|
//
|
|
// Note: there is no need to pass the isSticky attribute because that's an
|
|
// immutable attribute obtained from file at startup.
|
|
struct Pref {
|
|
nsCString name;
|
|
bool isLocked;
|
|
MaybePrefValue defaultValue;
|
|
MaybePrefValue userValue;
|
|
};
|
|
|
|
struct DataStorageItem {
|
|
nsCString key;
|
|
nsCString value;
|
|
DataStorageType type;
|
|
};
|
|
|
|
struct DataStorageEntry {
|
|
DataStorageItem[] items;
|
|
nsString filename;
|
|
};
|
|
|
|
struct ClipboardCapabilities {
|
|
bool supportsSelectionClipboard;
|
|
bool supportsFindClipboard;
|
|
};
|
|
|
|
union FileDescOrError {
|
|
FileDescriptor;
|
|
nsresult;
|
|
};
|
|
|
|
struct DomainPolicyClone
|
|
{
|
|
bool active;
|
|
URIParams[] blacklist;
|
|
URIParams[] whitelist;
|
|
URIParams[] superBlacklist;
|
|
URIParams[] superWhitelist;
|
|
};
|
|
|
|
struct AndroidSystemInfo
|
|
{
|
|
nsString device;
|
|
nsString manufacturer;
|
|
nsString release_version;
|
|
nsString hardware;
|
|
uint32_t sdk_version;
|
|
bool isTablet;
|
|
};
|
|
|
|
struct GetFilesResponseSuccess
|
|
{
|
|
IPCBlob[] blobs;
|
|
};
|
|
|
|
struct GetFilesResponseFailure
|
|
{
|
|
nsresult errorCode;
|
|
};
|
|
|
|
union GetFilesResponseResult
|
|
{
|
|
GetFilesResponseSuccess;
|
|
GetFilesResponseFailure;
|
|
};
|
|
|
|
struct FileCreationSuccessResult
|
|
{
|
|
IPCBlob blob;
|
|
};
|
|
|
|
struct FileCreationErrorResult
|
|
{
|
|
nsresult errorCode;
|
|
};
|
|
|
|
union FileCreationResult
|
|
{
|
|
FileCreationSuccessResult;
|
|
FileCreationErrorResult;
|
|
};
|
|
|
|
struct BlobURLRegistrationData
|
|
{
|
|
nsCString url;
|
|
IPCBlob blob;
|
|
Principal principal;
|
|
bool revoked;
|
|
};
|
|
|
|
struct GMPAPITags
|
|
{
|
|
nsCString api;
|
|
nsCString[] tags;
|
|
};
|
|
|
|
struct GMPCapabilityData
|
|
{
|
|
nsCString name;
|
|
nsCString version;
|
|
GMPAPITags[] capabilities;
|
|
};
|
|
|
|
struct GfxInfoFeatureStatus
|
|
{
|
|
int32_t feature;
|
|
int32_t status;
|
|
nsCString failureId;
|
|
};
|
|
|
|
struct XPCOMInitData
|
|
{
|
|
bool isOffline;
|
|
bool isConnected;
|
|
int32_t captivePortalState;
|
|
bool isLangRTL;
|
|
bool haveBidiKeyboards;
|
|
nsString[] dictionaries;
|
|
ClipboardCapabilities clipboardCaps;
|
|
DomainPolicyClone domainPolicy;
|
|
OptionalURIParams userContentSheetURL;
|
|
GfxVarUpdate[] gfxNonDefaultVarUpdates;
|
|
ContentDeviceData contentDeviceData;
|
|
GfxInfoFeatureStatus[] gfxFeatureStatus;
|
|
DataStorageEntry[] dataStorage;
|
|
nsCString[] appLocales;
|
|
nsCString[] requestedLocales;
|
|
DynamicScalarDefinition[] dynamicScalarDefs;
|
|
};
|
|
|
|
struct StringBundleDescriptor
|
|
{
|
|
nsCString bundleURL;
|
|
FileDescriptor mapFile;
|
|
uint32_t mapSize;
|
|
};
|
|
|
|
/**
|
|
* The PContent protocol is a top-level protocol between the UI process
|
|
* and a content process. There is exactly one PContentParent/PContentChild pair
|
|
* for each content process.
|
|
*/
|
|
nested(upto inside_cpow) sync protocol PContent
|
|
{
|
|
manages PBrowser;
|
|
manages PClientOpenWindowOp;
|
|
manages PContentPermissionRequest;
|
|
manages PCycleCollectWithLogs;
|
|
manages PPSMContentDownloader;
|
|
manages PExternalHelperApp;
|
|
manages PFileDescriptorSet;
|
|
manages PHal;
|
|
manages PHandlerService;
|
|
manages PHeapSnapshotTempFileHelper;
|
|
manages PIPCBlobInputStream;
|
|
manages PMedia;
|
|
manages PNecko;
|
|
manages POfflineCacheUpdate;
|
|
manages PPrinting;
|
|
manages PChildToParentStream;
|
|
manages PParentToChildStream;
|
|
manages PSpeechSynthesis;
|
|
manages PTestShell;
|
|
manages PJavaScript;
|
|
manages PRemoteSpellcheckEngine;
|
|
manages PWebBrowserPersistDocument;
|
|
manages PWebrtcGlobal;
|
|
manages PPresentation;
|
|
manages PURLClassifier;
|
|
manages PURLClassifierLocal;
|
|
manages PScriptCache;
|
|
manages PLoginReputation;
|
|
|
|
both:
|
|
// Depending on exactly how the new browser is being created, it might be
|
|
// created from either the child or parent process!
|
|
//
|
|
// The child creates the PBrowser as part of
|
|
// TabChild::BrowserFrameProvideWindow (which happens when the child's
|
|
// content calls window.open()), and the parent creates the PBrowser as part
|
|
// of ContentParent::CreateBrowser.
|
|
//
|
|
// When the parent constructs a PBrowser, the child trusts the attributes it
|
|
// receives from the parent. In that case, the context should be
|
|
// FrameIPCTabContext.
|
|
//
|
|
// When the child constructs a PBrowser, the parent doesn't trust the
|
|
// attributes it receives from the child. In this case, context must have
|
|
// type PopupIPCTabContext. The parent checks that if the opener is a
|
|
// browser element, the context is also for a browser element.
|
|
//
|
|
// If |sameTabGroupAs| is non-zero, the new tab should go in the same
|
|
// TabGroup as |sameTabGroupAs|. This parameter should always be zero
|
|
// for PBrowser messages sent from the child to the parent.
|
|
//
|
|
// Keep the last 3 attributes in sync with GetProcessAttributes!
|
|
async PBrowser(TabId tabId, TabId sameTabGroupAs,
|
|
IPCTabContext context, uint32_t chromeFlags,
|
|
ContentParentId cpId, bool isForBrowser);
|
|
|
|
async PFileDescriptorSet(FileDescriptor fd);
|
|
|
|
// For parent->child, aBrowser must be non-null; aOuterWindowID can
|
|
// be 0 to indicate the browser's current root document, or nonzero
|
|
// to persist a subdocument. For child->parent, arguments are
|
|
// ignored and should be null/zero.
|
|
async PWebBrowserPersistDocument(nullable PBrowser aBrowser,
|
|
uint64_t aOuterWindowID);
|
|
|
|
child:
|
|
async InitGMPService(Endpoint<PGMPServiceChild> service);
|
|
async InitProcessHangMonitor(Endpoint<PProcessHangMonitorChild> hangMonitor);
|
|
async InitContentBridgeChild(Endpoint<PContentBridgeChild> endpoint);
|
|
async InitProfiler(Endpoint<PProfilerChild> aEndpoint);
|
|
|
|
// Give the content process its endpoints to the compositor.
|
|
async InitRendering(
|
|
Endpoint<PCompositorManagerChild> compositor,
|
|
Endpoint<PImageBridgeChild> imageBridge,
|
|
Endpoint<PVRManagerChild> vr,
|
|
Endpoint<PVideoDecoderManagerChild> video,
|
|
uint32_t[] namespaces);
|
|
|
|
// Re-create the rendering stack using the given endpoints. This is sent
|
|
// after the compositor process has crashed. The new endpoints may be to a
|
|
// newly launched GPU process, or the compositor thread of the UI process.
|
|
async ReinitRendering(
|
|
Endpoint<PCompositorManagerChild> compositor,
|
|
Endpoint<PImageBridgeChild> bridge,
|
|
Endpoint<PVRManagerChild> vr,
|
|
Endpoint<PVideoDecoderManagerChild> video,
|
|
uint32_t[] namespaces);
|
|
|
|
async AudioDefaultDeviceChange();
|
|
|
|
// Re-create the rendering stack for a device reset.
|
|
async ReinitRenderingForDeviceReset();
|
|
|
|
/**
|
|
* Enable system-level sandboxing features, if available. Can
|
|
* usually only be performed zero or one times. The child may
|
|
* abnormally exit if this fails; the details are OS-specific.
|
|
*/
|
|
async SetProcessSandbox(MaybeFileDesc aBroker);
|
|
|
|
async RequestMemoryReport(uint32_t generation,
|
|
bool anonymize,
|
|
bool minimizeMemoryUsage,
|
|
MaybeFileDesc DMDFile);
|
|
async RequestPerformanceMetrics(nsID aID);
|
|
|
|
/**
|
|
* Communication between the PuppetBidiKeyboard and the actual
|
|
* BidiKeyboard hosted by the parent
|
|
*/
|
|
async BidiKeyboardNotify(bool isLangRTL, bool haveBidiKeyboards);
|
|
|
|
/**
|
|
* Dump this process's GC and CC logs to the provided files.
|
|
*
|
|
* For documentation on the other args, see dumpGCAndCCLogsToFile in
|
|
* nsIMemoryInfoDumper.idl
|
|
*/
|
|
async PCycleCollectWithLogs(bool dumpAllTraces,
|
|
FileDescriptor gcLog,
|
|
FileDescriptor ccLog);
|
|
|
|
async PTestShell();
|
|
|
|
async PScriptCache(FileDescOrError cacheFile, bool wantCacheData);
|
|
|
|
async RegisterChrome(ChromePackage[] packages, SubstitutionMapping[] substitutions,
|
|
OverrideMapping[] overrides, nsCString locale, bool reset);
|
|
async RegisterChromeItem(ChromeRegistryItem item);
|
|
|
|
async ClearImageCache(bool privateLoader, bool chrome);
|
|
|
|
async SetOffline(bool offline);
|
|
async SetConnectivity(bool connectivity);
|
|
async SetCaptivePortalState(int32_t aState);
|
|
|
|
async NotifyVisited(URIParams[] uri);
|
|
|
|
async PreferenceUpdate(Pref pref);
|
|
async VarUpdate(GfxVarUpdate var);
|
|
|
|
async DataStoragePut(nsString aFilename, DataStorageItem aItem);
|
|
async DataStorageRemove(nsString aFilename, nsCString aKey, DataStorageType aType);
|
|
async DataStorageClear(nsString aFilename);
|
|
|
|
async NotifyAlertsObserver(nsCString topic, nsString data);
|
|
|
|
async GeolocationUpdate(nsIDOMGeoPosition aPosition);
|
|
|
|
async GeolocationError(uint16_t errorCode);
|
|
|
|
async UpdateDictionaryList(nsString[] dictionaries);
|
|
|
|
async UpdateFontList(SystemFontListEntry[] fontList);
|
|
|
|
async UpdateAppLocales(nsCString[] appLocales);
|
|
async UpdateRequestedLocales(nsCString[] requestedLocales);
|
|
|
|
async ClearSiteDataReloadNeeded(nsString origin);
|
|
|
|
async RegisterStringBundles(StringBundleDescriptor[] stringBundles);
|
|
|
|
async UpdateSharedData(FileDescriptor mapFile, uint32_t aSize,
|
|
IPCBlob[] blobs,
|
|
nsCString[] changedKeys);
|
|
|
|
// nsIPermissionManager messages
|
|
async AddPermission(Permission permission);
|
|
async RemoveAllPermissions();
|
|
|
|
async FlushMemory(nsString reason);
|
|
|
|
async GarbageCollect();
|
|
async CycleCollect();
|
|
async UnlinkGhosts();
|
|
|
|
/**
|
|
* Start accessibility engine in content process.
|
|
* @param aTid is the thread ID of the chrome process main thread. Only used
|
|
* on Windows; pass 0 on other platforms.
|
|
* @param aMsaaID is an a11y-specific unique id for the content process
|
|
* that is generated by the chrome process. Only used on
|
|
* Windows; pass 0 on other platforms.
|
|
*/
|
|
async ActivateA11y(uint32_t aMainChromeTid, uint32_t aMsaaID);
|
|
|
|
/**
|
|
* Shutdown accessibility engine in content process (if not in use).
|
|
*/
|
|
async ShutdownA11y();
|
|
|
|
async AppInfo(nsCString version, nsCString buildID, nsCString name, nsCString UAName,
|
|
nsCString ID, nsCString vendor, nsCString sourceURL);
|
|
|
|
/**
|
|
* Send the remote type associated with the content process.
|
|
*/
|
|
async RemoteType(nsString aRemoteType);
|
|
|
|
/**
|
|
* Send ServiceWorkerRegistrationData to child process.
|
|
*/
|
|
async InitServiceWorkers(ServiceWorkerConfiguration aConfig);
|
|
|
|
/**
|
|
* Send BlobURLRegistrationData to child process.
|
|
*/
|
|
async InitBlobURLs(BlobURLRegistrationData[] registrations);
|
|
|
|
async SetXPCOMProcessAttributes(XPCOMInitData xpcomInit,
|
|
StructuredCloneData initialData,
|
|
LookAndFeelInt[] lookAndFeelIntCache,
|
|
/* used on MacOSX and Linux only: */
|
|
SystemFontListEntry[] systemFontList);
|
|
|
|
// Notify child that last-pb-context-exited notification was observed
|
|
async LastPrivateDocShellDestroyed();
|
|
|
|
async NotifyProcessPriorityChanged(ProcessPriority priority);
|
|
async MinimizeMemoryUsage();
|
|
|
|
/**
|
|
* Used to manage nsIStyleSheetService across processes.
|
|
*/
|
|
async LoadAndRegisterSheet(URIParams uri, uint32_t type);
|
|
async UnregisterSheet(URIParams uri, uint32_t type);
|
|
|
|
/**
|
|
* Notify idle observers in the child
|
|
*/
|
|
async NotifyIdleObserver(uint64_t observerId, nsCString topic, nsString str);
|
|
|
|
async InvokeDragSession(IPCDataTransfer[] transfers, uint32_t action);
|
|
|
|
async EndDragSession(bool aDoneDrag, bool aUserCancelled,
|
|
LayoutDeviceIntPoint aDragEndPoint,
|
|
uint32_t aKeyModifiers);
|
|
|
|
async DomainSetChanged(uint32_t aSetType, uint32_t aChangeType, OptionalURIParams aDomain);
|
|
|
|
/**
|
|
* Notify the child to shutdown. The child will in turn call FinishShutdown
|
|
* and let the parent close the channel.
|
|
*/
|
|
async Shutdown();
|
|
|
|
async LoadProcessScript(nsString url);
|
|
|
|
/**
|
|
* Requests a full native update of a native plugin child window. This is
|
|
* a Windows specific call.
|
|
*/
|
|
async UpdateWindow(uintptr_t aChildId);
|
|
|
|
/**
|
|
* Notify the child that presentation receiver has been launched with the
|
|
* correspondent iframe.
|
|
*/
|
|
async NotifyPresentationReceiverLaunched(PBrowser aIframe, nsString aSessionId);
|
|
|
|
/**
|
|
* Notify the child that the info about a presentation receiver needs to be
|
|
* cleaned up.
|
|
*/
|
|
async NotifyPresentationReceiverCleanUp(nsString aSessionId);
|
|
|
|
/**
|
|
* Notify the child that cache is emptied.
|
|
*/
|
|
async NotifyEmptyHTTPCache();
|
|
|
|
/**
|
|
* Send a `push` event without data to a service worker in the child.
|
|
*/
|
|
async Push(nsCString scope, Principal principal, nsString messageId);
|
|
|
|
/**
|
|
* Send a `push` event with data to a service worker in the child.
|
|
*/
|
|
async PushWithData(nsCString scope, Principal principal,
|
|
nsString messageId, uint8_t[] data);
|
|
|
|
/**
|
|
* Send a `pushsubscriptionchange` event to a service worker in the child.
|
|
*/
|
|
async PushSubscriptionChange(nsCString scope, Principal principal);
|
|
|
|
/**
|
|
* Send a Push error message to all service worker clients in the child.
|
|
*/
|
|
async PushError(nsCString scope, Principal principal, nsString message,
|
|
uint32_t flags);
|
|
|
|
/**
|
|
* Windows specific: associate this content process with the browsers
|
|
* audio session.
|
|
*/
|
|
async SetAudioSessionData(nsID aID,
|
|
nsString aDisplayName,
|
|
nsString aIconPath);
|
|
|
|
async GetFilesResponse(nsID aID, GetFilesResponseResult aResult);
|
|
|
|
async BlobURLRegistration(nsCString aURI, IPCBlob aBlob,
|
|
Principal aPrincipal);
|
|
|
|
async BlobURLUnregistration(nsCString aURI);
|
|
|
|
async GMPsChanged(GMPCapabilityData[] capabilities);
|
|
|
|
|
|
async FileCreationResponse(nsID aID, FileCreationResult aResult);
|
|
|
|
/**
|
|
* Sending an activate message moves focus to the child.
|
|
*/
|
|
async Activate(PBrowser aTab);
|
|
|
|
async Deactivate(PBrowser aTab);
|
|
|
|
async PParentToChildStream();
|
|
|
|
async ProvideAnonymousTemporaryFile(uint64_t aID, FileDescOrError aFD);
|
|
|
|
async SetPermissionsWithKey(nsCString aPermissionKey, Permission[] aPermissions);
|
|
|
|
async RefreshScreens(ScreenDetails[] aScreens);
|
|
|
|
async PIPCBlobInputStream(nsID aID, uint64_t aSize);
|
|
|
|
/**
|
|
* This call takes the set of plugins loaded in the chrome process, and
|
|
* sends them to the content process. However, in many cases this set will
|
|
* not have changed since the last SetPluginList message. To keep track of
|
|
* this, the chrome process increments an epoch number every time the set of
|
|
* plugins changes. The chrome process sends up the last epoch it observed.
|
|
* If the epoch last seen by the content process is the same, the content
|
|
* process ignores the update. Otherwise the content process updates its
|
|
* list and reloads its plugins.
|
|
**/
|
|
async SetPluginList(uint32_t pluginEpoch, PluginTag[] plugins, FakePluginTag[] fakePlugins);
|
|
|
|
async ShareCodeCoverageMutex(CrossProcessMutexHandle handle);
|
|
async DumpCodeCoverageCounters() returns (bool unused);
|
|
async ResetCodeCoverageCounters() returns (bool unused);
|
|
|
|
/*
|
|
* IPC message to enable the input event queue on the main thread of the
|
|
* content process.
|
|
*/
|
|
async SetInputEventQueueEnabled();
|
|
|
|
/*
|
|
* IPC message to flush the input event queue on the main thread of the
|
|
* content process.
|
|
*
|
|
* When the ContentParent stops sending the input event with input priority,
|
|
* there may be some pending events in the input event queue and normal
|
|
* event queue. Here is a possible scenario.
|
|
* R: Runnables.
|
|
* D: Enable the input priority event.
|
|
* E: Disable the input priority evnet.
|
|
*
|
|
* D E
|
|
* Normal Queue: R1 R2 R3
|
|
* Input Queue: II I2 I3
|
|
*
|
|
* To avoid the newly added normal events (e.g. R2, which may be an input
|
|
* event) preempt the pending input events (e.g. I1), or the newly added
|
|
* input events (e.g. I3) preempt the pending normal events (e.g. R2), we
|
|
* have to flush all pending events before enabling and disabling the input
|
|
* priority event.
|
|
*
|
|
* To flush the normal event queue and the input event queue, we use three
|
|
* IPC messages as the followings.
|
|
* FI: Flush the input queue.
|
|
* SI: Suspend the input queue.
|
|
* RI: Resume the input queue.
|
|
*
|
|
* Normal Queue: R1 FI RI R2 FI RI R3
|
|
* Input Queue: II SI I2 SI I3
|
|
*
|
|
* When the flush input request is processed before the other two requests,
|
|
* we consume all input events until the suspend request. After handling the
|
|
* suspend request, we stop consuming the input events until the resume
|
|
* request to make sure we consume all pending normal events.
|
|
*
|
|
* If we process the suspend request before the other two requests, we
|
|
* ignore the flush request and consume all pending normal events until the
|
|
* resume request.
|
|
*/
|
|
async FlushInputEventQueue();
|
|
|
|
/*
|
|
* IPC message to resume consuming the pending events in the input event
|
|
* queue.
|
|
*/
|
|
async ResumeInputEventQueue();
|
|
|
|
/*
|
|
* IPC message to suspend consuming the pending events in the input event
|
|
* queue.
|
|
*/
|
|
prio(input) async SuspendInputEventQueue();
|
|
|
|
/*
|
|
* IPC message to propagate dynamic scalar definitions, added after the
|
|
* content process is spawned, from the parent to the child.
|
|
* Dynamic scalar definitions added at the process startup are handled
|
|
* using the |TelemetryIPC::AddDynamicScalarDefinitions| functions.
|
|
*/
|
|
async AddDynamicScalars(DynamicScalarDefinition[] definitions);
|
|
|
|
/*
|
|
* Message to construct a PClientOpenWindowOp actor. This is used to
|
|
* open windows cross-process and receive notification when the operation
|
|
* has completed.
|
|
*/
|
|
async PClientOpenWindowOp(ClientOpenWindowArgs aArgs);
|
|
|
|
/* Save the execution up to the current point in a recording process. */
|
|
async SaveRecording(FileDescriptor file);
|
|
|
|
parent:
|
|
async InitBackground(Endpoint<PBackgroundParent> aEndpoint);
|
|
|
|
sync CreateChildProcess(IPCTabContext context,
|
|
ProcessPriority priority,
|
|
TabId openerTabId,
|
|
TabId tabId)
|
|
returns (ContentParentId cpId, bool isForBrowser);
|
|
sync BridgeToChildProcess(ContentParentId cpId)
|
|
returns (Endpoint<PContentBridgeParent> endpoint);
|
|
|
|
sync OpenRecordReplayChannel(uint32_t channelId)
|
|
returns (FileDescriptor connection);
|
|
async CreateReplayingProcess(uint32_t channelId);
|
|
async TerminateReplayingProcess(uint32_t channelId);
|
|
|
|
async CreateGMPService();
|
|
|
|
async InitStreamFilter(uint64_t channelId, nsString addonId)
|
|
returns (Endpoint<PStreamFilterChild> aEndpoint);
|
|
|
|
/**
|
|
* This call connects the content process to a plugin process. This call
|
|
* returns an endpoint for a new PluginModuleParent. The corresponding
|
|
* PluginModuleChild will be started up in the plugin process.
|
|
*/
|
|
sync LoadPlugin(uint32_t aPluginId)
|
|
returns (nsresult aResult, uint32_t aRunID, Endpoint<PPluginModuleParent> aEndpoint);
|
|
|
|
/**
|
|
* This call is used by asynchronous plugin instantiation to notify the
|
|
* content parent that it is now safe to initiate the plugin bridge for
|
|
* the specified plugin id. The endpoint for the content process part of the
|
|
* bridge is returned.
|
|
*/
|
|
sync ConnectPluginBridge(uint32_t aPluginId)
|
|
returns (nsresult rv, Endpoint<PPluginModuleParent> aEndpoint);
|
|
|
|
async PJavaScript();
|
|
|
|
async PRemoteSpellcheckEngine();
|
|
|
|
async InitCrashReporter(Shmem shmem, NativeThreadId tid);
|
|
|
|
sync IsSecureURI(uint32_t aType, URIParams aURI, uint32_t aFlags,
|
|
OriginAttributes aOriginAttributes)
|
|
returns (bool isSecureURI);
|
|
|
|
async AccumulateMixedContentHSTS(URIParams aURI, bool aActive,
|
|
OriginAttributes aOriginAttributes);
|
|
|
|
nested(inside_cpow) async PHal();
|
|
|
|
async PHeapSnapshotTempFileHelper();
|
|
|
|
async PNecko();
|
|
|
|
async PPrinting();
|
|
|
|
async PChildToParentStream();
|
|
|
|
async PSpeechSynthesis();
|
|
|
|
async PMedia();
|
|
|
|
async PWebrtcGlobal();
|
|
|
|
async PPresentation();
|
|
|
|
async CreateAudioIPCConnection() returns (FileDescriptor fd);
|
|
|
|
sync PURLClassifier(Principal principal, bool useTrackingProtection)
|
|
returns (bool success);
|
|
sync ClassifyLocal(URIParams uri, nsCString tables)
|
|
returns (nsresult rv, nsCString[] results);
|
|
// The async version of ClassifyLocal.
|
|
async PURLClassifierLocal(URIParams uri, nsCString tables);
|
|
|
|
async PLoginReputation(URIParams formURI);
|
|
|
|
// Services remoting
|
|
|
|
async StartVisitedQuery(URIParams uri);
|
|
async VisitURI(URIParams uri, OptionalURIParams referrer, uint32_t flags);
|
|
async SetURITitle(URIParams uri, nsString title);
|
|
|
|
async LoadURIExternal(URIParams uri, PBrowser windowContext);
|
|
async ExtProtocolChannelConnectParent(uint32_t registrarId);
|
|
|
|
// PrefService message
|
|
sync GetGfxVars() returns (GfxVarUpdate[] vars);
|
|
|
|
sync ReadFontList() returns (FontListEntry[] retValue);
|
|
|
|
sync SyncMessage(nsString aMessage, ClonedMessageData aData,
|
|
CpowEntry[] aCpows, Principal aPrincipal)
|
|
returns (StructuredCloneData[] retval);
|
|
|
|
nested(inside_sync) sync RpcMessage(nsString aMessage, ClonedMessageData aData,
|
|
CpowEntry[] aCpows, Principal aPrincipal)
|
|
returns (StructuredCloneData[] retval);
|
|
|
|
async ShowAlert(nsIAlertNotification alert);
|
|
|
|
async CloseAlert(nsString name, Principal principal);
|
|
|
|
async DisableNotifications(Principal principal);
|
|
|
|
async OpenNotificationSettings(Principal principal);
|
|
|
|
async PPSMContentDownloader(uint32_t aCertType);
|
|
|
|
async PExternalHelperApp(OptionalURIParams uri,
|
|
nsCString aMimeContentType,
|
|
nsCString aContentDisposition,
|
|
uint32_t aContentDispositionHint,
|
|
nsString aContentDispositionFilename,
|
|
bool aForceSave,
|
|
int64_t aContentLength,
|
|
bool aWasFileChannel,
|
|
OptionalURIParams aReferrer,
|
|
nullable PBrowser aBrowser);
|
|
|
|
async PHandlerService();
|
|
|
|
async AddGeolocationListener(Principal principal, bool highAccuracy);
|
|
async RemoveGeolocationListener();
|
|
async SetGeolocationHigherAccuracy(bool enable);
|
|
|
|
async ConsoleMessage(nsString message);
|
|
async ScriptError(nsString message, nsString sourceName, nsString sourceLine,
|
|
uint32_t lineNumber, uint32_t colNumber, uint32_t flags,
|
|
nsCString category, bool privateWindow);
|
|
async ScriptErrorWithStack(nsString message, nsString sourceName, nsString sourceLine,
|
|
uint32_t lineNumber, uint32_t colNumber, uint32_t flags,
|
|
nsCString category, bool privateWindow,
|
|
ClonedMessageData stack);
|
|
|
|
// Places the items within dataTransfer on the clipboard.
|
|
async SetClipboard(IPCDataTransfer aDataTransfer,
|
|
bool aIsPrivateData,
|
|
Principal aRequestingPrincipal,
|
|
uint32_t aContentPolicyType,
|
|
int32_t aWhichClipboard);
|
|
|
|
// Given a list of supported types, returns the clipboard data for the
|
|
// first type that matches.
|
|
sync GetClipboard(nsCString[] aTypes, int32_t aWhichClipboard)
|
|
returns (IPCDataTransfer dataTransfer);
|
|
|
|
// Returns a list of formats supported by the clipboard
|
|
sync GetExternalClipboardFormats(int32_t aWhichClipboard, bool aPlainTextOnly) returns (nsCString[] aTypes);
|
|
|
|
// Clears the clipboard.
|
|
async EmptyClipboard(int32_t aWhichClipboard);
|
|
|
|
// Returns true if data of one of the specified types is on the clipboard.
|
|
sync ClipboardHasType(nsCString[] aTypes, int32_t aWhichClipboard)
|
|
returns (bool hasType);
|
|
|
|
// 'Play', 'Beep' and 'PlayEventSound' are the only nsISound methods used in
|
|
// the content process.
|
|
async PlaySound(URIParams aURL) compress;
|
|
async Beep() compress;
|
|
async PlayEventSound(uint32_t aEventId) compress;
|
|
|
|
sync GetSystemColors(uint32_t colorsCount)
|
|
returns (uint32_t[] colors);
|
|
|
|
sync GetIconForExtension(nsCString aFileExt, uint32_t aIconSize)
|
|
returns (uint8_t[] bits);
|
|
|
|
sync GetShowPasswordSetting()
|
|
returns (bool showPassword);
|
|
|
|
// Notify the parent of the presence or absence of private docshells
|
|
async PrivateDocShellsExist(bool aExist);
|
|
|
|
// Tell the parent that the child has gone idle for the first time.
|
|
async FirstIdle();
|
|
|
|
async DeviceReset();
|
|
|
|
sync KeywordToURI(nsCString keyword)
|
|
returns (nsString providerName, nsIInputStream postData, OptionalURIParams uri);
|
|
|
|
sync NotifyKeywordSearchLoading(nsString providerName, nsString keyword);
|
|
|
|
async CopyFavicon(URIParams oldURI, URIParams newURI, Principal aLoadingPrincipal, bool isPrivate);
|
|
|
|
// Tell the compositor to allocate a layer tree id for nested remote mozbrowsers.
|
|
sync AllocateLayerTreeId(ContentParentId cpId, TabId tabId)
|
|
returns (LayersId id);
|
|
async DeallocateLayerTreeId(ContentParentId cpId, LayersId id);
|
|
|
|
/**
|
|
* Notifies the parent about a recording device is starting or shutdown.
|
|
* @param recordingStatus starting or shutdown
|
|
* @param pageURL URL that request that changing the recording status
|
|
* @param isAudio recording start with microphone
|
|
* @param isVideo recording start with camera
|
|
*/
|
|
async RecordingDeviceEvents(nsString recordingStatus,
|
|
nsString pageURL,
|
|
bool isAudio,
|
|
bool isVideo);
|
|
|
|
// Graphics errors
|
|
async GraphicsError(nsCString aError);
|
|
|
|
// Driver crash guards. aGuardType must be a member of CrashGuardType.
|
|
sync BeginDriverCrashGuard(uint32_t aGuardType) returns (bool crashDetected);
|
|
sync EndDriverCrashGuard(uint32_t aGuardType);
|
|
|
|
async AddIdleObserver(uint64_t observerId, uint32_t idleTimeInS);
|
|
async RemoveIdleObserver(uint64_t observerId, uint32_t idleTimeInS);
|
|
|
|
/**
|
|
* This message is only used on X11 platforms.
|
|
*
|
|
* Send a dup of the plugin process's X socket to the parent
|
|
* process. In theory, this scheme keeps the plugin's X resources
|
|
* around until after both the plugin process shuts down *and* the
|
|
* parent process closes the dup fd. This is used to prevent the
|
|
* parent process from crashing on X errors if, e.g., the plugin
|
|
* crashes *just before* a repaint and the parent process tries to
|
|
* use the newly-invalid surface.
|
|
*/
|
|
async BackUpXResources(FileDescriptor aXSocketFd);
|
|
|
|
async RequestAnonymousTemporaryFile(uint64_t aID);
|
|
|
|
/**
|
|
* Keygen requires us to call it after a <keygen> element is parsed and
|
|
* before one is submitted. This is urgent because an extension might use
|
|
* a CPOW to synchronously submit a keygen element.
|
|
*/
|
|
nested(inside_cpow) sync KeygenProcessValue(nsString oldValue,
|
|
nsString challenge,
|
|
nsString keytype,
|
|
nsString keyparams)
|
|
returns (nsString newValue);
|
|
|
|
/**
|
|
* Called to provide the options for <keygen> elements.
|
|
*/
|
|
sync KeygenProvideContent()
|
|
returns (nsString aAttribute, nsString[] aContent);
|
|
|
|
/** Clear RemoteFrameInfo of the given tab id. */
|
|
async UnregisterRemoteFrame(TabId tabId,
|
|
ContentParentId cpId,
|
|
bool aMarkedDestroying);
|
|
|
|
/**
|
|
* Tell the chrome process there is a destruction of PBrowser(Tab)
|
|
*/
|
|
async NotifyTabDestroying(TabId tabId,
|
|
ContentParentId cpId);
|
|
/**
|
|
* Starts an offline application cache update.
|
|
* @param manifestURI
|
|
* URI of the manifest to fetch, the application cache group ID
|
|
* @param documentURI
|
|
* URI of the document that referred the manifest
|
|
* @param loadingPrincipal
|
|
* Principal of the document that referred the manifest
|
|
* @param stickDocument
|
|
* True if the update was initiated by a document load that referred
|
|
* a manifest.
|
|
* False if the update was initiated by applicationCache.update() call.
|
|
*
|
|
* Tells the update to carry the documentURI to a potential separate
|
|
* update of implicit (master) items.
|
|
*
|
|
* Why this argument? If the document was not found in an offline cache
|
|
* before load and refers a manifest and this manifest itself has not
|
|
* been changed since the last fetch, we will not do the application
|
|
* cache group update. But we must cache the document (identified by the
|
|
* documentURI). This argument will ensure that a previously uncached
|
|
* document will get cached and that we don't re-cache a document that
|
|
* has already been cached (stickDocument=false).
|
|
* @param tabId
|
|
* To identify which tab owns the app.
|
|
*/
|
|
async POfflineCacheUpdate(URIParams manifestURI, URIParams documentURI,
|
|
PrincipalInfo loadingPrincipal, bool stickDocument);
|
|
|
|
/**
|
|
* Sets "offline-app" permission for the principal. Called when we hit
|
|
* a web app with the manifest attribute in <html> and
|
|
* offline-apps.allow_by_default is set to true.
|
|
*/
|
|
async SetOfflinePermission(Principal principal);
|
|
|
|
/**
|
|
* Notifies the parent to continue shutting down after the child performs
|
|
* its shutdown tasks.
|
|
*/
|
|
async FinishShutdown();
|
|
|
|
async UpdateDropEffect(uint32_t aDragAction, uint32_t aDropEffect);
|
|
|
|
/**
|
|
* Initiates an asynchronous request for permission for the
|
|
* provided principal.
|
|
*
|
|
* @param aRequests
|
|
* The array of permissions to request.
|
|
* @param aPrincipal
|
|
* The principal of the request.
|
|
* @param tabId
|
|
* To identify which tab issues this request.
|
|
*
|
|
* NOTE: The principal is untrusted in the parent process. Only
|
|
* principals that can live in the content process should
|
|
* provided.
|
|
*/
|
|
async PContentPermissionRequest(PermissionRequest[] aRequests, Principal aPrincipal,
|
|
bool aIsHandlingUserInput, TabId tabId);
|
|
|
|
async ShutdownProfile(nsCString aProfile);
|
|
|
|
/**
|
|
* Request graphics initialization information from the parent.
|
|
*/
|
|
sync GetGraphicsDeviceInitData()
|
|
returns (ContentDeviceData aData);
|
|
|
|
async CreateWindow(nullable PBrowser aThisTab,
|
|
PBrowser aNewTab,
|
|
PRenderFrame aRenderFrame,
|
|
uint32_t aChromeFlags,
|
|
bool aCalledFromJS,
|
|
bool aPositionSpecified,
|
|
bool aSizeSpecified,
|
|
OptionalURIParams aURIToLoad,
|
|
nsCString aFeatures,
|
|
nsCString aBaseURI,
|
|
float aFullZoom,
|
|
Principal aTriggeringPrincipal,
|
|
uint32_t aReferrerPolicy)
|
|
returns (CreatedWindowInfo window);
|
|
|
|
async CreateWindowInDifferentProcess(
|
|
PBrowser aThisTab,
|
|
uint32_t aChromeFlags,
|
|
bool aCalledFromJS,
|
|
bool aPositionSpecified,
|
|
bool aSizeSpecified,
|
|
OptionalURIParams aURIToLoad,
|
|
nsCString aFeatures,
|
|
nsCString aBaseURI,
|
|
float aFullZoom,
|
|
nsString aName,
|
|
Principal aTriggeringPrincipal,
|
|
uint32_t aReferrerPolicy);
|
|
|
|
sync GetAndroidSystemInfo()
|
|
returns (AndroidSystemInfo info);
|
|
|
|
/**
|
|
* Tells the parent to ungrab the pointer on the default display.
|
|
*
|
|
* This is for GTK platforms where we have to ensure the pointer ungrab happens in the
|
|
* chrome process as that's the process that receives the pointer event.
|
|
*/
|
|
sync UngrabPointer(uint32_t time);
|
|
|
|
sync RemovePermission(Principal principal, nsCString permissionType) returns (nsresult rv);
|
|
|
|
/**
|
|
* Tell the parent that a decoder's' benchmark has been completed.
|
|
* The result can then be stored in permanent storage.
|
|
*/
|
|
async NotifyBenchmarkResult(nsString aCodecName, uint32_t aDecodeFPS);
|
|
|
|
/**
|
|
* Notify `push-message` observers without data in the parent.
|
|
*/
|
|
async NotifyPushObservers(nsCString scope, Principal principal,
|
|
nsString messageId);
|
|
|
|
/**
|
|
* Notify `push-message` observers with data in the parent.
|
|
*/
|
|
async NotifyPushObserversWithData(nsCString scope, Principal principal,
|
|
nsString messageId, uint8_t[] data);
|
|
|
|
/**
|
|
* Notify `push-subscription-change` observers in the parent.
|
|
*/
|
|
async NotifyPushSubscriptionChangeObservers(nsCString scope,
|
|
Principal principal);
|
|
|
|
async GetFilesRequest(nsID aID, nsString aDirectory, bool aRecursiveFlag);
|
|
async DeleteGetFilesRequest(nsID aID);
|
|
|
|
async FileCreationRequest(nsID aID, nsString aFullPath, nsString aType,
|
|
nsString aName, bool lastModifiedPassed,
|
|
int64_t lastModified, bool aExistenceCheck,
|
|
bool aIsFromNsIFile);
|
|
|
|
async StoreAndBroadcastBlobURLRegistration(nsCString url, IPCBlob blob,
|
|
Principal principal);
|
|
|
|
async UnstoreAndBroadcastBlobURLUnregistration(nsCString url);
|
|
|
|
/**
|
|
* Messages for communicating child Telemetry to the parent process
|
|
*/
|
|
async AccumulateChildHistograms(HistogramAccumulation[] accumulations);
|
|
async AccumulateChildKeyedHistograms(KeyedHistogramAccumulation[] accumulations);
|
|
async UpdateChildScalars(ScalarAction[] updates);
|
|
async UpdateChildKeyedScalars(KeyedScalarAction[] updates);
|
|
async RecordChildEvents(ChildEventData[] events);
|
|
async RecordDiscardedData(DiscardedData data);
|
|
|
|
sync GetA11yContentId() returns (uint32_t aContentId);
|
|
async A11yHandlerControl(uint32_t aPid,
|
|
IHandlerControlHolder aHandlerControl);
|
|
|
|
async AddMemoryReport(MemoryReport aReport);
|
|
async FinishMemoryReport(uint32_t aGeneration);
|
|
|
|
async MaybeReloadPlugins();
|
|
|
|
async BHRThreadHang(HangDetails aHangDetails);
|
|
|
|
async AddPerformanceMetrics(nsID aID, PerformanceInfo[] aMetrics);
|
|
|
|
/*
|
|
* A 3rd party tracking origin (aTrackingOrigin) has received the permission
|
|
* granted to have access to aGrantedOrigin when loaded by aParentPrincipal.
|
|
*/
|
|
async FirstPartyStorageAccessGrantedForOrigin(Principal aParentPrincipal,
|
|
nsCString aTrackingOrigin,
|
|
nsCString aGrantedOrigin)
|
|
returns (bool unused);
|
|
|
|
/**
|
|
* Sync the BrowsingContext with id 'aContextId' and name 'aName'
|
|
* to the parent, and attach it to the BrowsingContext with id
|
|
* 'aParentContextId'. If 'aParentContextId' is '0' the
|
|
* BrowsingContext is a root in the BrowsingContext
|
|
* tree. AttachBrowsingContext must only be called at most once
|
|
* for any child BrowsingContext, and only for BrowsingContexts
|
|
* where the parent and the child context contains their
|
|
* nsDocShell.
|
|
*/
|
|
async AttachBrowsingContext(BrowsingContextId aParentContextId,
|
|
BrowsingContextId aContextId,
|
|
nsString aName);
|
|
|
|
/**
|
|
* Remove the synced BrowsingContext with id 'aContextId' from the
|
|
* parent. DetachBrowsingContext is only needed to be called once
|
|
* for any BrowsingContext, since detaching a node in the
|
|
* BrowsingContext detaches the entire sub-tree rooted at that
|
|
* node. Calling DetachBrowsingContext with an already detached
|
|
* BrowsingContext effectively does nothing. Note that it is not
|
|
* an error to call DetachBrowsingContext on a BrowsingContext
|
|
* belonging to an already detached subtree. The 'aMoveToBFCache'
|
|
* paramater controls if detaching a BrowsingContext should move
|
|
* it to the bfcache allowing it to be re-attached if navigated
|
|
* to.
|
|
*/
|
|
async DetachBrowsingContext(BrowsingContextId aContextId,
|
|
bool aMoveToBFCache);
|
|
both:
|
|
async AsyncMessage(nsString aMessage, CpowEntry[] aCpows,
|
|
Principal aPrincipal, ClonedMessageData aData);
|
|
|
|
/**
|
|
* Notify `push-subscription-modified` observers in the parent and child.
|
|
*/
|
|
async NotifyPushSubscriptionModifiedObservers(nsCString scope,
|
|
Principal principal);
|
|
};
|
|
|
|
}
|
|
}
|