/* -*- 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 PAPZ; include protocol PBackground; include protocol PBlob; include protocol PBluetooth; include protocol PBrowser; include protocol PCellBroadcast; 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 PDeviceStorageRequest; include protocol PFileDescriptorSet; include protocol PFMRadio; include protocol PHal; include protocol PHeapSnapshotTempFileHelper; include protocol PIcc; include protocol PProcessHangMonitor; include protocol PImageBridge; include protocol PMedia; include protocol PMemoryReportRequest; include protocol PMobileConnection; 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 POfflineCacheUpdate; include protocol PRenderFrame; include protocol PScreenManager; include protocol PSharedBufferManager; include protocol PSms; include protocol PSpeechSynthesis; include protocol PStorage; include protocol PTelephony; include protocol PTestShell; include protocol PVoicemail; include protocol PJavaScript; include protocol PRemoteSpellcheckEngine; include protocol PWebBrowserPersistDocument; include protocol PWebrtcGlobal; include protocol PPresentation; include protocol PVRManager; include DOMTypes; include JavaScriptTypes; include InputStreamParams; include PTabContext; include URIParams; include PluginTypes; include ProtocolTypes; include PBackgroundSharedTypes; include PContentPermission; include BrowserConfiguration; 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 struct LookAndFeelInt from "mozilla/widget/WidgetMessageUtils.h"; using class mozilla::dom::ipc::StructuredCloneData from "ipc/IPCMessageUtils.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"; 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; }; struct DeviceStorageFreeSpaceParams { nsString type; nsString storageName; }; struct DeviceStorageUsedSpaceParams { nsString type; nsString storageName; }; struct DeviceStorageAvailableParams { nsString type; nsString storageName; }; struct DeviceStorageStatusParams { nsString type; nsString storageName; }; struct DeviceStorageFormatParams { nsString type; nsString storageName; }; struct DeviceStorageMountParams { nsString type; nsString storageName; }; struct DeviceStorageUnmountParams { nsString type; nsString storageName; }; struct DeviceStorageAddParams { nsString type; nsString storageName; nsString relpath; PBlob blob; }; struct DeviceStorageAppendParams { nsString type; nsString storageName; nsString relpath; PBlob blob; }; struct DeviceStorageCreateFdParams { nsString type; nsString storageName; nsString relpath; }; struct DeviceStorageGetParams { nsString type; nsString storageName; nsString rootDir; nsString relpath; }; struct DeviceStorageDeleteParams { nsString type; nsString storageName; nsString relpath; }; struct DeviceStorageEnumerationParams { nsString type; nsString storageName; nsString rootdir; uint64_t since; }; union DeviceStorageParams { DeviceStorageAddParams; DeviceStorageAppendParams; DeviceStorageCreateFdParams; DeviceStorageGetParams; DeviceStorageDeleteParams; DeviceStorageEnumerationParams; DeviceStorageFreeSpaceParams; DeviceStorageUsedSpaceParams; DeviceStorageAvailableParams; DeviceStorageStatusParams; DeviceStorageFormatParams; DeviceStorageMountParams; DeviceStorageUnmountParams; }; struct DeviceStorageLocationInfo { nsString music; nsString pictures; nsString videos; nsString sdcard; nsString apps; nsString crashes; }; struct FMRadioRequestEnableParams { double frequency; }; struct FMRadioRequestDisableParams { }; struct FMRadioRequestSetFrequencyParams { double frequency; }; struct FMRadioRequestSeekParams { bool upward; }; struct FMRadioRequestCancelSeekParams { }; union FMRadioRequestParams { FMRadioRequestEnableParams; FMRadioRequestDisableParams; FMRadioRequestSetFrequencyParams; FMRadioRequestSeekParams; FMRadioRequestCancelSeekParams; }; 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; }; struct DataStoreSetting { nsString name; nsString originURL; nsString manifestURL; bool readOnly; bool enabled; }; // 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; }; union OptionalContentId { ContentParentId; void_t; }; struct DomainPolicyClone { bool active; URIParams[] blacklist; URIParams[] whitelist; URIParams[] superBlacklist; URIParams[] superWhitelist; }; struct GamepadAdded { nsString id; uint32_t index; uint32_t mapping; uint32_t num_buttons; uint32_t num_axes; }; struct GamepadRemoved { uint32_t index; }; struct GamepadAxisInformation { uint32_t index; uint32_t axis; double value; }; struct GamepadButtonInformation { uint32_t index; uint32_t button; bool pressed; double value; }; union GamepadChangeEvent { GamepadAdded; GamepadRemoved; GamepadAxisInformation; GamepadButtonInformation; }; struct FrameScriptInfo { nsString url; bool runInGlobalScope; }; struct AndroidSystemInfo { nsString device; nsString manufacturer; nsString release_version; nsString hardware; uint32_t sdk_version; bool isTablet; }; prio(normal upto urgent) sync protocol PContent { parent spawns PPluginModule; parent opens PCompositorBridge; parent opens PProcessHangMonitor; parent opens PSharedBufferManager; parent opens PImageBridge; parent opens PGMPService; parent opens PVRManager; child opens PBackground; manages PAPZ; manages PBlob; manages PBluetooth; manages PBrowser; manages PCellBroadcast; manages PContentPermissionRequest; manages PCrashReporter; manages PCycleCollectWithLogs; manages PDeviceStorageRequest; manages PPSMContentDownloader; manages PExternalHelperApp; manages PFileDescriptorSet; manages PFMRadio; manages PHal; manages PHandlerService; manages PHeapSnapshotTempFileHelper; manages PIcc; manages PMedia; manages PMemoryReportRequest; manages PMobileConnection; manages PNecko; manages POfflineCacheUpdate; manages PPrinting; manages PScreenManager; manages PSms; manages PSpeechSynthesis; manages PStorage; manages PTelephony; manages PTestShell; manages PVoicemail; manages PJavaScript; manages PRemoteSpellcheckEngine; manages PWebBrowserPersistDocument; manages PWebrtcGlobal; manages PPresentation; 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: /** * 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); async SpeakerManagerNotify(); /** * Communication between the PuppetBidiKeyboard and the actual * BidiKeyboard hosted by the parent */ async BidiKeyboardNotify(bool isLangRTL); async DataStoreNotify(uint32_t aAppId, nsString aName, nsString aManifestURL); /** * 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 PAPZ(TabId tabId); async RegisterChrome(ChromePackage[] packages, SubstitutionMapping[] substitutions, OverrideMapping[] overrides, nsCString locale, bool reset); async RegisterChromeItem(ChromeRegistryItem item); async SetOffline(bool offline); async SetConnectivity(bool connectivity); async NotifyVisited(URIParams uri); async SystemMemoryAvailable(uint64_t getterId, uint32_t memoryAvailable); async PreferenceUpdate(PrefSetting pref); 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. */ async ActivateA11y(); async AppInfo(nsCString version, nsCString buildID, nsCString name, nsCString UAName, nsCString ID, nsCString vendor); async AppInit(); // Notify child that last-pb-context-exited notification was observed async LastPrivateDocShellDestroyed(); async FilePathUpdate(nsString storageType, nsString storageName, nsString filepath, nsCString reasons); // 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); /** * Notify windows in the child to apply a new app style. */ async OnAppThemeChanged(); /** * 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); 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); /** * Send gamepad status update to child. */ async GamepadUpdate(GamepadChangeEvent aGamepadEvent); /** * 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 the Gecko Media Plugins installed changed. */ async NotifyGMPsChanged(); /** * 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, nsString message, uint32_t flags); /** * Windows specific: associate this content process with the browsers * audio session. */ async SetAudioSessionData(nsID aID, nsString aDisplayName, nsString aIconPath); 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 for an app. When * |isForBrowser|, we're loading . When |!isForApp && * !isForBrowser|, we're probably loading . * * Keep the return values in sync with PBrowser()! */ sync GetProcessAttributes() returns (ContentParentId cpId, bool isForApp, bool isForBrowser); sync GetXPCOMProcessAttributes() returns (bool isOffline, bool isConnected, bool isLangRTL, nsString[] dictionaries, ClipboardCapabilities clipboardCaps, DomainPolicyClone domainPolicy, StructuredCloneData initialData); sync CreateChildProcess(IPCTabContext context, ProcessPriority priority, TabId openerTabId) returns (ContentParentId cpId, bool isForApp, bool isForBrowser, TabId tabId); sync BridgeToChildProcess(ContentParentId cpId); async CreateGMPService(); sync GetGMPPluginVersionForAPI(nsCString api, nsCString[] tags) returns (bool hasPlugin, nsCString version); sync IsGMPPresentOnDisk(nsString keySystem, nsCString version) returns (bool isPresent, nsCString message); /** * 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(); async PDeviceStorageRequest(DeviceStorageParams params); 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); async GetSystemMemory(uint64_t getterId); sync IsSecureURI(uint32_t type, URIParams uri, uint32_t flags) returns (bool isSecureURI); async AccumulateMixedContentHSTS(URIParams uri, bool active); sync GetLookAndFeelCache() returns (LookAndFeelInt[] lookAndFeelIntCache); prio(urgent) async PHal(); async PHeapSnapshotTempFileHelper(); async PIcc(uint32_t serviceId); async PMobileConnection(uint32_t clientId); async PNecko(); async PPrinting(); prio(high) sync PScreenManager() returns (uint32_t numberOfScreens, float systemDefaultScale, bool success); async PCellBroadcast(); async PSms(); async PSpeechSynthesis(); prio(urgent) async PStorage(); async PTelephony(); async PVoicemail(); async PMedia(); async PBluetooth(); async PFMRadio(); async PWebrtcGlobal(); async PPresentation(); // 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); // PrefService message sync ReadPrefsArray() returns (PrefSetting[] prefs); 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); prio(high) 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, 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, 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); sync DataStoreGetStores(nsString aName, nsString aOwner, Principal aPrincipal) returns (DataStoreSetting[] dataStores); async FilePathUpdateNotify(nsString aType, nsString aStorageName, nsString aFilepath, nsCString aReason); // Notify the parent that the child has finished handling a system message. async SystemMessageHandled(); // 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 element is parsed and * before one is submitted. This is urgent because an extension might use * a CPOW to synchronously submit a keygen element. */ prio(urgent) sync KeygenProcessValue(nsString oldValue, nsString challenge, nsString keytype, nsString keyparams) returns (nsString newValue); /** * Called to provide the options for 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 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); /** * Send ServiceWorkerRegistrationData to child process. */ sync GetBrowserConfiguration(nsCString aUri) returns (BrowserConfiguration aConfig); /* * Tells the parent to start the gamepad listening service if it hasn't already. */ async GamepadListenerAdded(); /** * Tells the parent to stop the gamepad listening service if it hasn't already. */ async GamepadListenerRemoved(); async Profile(nsCString aProfile); /** * Request graphics initialization information from the parent. */ sync GetGraphicsDeviceInitData() returns (DeviceInitData aData); sync CreateWindow(nullable PBrowser aThisTab, PBrowser aNewTab, PRenderFrame aRenderFrame, uint32_t aChromeFlags, bool aCalledFromJS, bool aPositionSpecified, bool aSizeSpecified, nsCString aURI, nsString aName, nsCString aFeatures, nsCString aBaseURI, DocShellOriginAttributes aOpenerOriginAttributes, float aFullZoom) returns (nsresult rv, bool windowOpened, FrameScriptInfo[] frameScripts, nsCString urlToLoad, TextureFactoryIdentifier textureFactoryIdentifier, uint64_t layersId); sync GetDeviceStorageLocation(nsString type) returns (nsString path); sync GetDeviceStorageLocations() returns (DeviceStorageLocationInfo info); 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); both: async AsyncMessage(nsString aMessage, CpowEntry[] aCpows, Principal aPrincipal, ClonedMessageData aData); }; } }