/* -*- 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 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 PRemoteDecoderManager; 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; include PrefsTypes; // 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 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; }; 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[] blocklist; URIParams[] allowlist; URIParams[] superBlocklist; URIParams[] superAllowlist; }; 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; }; struct IPCURLClassifierFeature { nsCString featureName; nsCString[] tables; nsCString skipHostList; }; // Transport structure for Notifications API notifications // (https://developer.mozilla.org/en-US/docs/Web/API/notification) instances // used exclusively by the NotificationEvent PContent method. struct NotificationEventData { nsCString originSuffix; nsCString scope; nsString ID; nsString title; nsString dir; nsString lang; nsString body; nsString tag; nsString icon; nsString data; nsString behavior; }; struct PostMessageData { BrowsingContextId source; nsString origin; nsString targetOrigin; nsIURI targetOriginURI; nsIPrincipal callerPrincipal; nsIPrincipal subjectPrincipal; nsIURI callerDocumentURI; bool isFromPrivateWindow; }; /** * 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 service); async InitProcessHangMonitor(Endpoint hangMonitor); async InitContentBridgeChild(Endpoint endpoint); async InitProfiler(Endpoint aEndpoint); // Give the content process its endpoints to the compositor. async InitRendering( Endpoint compositor, Endpoint imageBridge, Endpoint vr, Endpoint 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 compositor, Endpoint bridge, Endpoint vr, Endpoint video, uint32_t[] namespaces); async AudioDefaultDeviceChange(); // Re-create the rendering stack for a device reset. async ReinitRenderingForDeviceReset(); async InitRemoteDecoder(Endpoint decoder); /** * 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 FlushCodeCoverageCounters() returns (bool unused); async GetMemoryUniqueSetSize() returns (int64_t uss); /* * 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 aEndpoint); sync CreateChildProcess(IPCTabContext context, ProcessPriority priority, TabId openerTabId, TabId tabId) returns (ContentParentId cpId, bool isForBrowser); sync BridgeToChildProcess(ContentParentId cpId) returns (Endpoint endpoint); sync OpenRecordReplayChannel(uint32_t channelId) returns (FileDescriptor connection); async CreateReplayingProcess(uint32_t channelId); async CreateGMPService(); async InitStreamFilter(uint64_t channelId, nsString addonId) returns (Endpoint 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 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 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); async PURLClassifierLocal(URIParams uri, IPCURLClassifierFeature[] features); async PLoginReputation(URIParams formURI); // Services remoting async StartVisitedQuery(URIParams uri); 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); // Request that the ServiceWorkerManager in the parent process create a // notification "click" or "close" event and dispatch it on the relevant // ServiceWorker. This needs to happen because when a notification is // created it is tied to a specific content process and when the user clicks // on the notification, it will be that content process that is notified. // However, even if the ServiceWorker lives in that process (it may no // longer be in that process, or may have never lived there), the right/only // way to talk through the ServiceWorker is through the parent. // // This happens on PContent because the ServiceWorkerManager lives on the // main thread and bouncing this off of PBackground would be silly and // complex. In the long run, the notification implementation will be // overhauled to directly process the notification click/close and directly // translate that to a ServiceWorker event. async NotificationEvent(nsString type, NotificationEventData data); 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 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); /** * 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 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 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 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 aTopLevelPrincipal * The principal of the top level page the request comes from. * @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, Principal aTopLevelPrincipal, 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, 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, Principal aTrackingPrincipal, nsCString aTrackingOrigin, nsCString aGrantedOrigin, int aAllowMode) returns (bool unused); async StoreUserInteractionAsPermission(Principal aPrincipal); /** * 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 aOpenerId, 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); /** * Set the opener of browsing context with id 'aContextId' to the * browsing context with id 'aOpenerId'. */ async SetOpenerBrowsingContext(BrowsingContextId aContextId, BrowsingContextId aOpenerContextId); 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); async WindowClose(BrowsingContextId aContextId, bool aTrustedCaller); async WindowFocus(BrowsingContextId aContextId); async WindowBlur(BrowsingContextId aContextId); async WindowPostMessage(BrowsingContextId aContextId, ClonedMessageData aMessage, PostMessageData aData); }; } }