summaryrefslogtreecommitdiffstats
path: root/dom/ipc/PContent.ipdl
diff options
context:
space:
mode:
authorMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
committerMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
commit5f8de423f190bbb79a62f804151bc24824fa32d8 (patch)
tree10027f336435511475e392454359edea8e25895d /dom/ipc/PContent.ipdl
parent49ee0794b5d912db1f95dce6eb52d781dc210db5 (diff)
downloadUXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.gz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.lz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.xz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.zip
Add m-esr52 at 52.6.0
Diffstat (limited to 'dom/ipc/PContent.ipdl')
-rw-r--r--dom/ipc/PContent.ipdl1063
1 files changed, 1063 insertions, 0 deletions
diff --git a/dom/ipc/PContent.ipdl b/dom/ipc/PContent.ipdl
new file mode 100644
index 000000000..d436c19fe
--- /dev/null
+++ b/dom/ipc/PContent.ipdl
@@ -0,0 +1,1063 @@
+/* -*- 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 PBlob;
+include protocol PBrowser;
+include protocol PCompositorBridge;
+include protocol PContentBridge;
+include protocol PContentPermissionRequest;
+include protocol PCycleCollectWithLogs;
+include protocol PCrashReporter;
+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 PMedia;
+include protocol PMemoryReportRequest;
+include protocol PNecko;
+// FIXME This is pretty ridiculous, but we have to keep the order of the
+// following 4 includes, or the parser is confused about PGMPContent
+// bridging PContent and PGMP. As soon as it registers the bridge between
+// PContent and PPluginModule it seems to think that PContent's parent and
+// child live in the same process!
+include protocol PGMPContent;
+include protocol PGMPService;
+include protocol PPluginModule;
+include protocol PGMP;
+include protocol PPrinting;
+include protocol PSendStream;
+include protocol POfflineCacheUpdate;
+include protocol PRenderFrame;
+include protocol PScreenManager;
+include protocol PSpeechSynthesis;
+include protocol PStorage;
+include protocol PTestShell;
+include protocol PJavaScript;
+include protocol PRemoteSpellcheckEngine;
+include protocol PWebBrowserPersistDocument;
+include protocol PWebrtcGlobal;
+include protocol PPresentation;
+include protocol PVRManager;
+include protocol PVideoDecoderManager;
+include protocol PFlyWebPublishedServer;
+include DOMTypes;
+include JavaScriptTypes;
+include InputStreamParams;
+include PTabContext;
+include URIParams;
+include PluginTypes;
+include ProtocolTypes;
+include PBackgroundSharedTypes;
+include PContentPermission;
+include ServiceWorkerConfiguration;
+include GraphicsMessages;
+include ProfilerTypes;
+
+// 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 GeoPosition from "nsGeoPositionIPCSerialiser.h";
+using AlertNotificationType 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::ChildPrivileges from "base/process_util.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 struct mozilla::void_t from "ipc/IPCMessageUtils.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::DocShellOriginAttributes from "mozilla/ipc/BackgroundUtils.h";
+using struct mozilla::layers::TextureFactoryIdentifier from "mozilla/layers/CompositorTypes.h";
+using struct mozilla::dom::FlyWebPublishOptions from "mozilla/dom/FlyWebPublishOptionsIPCSerializer.h";
+using mozilla::Telemetry::Accumulation from "mozilla/TelemetryComms.h";
+using mozilla::Telemetry::KeyedAccumulation from "mozilla/TelemetryComms.h";
+
+union ChromeRegistryItem
+{
+ ChromePackage;
+ OverrideMapping;
+ SubstitutionMapping;
+};
+
+namespace mozilla {
+namespace dom {
+
+struct FontListEntry {
+ nsString familyName;
+ nsString faceName;
+ nsCString filepath;
+ uint16_t weight;
+ int16_t stretch;
+ uint8_t italic;
+ uint8_t index;
+ bool isHidden;
+};
+
+union PrefValue {
+ nsCString;
+ int32_t;
+ bool;
+};
+
+union MaybePrefValue {
+ PrefValue;
+ null_t;
+};
+
+struct PrefSetting {
+ nsCString name;
+ MaybePrefValue defaultValue;
+ MaybePrefValue userValue;
+};
+
+struct DataStorageItem {
+ nsCString key;
+ nsCString value;
+ DataStorageType type;
+};
+
+// Note: Any changes to this structure should also be changed in
+// FileSystemUpdate below.
+struct VolumeInfo {
+ nsString name;
+ nsString mountPoint;
+ int32_t volState;
+ int32_t mountGeneration;
+ bool isMediaPresent;
+ bool isSharing;
+ bool isFormatting;
+ bool isFake;
+ bool isUnmounting;
+ bool isRemovable;
+ bool isHotSwappable;
+};
+
+struct ClipboardCapabilities {
+ bool supportsSelectionClipboard;
+ bool supportsFindClipboard;
+};
+
+union MaybeFileDesc {
+ FileDescriptor;
+ void_t;
+};
+
+union FileDescOrError {
+ FileDescriptor;
+ nsresult;
+};
+
+struct DomainPolicyClone
+{
+ bool active;
+ URIParams[] blacklist;
+ URIParams[] whitelist;
+ URIParams[] superBlacklist;
+ URIParams[] superWhitelist;
+};
+
+
+
+struct FrameScriptInfo
+{
+ nsString url;
+ bool runInGlobalScope;
+};
+
+struct AndroidSystemInfo
+{
+ nsString device;
+ nsString manufacturer;
+ nsString release_version;
+ nsString hardware;
+ uint32_t sdk_version;
+ bool isTablet;
+};
+
+struct GetFilesResponseSuccess
+{
+ PBlob[] blobs;
+};
+
+struct GetFilesResponseFailure
+{
+ nsresult errorCode;
+};
+
+union GetFilesResponseResult
+{
+ GetFilesResponseSuccess;
+ GetFilesResponseFailure;
+};
+
+struct BlobURLRegistrationData
+{
+ nsCString url;
+ PBlob blob;
+ Principal principal;
+};
+
+struct GMPAPITags
+{
+ nsCString api;
+ nsCString[] tags;
+};
+
+struct GMPCapabilityData
+{
+ nsCString name;
+ nsCString version;
+ GMPAPITags[] capabilities;
+};
+
+nested(upto inside_cpow) sync protocol PContent
+{
+ parent spawns PPluginModule;
+
+ parent opens PProcessHangMonitor;
+ parent opens PGMPService;
+ child opens PBackground;
+
+ manages PBlob;
+ manages PBrowser;
+ manages PContentPermissionRequest;
+ manages PCrashReporter;
+ manages PCycleCollectWithLogs;
+ manages PPSMContentDownloader;
+ manages PExternalHelperApp;
+ manages PFileDescriptorSet;
+ manages PHal;
+ manages PHandlerService;
+ manages PHeapSnapshotTempFileHelper;
+ manages PMedia;
+ manages PMemoryReportRequest;
+ manages PNecko;
+ manages POfflineCacheUpdate;
+ manages PPrinting;
+ manages PSendStream;
+ manages PScreenManager;
+ manages PSpeechSynthesis;
+ manages PStorage;
+ manages PTestShell;
+ manages PJavaScript;
+ manages PRemoteSpellcheckEngine;
+ manages PWebBrowserPersistDocument;
+ manages PWebrtcGlobal;
+ manages PPresentation;
+ manages PFlyWebPublishedServer;
+
+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::CreateBrowserOrApp.
+ //
+ // When the parent constructs a PBrowser, the child trusts the app token and
+ // other 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 app
+ // token it receives from the child. In this case, context must have type
+ // PopupIPCTabContext. The browser created using a PopupIPCTabContext has
+ // the opener PBrowser's app-id and containing-app-id. The parent checks
+ // that if the opener is a browser element, the context is also for a
+ // browser element.
+ //
+ // This allows the parent to prevent a malicious child from escalating its
+ // privileges by requesting a PBrowser corresponding to a highly-privileged
+ // app; the child can only request privileges for an app which the child has
+ // access to (in the form of a TabChild).
+ //
+ // Keep the last 3 attributes in sync with GetProcessAttributes!
+ async PBrowser(TabId tabId, IPCTabContext context, uint32_t chromeFlags,
+ ContentParentId cpId, bool isForApp, bool isForBrowser);
+
+ async PBlob(BlobConstructorParams params);
+
+ 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:
+ // Give the content process its endpoints to the compositor.
+ async InitRendering(
+ Endpoint<PCompositorBridgeChild> compositor,
+ Endpoint<PImageBridgeChild> imageBridge,
+ Endpoint<PVRManagerChild> vr,
+ Endpoint<PVideoDecoderManagerChild> video);
+
+ // 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<PCompositorBridgeChild> compositor,
+ Endpoint<PImageBridgeChild> bridge,
+ Endpoint<PVRManagerChild> vr,
+ Endpoint<PVideoDecoderManagerChild> video);
+
+ /**
+ * 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 PMemoryReportRequest(uint32_t generation, bool anonymize,
+ bool minimizeMemoryUsage, MaybeFileDesc DMDFile);
+
+ /**
+ * Sent to notify that aTabId has been allocated aLayersId
+ */
+ async NotifyLayerAllocated(TabId aTabId, uint64_t aLayersId);
+
+ async SpeakerManagerNotify();
+
+ /**
+ * 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 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(PrefSetting 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(GeoPosition somewhere);
+
+ async GeolocationError(uint16_t errorCode);
+
+ async UpdateDictionaryList(nsString[] dictionaries);
+
+ // nsIPermissionManager messages
+ async AddPermission(Permission permission);
+
+ async Volumes(VolumeInfo[] volumes);
+
+ async FlushMemory(nsString reason);
+
+ async GarbageCollect();
+ async CycleCollect();
+
+ /**
+ * Start accessibility engine in content process.
+ * @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 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);
+ async AppInit();
+
+ /**
+ * Send ServiceWorkerRegistrationData to child process.
+ */
+ async InitServiceWorkers(ServiceWorkerConfiguration aConfig);
+
+ /**
+ * Send BlobURLRegistrationData to child process.
+ */
+ async InitBlobURLs(BlobURLRegistrationData[] registrations);
+
+ // Notify child that last-pb-context-exited notification was observed
+ async LastPrivateDocShellDestroyed();
+
+ // Note: Any changes to this structure should also be changed in
+ // VolumeInfo above.
+ async FileSystemUpdate(nsString fsName, nsString mountPoint, int32_t fsState,
+ int32_t mountGeneration, bool isMediaPresent,
+ bool isSharing, bool isFormatting, bool isFake,
+ bool isUnmounting, bool isRemovable, bool isHotSwappable);
+
+ // Notify volume is removed.
+ async VolumeRemoved(nsString fsName);
+
+ 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);
+
+ async NotifyPhoneStateChange(nsString newState);
+
+ /**
+ * Notify idle observers in the child
+ */
+ async NotifyIdleObserver(uint64_t observerId, nsCString topic, nsString str);
+
+ /**
+ * Called during plugin initialization to map a plugin id to a child process
+ * id.
+ */
+ async AssociatePluginId(uint32_t aPluginId, ProcessId aProcessId);
+
+ /**
+ * This call is used by async plugin initialization to notify the
+ * PluginModuleContentParent that the PluginModuleChromeParent's async
+ * init has completed.
+ */
+ async LoadPluginResult(uint32_t aPluginId, bool aResult);
+
+ /**
+ * Control the Gecko Profiler in the child process.
+ */
+ async StartProfiler(ProfilerInitParams params);
+ async StopProfiler();
+ async PauseProfiler(bool aPause);
+
+ async GatherProfile();
+
+ async InvokeDragSession(IPCDataTransfer[] transfers, uint32_t action);
+
+ async EndDragSession(bool aDoneDrag, bool aUserCancelled,
+ LayoutDeviceIntPoint aDragEndPoint);
+
+ 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, PBlob aBlob,
+ Principal aPrincipal);
+
+ async BlobURLUnregistration(nsCString aURI);
+
+
+ async GMPsChanged(GMPCapabilityData[] capabilities);
+
+parent:
+ /**
+ * Tell the content process some attributes of itself. This is
+ * among the first information queried by content processes after
+ * startup. (The message is sync to allow the content process to
+ * control when it receives the information.)
+ *
+ * |id| is a unique ID among all subprocesses. When |isForApp &&
+ * isForBrowser|, we're loading <browser> for an app. When
+ * |isForBrowser|, we're loading <browser>. When |!isForApp &&
+ * !isForBrowser|, we're probably loading <xul:browser remote>.
+ *
+ * Keep the return values in sync with PBrowser()!
+ */
+ sync GetProcessAttributes()
+ returns (ContentParentId cpId, bool isForApp, bool isForBrowser);
+ sync GetXPCOMProcessAttributes()
+ returns (bool isOffline, bool isConnected, int32_t captivePortalState,
+ bool isLangRTL,
+ bool haveBidiKeyboards, nsString[] dictionaries,
+ ClipboardCapabilities clipboardCaps,
+ DomainPolicyClone domainPolicy,
+ StructuredCloneData initialData,
+ OptionalURIParams userContentSheetURL);
+
+ sync CreateChildProcess(IPCTabContext context,
+ ProcessPriority priority,
+ TabId openerTabId)
+ returns (ContentParentId cpId, bool isForApp, bool isForBrowser, TabId tabId);
+ sync BridgeToChildProcess(ContentParentId cpId);
+
+ async CreateGMPService();
+
+ /**
+ * This call connects the content process to a plugin process. While this
+ * call runs, a new PluginModuleParent will be created in the ContentChild
+ * via bridging. The corresponding PluginModuleChild will live in the plugin
+ * process.
+ */
+ sync LoadPlugin(uint32_t aPluginId) returns (nsresult aResult, uint32_t aRunID);
+
+ /**
+ * 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. When this call returns, the requested bridge
+ * connection has been made.
+ */
+ sync ConnectPluginBridge(uint32_t aPluginId) returns (nsresult rv);
+
+ /**
+ * Return the current blocklist state for a particular plugin.
+ */
+ sync GetBlocklistState(uint32_t aPluginId) returns (uint32_t aState);
+
+ /**
+ * This call returns the set of plugins loaded in the chrome
+ * process. However, in many cases this set will not have changed since the
+ * last FindPlugins message. Consequently, the chrome process increments an
+ * epoch number every time the set of plugins changes. The content process
+ * sends up the last epoch it observed. If the epochs are the same, the
+ * chrome process returns no plugins. Otherwise it returns a complete list.
+ *
+ * |pluginEpoch| is the epoch last observed by the content
+ * process. |newPluginEpoch| is the current epoch in the chrome process. If
+ * |pluginEpoch == newPluginEpoch|, then |plugins| will be left empty.
+ */
+ sync FindPlugins(uint32_t pluginEpoch) returns (nsresult aResult, PluginTag[] plugins, uint32_t newPluginEpoch);
+
+ async PJavaScript();
+
+ async PRemoteSpellcheckEngine();
+
+ sync PCrashReporter(NativeThreadId tid, uint32_t processType);
+
+ /**
+ * Is this token compatible with the provided version?
+ *
+ * |version| The offered version to test
+ * Returns |True| if the offered version is compatible
+ */
+ sync NSSU2FTokenIsCompatibleVersion(nsString version)
+ returns (bool result);
+
+ /**
+ * Return whether the provided KeyHandle belongs to this Token
+ *
+ * |keyHandle| Key Handle to evaluate.
+ * Returns |True| if the Key Handle is ours.
+ */
+ sync NSSU2FTokenIsRegistered(uint8_t[] keyHandle)
+ returns (bool isValidKeyHandle);
+
+ /**
+ * Generates a public/private keypair for the provided application
+ * and challenge, returning the pubkey, challenge response, and
+ * key handle in the registration data.
+ *
+ * |application| The FIDO Application data to associate with the key.
+ * |challenge| The Challenge to satisfy in the response.
+ * |registration| An array containing the pubkey, challenge response,
+ * and key handle.
+ */
+ sync NSSU2FTokenRegister(uint8_t[] application, uint8_t[] challenge)
+ returns (uint8_t[] registration);
+
+ /**
+ * Creates a signature over the "param" arguments using the private key
+ * provided in the key handle argument.
+ *
+ * |application| The FIDO Application data to associate with the key.
+ * |challenge| The Challenge to satisfy in the response.
+ * |keyHandle| The Key Handle opaque object to use.
+ * |signature| The resulting signature.
+ */
+ sync NSSU2FTokenSign(uint8_t[] application, uint8_t[] challenge,
+ uint8_t[] keyHandle)
+ returns (uint8_t[] signature);
+
+ sync IsSecureURI(uint32_t type, URIParams uri, uint32_t flags)
+ returns (bool isSecureURI);
+
+ async AccumulateMixedContentHSTS(URIParams uri, bool active, bool hasHSTSPriming);
+
+ sync GetLookAndFeelCache()
+ returns (LookAndFeelInt[] lookAndFeelIntCache);
+
+ nested(inside_cpow) async PHal();
+
+ async PHeapSnapshotTempFileHelper();
+
+ async PNecko();
+
+ async PPrinting();
+
+ async PSendStream();
+
+ nested(inside_sync) sync PScreenManager()
+ returns (uint32_t numberOfScreens,
+ float systemDefaultScale,
+ bool success);
+
+ async PSpeechSynthesis();
+
+ nested(inside_cpow) async PStorage();
+
+ async PMedia();
+
+ async PWebrtcGlobal();
+
+ async PPresentation();
+
+ async PFlyWebPublishedServer(nsString name, FlyWebPublishOptions params);
+
+ // 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 ReadPrefsArray() returns (PrefSetting[] prefs) verify;
+ sync GetGfxVars() returns (GfxVarUpdate[] vars);
+
+ sync ReadFontList() returns (FontListEntry[] retValue);
+
+ sync ReadDataStorageArray(nsString aFilename)
+ returns (DataStorageItem[] 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(AlertNotificationType 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);
+
+ // nsIPermissionManager messages
+ sync ReadPermissions() returns (Permission[] permissions);
+
+ // Places the items within dataTransfer on the clipboard.
+ async SetClipboard(IPCDataTransfer aDataTransfer,
+ bool aIsPrivateData,
+ Principal aRequestingPrincipal,
+ 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);
+
+ // 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);
+
+ 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 AudioChannelServiceStatus(bool aActiveTelephonyChannel,
+ bool aContentOrNormalChannel,
+ bool aAnyActiveChannel);
+
+ async AudioChannelChangeDefVolChannel(int32_t aChannel, bool aHidden);
+
+ // called by the child (test code only) to propagate volume changes to the parent
+ async CreateFakeVolume(nsString fsName, nsString mountPoint);
+ async SetFakeVolumeState(nsString fsName, int32_t fsState);
+ async RemoveFakeVolume(nsString fsName);
+
+ sync KeywordToURI(nsCString keyword)
+ returns (nsString providerName, OptionalInputStreamParams 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 (uint64_t id);
+ async DeallocateLayerTreeId(uint64_t id);
+
+ sync SpeakerManagerForceSpeaker(bool aEnable);
+
+ sync SpeakerManagerGetSpeakerStatus()
+ returns (bool value);
+
+ /**
+ * 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);
+
+ sync GetGraphicsFeatureStatus(int32_t aFeature) returns (int32_t aStatus, nsCString aFailureCode,
+ bool aSuccess);
+
+ // 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);
+
+ sync OpenAnonymousTemporaryFile() returns (FileDescOrError aFD);
+
+ /**
+ * 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);
+
+ /**
+ * Tell the chrome process there is an creation of PBrowser.
+ * return a system-wise unique Id.
+ */
+ sync AllocateTabId(TabId openerTabId, IPCTabContext context, ContentParentId cpId)
+ returns (TabId tabId);
+ async DeallocateTabId(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,
+ TabId tabId);
+
+ async Profile(nsCString aProfile);
+
+ /**
+ * Request graphics initialization information from the parent.
+ */
+ sync GetGraphicsDeviceInitData()
+ returns (ContentDeviceData aData);
+
+ sync CreateWindow(nullable PBrowser aThisTab,
+ PBrowser aNewTab,
+ PRenderFrame aRenderFrame,
+ uint32_t aChromeFlags,
+ bool aCalledFromJS,
+ bool aPositionSpecified,
+ bool aSizeSpecified,
+ nsCString aFeatures,
+ nsCString aBaseURI,
+ DocShellOriginAttributes aOpenerOriginAttributes,
+ float aFullZoom)
+ returns (nsresult rv,
+ bool windowOpened,
+ FrameScriptInfo[] frameScripts,
+ nsCString urlToLoad,
+ TextureFactoryIdentifier textureFactoryIdentifier,
+ uint64_t layersId);
+
+ 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);
+
+ /**
+ * Tell the parent process that the child process is low on memory. This
+ * allows the parent process to save a memory report that can potentially be
+ * sent with a crash report from the content process.
+ */
+ async NotifyLowMemory();
+
+ async GetFilesRequest(nsID aID, nsString aDirectory, bool aRecursiveFlag);
+ async DeleteGetFilesRequest(nsID aID);
+
+ async StoreAndBroadcastBlobURLRegistration(nsCString url, PBlob blob,
+ Principal principal);
+
+ async UnstoreAndBroadcastBlobURLUnregistration(nsCString url);
+
+ /**
+ * Messages for communicating child Telemetry to the parent process
+ */
+ async AccumulateChildHistogram(Accumulation[] accumulations);
+ async AccumulateChildKeyedHistogram(KeyedAccumulation[] accumulations);
+
+ sync GetA11yContentId() returns (uint32_t aContentId);
+
+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);
+};
+
+}
+}