PContent.ipdl - mozsearch

/* -*- tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */

/* vim: set ts=2 et sw=2 tw=80: */

/* 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 PBackgroundStarter;

include protocol PBrowser;

include protocol PClipboardReadRequest;

include protocol PClipboardWriteRequest;

include protocol PCompositorManager;

include protocol PContentPermissionRequest;

include protocol PCycleCollectWithLogs;

include protocol PDocumentChannel;

include protocol PExtensions;

include protocol PExternalHelperApp;

include protocol PHandlerService;

include protocol PHal;

include protocol PHeapSnapshotTempFileHelper;

include protocol PProcessHangMonitor;

include protocol PImageBridge;

include protocol PRemotePrintJob;

include protocol PMedia;

include protocol PNecko;

include protocol PStreamFilter;

include protocol PGMPContent;

include protocol PGMPService;

include protocol PGMP;

#ifdef MOZ_WEBSPEECH

include protocol PSpeechSynthesis;

#endif

include protocol PTestShell;

include protocol PRemoteSpellcheckEngine;

include protocol PWebBrowserPersistDocument;

#ifdef MOZ_WEBRTC

include protocol PWebrtcGlobal;

#endif

include protocol PWindowGlobal;

include protocol PURLClassifier;

include protocol PURLClassifierLocal;

include protocol PVRManager;

include protocol PRemoteDecoderManager;

include protocol PProfiler;

include protocol PScriptCache;

include protocol PSessionStorageObserver;

include protocol PBenchmarkStorage;

include DOMTypes;

include WindowGlobalTypes;

include IPCBlob;

include IPCStream;

include IPCTransferable;

include PPrintingTypes;

include PTabContext;

include ProtocolTypes;

include PBackgroundSharedTypes;

include PContentPermission;

include GraphicsMessages;

include MemoryReportTypes;

include ClientIPCTypes;

include HangTypes;

include PrefsTypes;

include NeckoChannelParams;

include PSMIPCTypes;

include LookAndFeelTypes;

#if defined(MOZ_SANDBOX) && defined(MOZ_DEBUG) && defined(ENABLE_TESTS)

include protocol PSandboxTesting;

#endif

include "ipc/MediaControlIPC.h";

include "mozilla/AntiTrackingIPCUtils.h";

include "mozilla/GfxMessageUtils.h";

include "mozilla/dom/BindingIPCUtils.h";

include "mozilla/dom/CSPMessageUtils.h";

include "mozilla/dom/DocShellMessageUtils.h";

include "mozilla/dom/FeaturePolicyUtils.h";

include "mozilla/dom/MediaSessionIPCUtils.h";

include "mozilla/dom/PageLoadEventUtils.h";

include "mozilla/dom/ReferrerInfoUtils.h";

include "mozilla/glean/GleanMetrics.h";

include "mozilla/ipc/ByteBufUtils.h";

include "mozilla/ipc/TransportSecurityInfoUtils.h";

include "mozilla/ipc/URIUtils.h";

include "mozilla/net/NeckoMessageUtils.h";

include "mozilla/PermissionDelegateIPCUtils.h";

[RefCounted] using class nsIDOMGeoPosition from "nsGeoPositionIPCSerialiser.h";

[RefCounted] using 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 mozilla::dom::NativeThreadId from "mozilla/dom/NativeThreadId.h";

using mozilla::hal::ProcessPriority from "mozilla/HalTypes.h";

using mozilla::gfx::IntSize from "mozilla/gfx/2D.h";

using mozilla::gfx::SurfaceFormat from "mozilla/gfx/Types.h";

using mozilla::dom::TabId from "mozilla/dom/ipc/IdType.h";

using mozilla::dom::ContentParentId from "mozilla/dom/ipc/IdType.h";

using mozilla::EventMessage from "mozilla/EventForwards.h";

using mozilla::LayoutDeviceIntPoint from "Units.h";

using mozilla::ImagePoint from "Units.h";

using mozilla::widget::ThemeChangeKind from "mozilla/widget/WidgetMessageUtils.h";

using class mozilla::dom::MessagePort from "mozilla/dom/MessagePort.h";

[MoveOnly=data] using class mozilla::dom::ipc::StructuredCloneData from "mozilla/dom/ipc/StructuredCloneData.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";

#if defined(XP_WIN)

[MoveOnly] using mozilla::UntrustedModulesData from "mozilla/UntrustedModulesData.h";

[MoveOnly] using mozilla::ModulePaths from "mozilla/UntrustedModulesData.h";

[MoveOnly] using mozilla::ModulesMapResult from "mozilla/UntrustedModulesData.h";

#endif  // defined(XP_WIN)

using mozilla::Telemetry::DiscardedData from "mozilla/TelemetryComms.h";

using mozilla::glean::perf::PageLoadExtra from "mozilla/glean/GleanMetrics.h";

[MoveOnly] using mozilla::CrossProcessMutexHandle from "mozilla/ipc/CrossProcessMutex.h";

using mozilla::dom::MaybeDiscardedBrowsingContext from "mozilla/dom/BrowsingContext.h";

using mozilla::dom::BrowsingContextTransaction from "mozilla/dom/BrowsingContext.h";

using mozilla::dom::BrowsingContextInitializer from "mozilla/dom/BrowsingContext.h";

using mozilla::dom::PermitUnloadResult from "nsIDocumentViewer.h";

using mozilla::dom::MaybeDiscardedWindowContext from "mozilla/dom/WindowContext.h";

using mozilla::dom::WindowContextTransaction from "mozilla/dom/WindowContext.h";

[MoveOnly] using base::SharedMemoryHandle from "base/shared_memory.h";

using gfxSparseBitSet from "gfxFontUtils.h";

using FontVisibility from "gfxFontEntry.h";

using mozilla::dom::MediaControlAction from "mozilla/dom/MediaControlKeySource.h";

using mozilla::dom::MediaPlaybackState from "mozilla/dom/MediaPlaybackStatus.h";

using mozilla::dom::MediaAudibleState from "mozilla/dom/MediaPlaybackStatus.h";

using mozilla::dom::MediaMetadataBase from "mozilla/dom/MediaMetadata.h";

using mozilla::dom::MediaSessionAction from "mozilla/dom/MediaSessionBinding.h";

using mozilla::dom::MediaSessionPlaybackState from "mozilla/dom/MediaSessionBinding.h";

using mozilla::dom::PositionState from "mozilla/dom/MediaSession.h";

using mozilla::dom::ServiceWorkerShutdownState::Progress from "mozilla/dom/ServiceWorkerShutdownState.h";

using mozilla::ContentBlockingNotifier::StorageAccessPermissionGrantedReason from "mozilla/ContentBlockingNotifier.h";

using mozilla::ContentBlockingNotifier::BlockingDecision from "mozilla/ContentBlockingNotifier.h";

using mozilla::StorageAccessAPIHelper::StorageAccessPromptChoices from "mozilla/StorageAccessAPIHelper.h";

using mozilla::dom::JSActorMessageKind from "mozilla/dom/JSActor.h";

using mozilla::dom::JSActorMessageMeta from "mozilla/dom/PWindowGlobal.h";

using mozilla::PermissionDelegateHandler::DelegatedPermissionList from "mozilla/PermissionDelegateHandler.h";

[RefCounted] using class nsILayoutHistoryState from "nsILayoutHistoryState.h";

using class mozilla::dom::SessionHistoryInfo from "mozilla/dom/SessionHistoryEntry.h";

using struct nsPoint from "nsPoint.h";

using struct mozilla::dom::LoadingSessionHistoryInfo from "mozilla/dom/SessionHistoryEntry.h";

using mozilla::media::MediaCodecsSupported from "MediaCodecsSupport.h";

using mozilla::RemoteDecodeIn from "mozilla/RemoteDecoderManagerChild.h";

using mozilla::dom::PerformanceTimingData from "mozilla/dom/PerformanceTiming.h";

[RefCounted] using mozilla::dom::FeaturePolicy from "mozilla/dom/FeaturePolicy.h";

using mozilla::dom::Wireframe from "mozilla/dom/DocumentBinding.h";

using mozilla::PerfStats::MetricMask from "mozilla/PerfStats.h";

[RefCounted] using class nsIX509Cert from "nsIX509Cert.h";

using nsIDNSService::ResolverMode from "nsIDNSService.h";

using mozilla::dom::UserActivation::Modifiers from "mozilla/dom/UserActivation.h";

union ChromeRegistryItem

    ChromePackage;

    OverrideMapping;

    SubstitutionMapping;

};

namespace mozilla {

namespace dom {

// SetXPCOMProcessAttributes passes an array of font data to the child,

// but each platform needs different details so we have platform-specific

// versions of the SystemFontListEntry type:

#if defined(ANDROID)

// Used on Android to pass the list of fonts on the device

// to the child process

struct SystemFontListEntry {

    nsCString familyName;

    nsCString faceName;

    nsCString filepath;

    uint32_t  weightRange;

    uint32_t  stretchRange;

    uint32_t  styleRange;

    uint8_t   index;

    FontVisibility visibility;

};

#elif defined(XP_MACOSX) || defined(XP_IOS)

// 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 SystemFontListEntry {

    nsCString familyName;

    FontVisibility visibility;

    uint8_t   entryType;

};

#else

// Used on Linux to pass list of font patterns from chrome to content.

// (Unused on Windows, but there needs to be a definition of the type.)

struct SystemFontListEntry {

    nsCString pattern;

    bool      appFontFamily;

};

#endif

#ifdef MOZ_WIDGET_GTK

struct SystemFontOptions {

    int32_t antialias; // cairo_antialias_t

    int32_t subpixelOrder; // cairo_subpixel_order_t

    int32_t hintStyle; // cairo_hint_style_t

    int32_t lcdFilter; // cairo_lcd_filter_t

};

#endif

struct SystemFontList {

    SystemFontListEntry[] entries;

#ifdef MOZ_WIDGET_GTK

    SystemFontOptions options;

#endif

};

union SystemParameterValue {

  bool;

  float;

};

struct ClipboardCapabilities {

  bool supportsSelectionClipboard;

  bool supportsFindClipboard;

  bool supportsSelectionCache;

};

union FileDescOrError {

    FileDescriptor;

    nsresult;

};

struct DomainPolicyClone

    bool        active;

    nullable nsIURI[] blocklist;

    nullable nsIURI[] allowlist;

    nullable nsIURI[] superBlocklist;

    nullable nsIURI[] 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 BlobURLRegistrationData

  nsCString url;

  IPCBlob blob;

  nullable nsIPrincipal principal;

  nsCString partitionKey;

  bool revoked;

};

struct JSWindowActorEventDecl

  nsString name;

  bool capture;

  bool systemGroup;

  bool allowUntrusted;

  bool? passive;

  bool createActor;

};

struct JSWindowActorInfo

  nsCString name;

  bool allFrames;

  // True if `url` is for ESM.

  // False if `url` is for JSM or nothing.

  bool isESModule;

  // This is to align with JSProcessActorInfo.

  // This attribute isn't used for JSWindow Actors.

  bool loadInDevToolsLoader;

  // The module of the url.

  nsCString? url;

  JSWindowActorEventDecl[] events;

  // Observer notifications this actor listens to.

  nsCString[] observers;

  nsString[] matches;

  nsCString[] remoteTypes;

  nsString[] messageManagerGroups;

};

struct JSProcessActorInfo

    // The name of the actor.

    nsCString name;

    // True if `url` is for ESM.

    // False if `url` is for JSM or nothing.

    bool isESModule;

    // True if the actor should be loaded in the distinct loader dedicated to DevTools.

    bool loadInDevToolsLoader;

    // The module of the url.

    nsCString? url;

    // Observer notifications this actor listens to.

    nsCString[] observers;

    nsCString[] remoteTypes;

};

struct GMPAPITags

    nsCString api;

    nsCString[] tags;

};

struct GMPCapabilityData

    nsCString name;

    nsCString version;

    GMPAPITags[] capabilities;

};

struct L10nFileSourceDescriptor {

  nsCString name;

  nsCString metasource;

  nsCString[] locales;

  nsCString prePath;

  nsCString[] index;

};

struct XPCOMInitData

    bool isOffline;

    bool isConnected;

    int32_t captivePortalState;

    bool isLangRTL;

    bool haveBidiKeyboards;

    nsCString[] dictionaries;

    ClipboardCapabilities clipboardCaps;

    DomainPolicyClone domainPolicy;

    nullable nsIURI userContentSheetURL;

    GfxVarUpdate[] gfxNonDefaultVarUpdates;

    ContentDeviceData contentDeviceData;

    GfxInfoFeatureStatus[] gfxFeatureStatus;

    nsCString[] appLocales;

    nsCString[] requestedLocales;

    L10nFileSourceDescriptor[] l10nFileSources;

    DynamicScalarDefinition[] dynamicScalarDefs;

    MetricMask perfStatsMask;

    nsCString trrDomain;

    ResolverMode trrMode;

    // This is the value of network.trr.mode and can be diffrent than trrMode.

    ResolverMode trrModeFromPref;

};

struct VisitedQueryResult

    nullable nsIURI uri;

    bool visited;

};

struct StringBundleDescriptor

    nsCString bundleURL;

    FileDescriptor mapFile;

    uint32_t mapSize;

};

struct IPCURLClassifierFeature

    nsCString featureName;

    nsCString[] tables;

    nsCString exceptionHostList;

};

// 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

    MaybeDiscardedBrowsingContext source;

    nsString origin;

    nsString targetOrigin;

    nullable nsIURI targetOriginURI;

    nullable nsIPrincipal callerPrincipal;

    nullable nsIPrincipal subjectPrincipal;

    nullable nsIURI callerURI;

    bool isFromPrivateWindow;

    nsCString scriptLocation;

    uint64_t innerWindowId;

};

union SyncedContextInitializer

    BrowsingContextInitializer;

    WindowContextInitializer;

};

union BlobURLDataRequestResult

  IPCBlob;

  nsresult;

};

struct TextRecognitionQuad {

    float confidence;

    nsString string;

    ImagePoint[] points;

};

struct TextRecognitionResult {

    TextRecognitionQuad[] quads;

};

union TextRecognitionResultOrError {

    TextRecognitionResult;

    nsCString;

};

struct ClipboardReadRequest {

    ManagedEndpoint<PClipboardReadRequestChild> childEndpoint;

    nsCString[] availableTypes;

};

union ClipboardReadRequestOrError {

    ClipboardReadRequest;

    nsresult;

};

/**

 * 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.

*/

[NestedUpTo=inside_cpow, NeedsOtherPid, ChildProc=Content]

sync protocol PContent

    manages PBrowser;

    manages PClipboardReadRequest;

    manages PClipboardWriteRequest;

    manages PContentPermissionRequest;

    manages PCycleCollectWithLogs;

    manages PExtensions;

    manages PExternalHelperApp;

    manages PHal;

    manages PHandlerService;

    manages PHeapSnapshotTempFileHelper;

    manages PRemotePrintJob;

    manages PMedia;

    manages PNecko;

#ifdef MOZ_WEBSPEECH

    manages PSpeechSynthesis;

#endif

    manages PTestShell;

    manages PRemoteSpellcheckEngine;

    manages PWebBrowserPersistDocument;

#ifdef MOZ_WEBRTC

    manages PWebrtcGlobal;

#endif

    manages PURLClassifier;

    manages PURLClassifierLocal;

    manages PScriptCache;

    manages PSessionStorageObserver;

    manages PBenchmarkStorage;

    // 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

    // BrowserChild::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.

//

    // Separate messages are used for the parent and child side constructors due

    // to the differences in data and actor setup required.

//

    // Keep the last 3 attributes in sync with GetProcessAttributes!

parent:

    async ConstructPopupBrowser(ManagedEndpoint<PBrowserParent> browserEp,

                                ManagedEndpoint<PWindowGlobalParent> windowEp,

                                TabId tabId, IPCTabContext context,

                                WindowGlobalInit windowInit,

                                uint32_t chromeFlags);

    // TODO: Do I need to make this return something to watch for completion?

    // Guess we'll see how we end up triggering the actual print, for preview

    // this should be enough...

    async CloneDocumentTreeInto(MaybeDiscardedBrowsingContext aSourceBc,

                                MaybeDiscardedBrowsingContext aTargetBc,

                                PrintData aPrintData);

    async UpdateRemotePrintSettings(MaybeDiscardedBrowsingContext aBc,

                                    PrintData aPrintData);

    async PExtensions();

child:

    async ConstructBrowser(ManagedEndpoint<PBrowserChild> browserEp,

                           ManagedEndpoint<PWindowGlobalChild> windowEp,

                           TabId tabId,

                           IPCTabContext context,

                           WindowGlobalInit windowInit,

                           uint32_t chromeFlags, ContentParentId cpId,

                           bool isForBrowser, bool isTopLevel);

both:

    // For parent->child, aBrowser must be non-null; aContext can

    // be null to indicate the browser's current root document, or non-null

    // to persist a subdocument.  For child->parent, arguments are

    // ignored and should be null.

    async PWebBrowserPersistDocument(nullable PBrowser aBrowser,

                                     MaybeDiscardedBrowsingContext aContext);

    async RawMessage(JSActorMessageMeta aMetadata, ClonedMessageData? aData,

                     ClonedMessageData? aStack);

child:

    async InitGMPService(Endpoint<PGMPServiceChild> service);

    async InitProcessHangMonitor(Endpoint<PProcessHangMonitorChild> hangMonitor);

    async InitProfiler(Endpoint<PProfilerChild> aEndpoint);

    // Give the content process its endpoints to the compositor.

    async InitRendering(

      Endpoint<PCompositorManagerChild> compositor,

      Endpoint<PImageBridgeChild> imageBridge,

      Endpoint<PVRManagerChild> vr,

      Endpoint<PRemoteDecoderManagerChild> video,

      uint32_t[] namespaces);

    // Re-create the rendering stack using the given endpoints. This is sent

    // after the compositor process has crashed. The new endpoints may be to a

    // newly launched GPU process, or the compositor thread of the UI process.

    async ReinitRendering(

      Endpoint<PCompositorManagerChild> compositor,

      Endpoint<PImageBridgeChild> bridge,

      Endpoint<PVRManagerChild> vr,

      Endpoint<PRemoteDecoderManagerChild> video,

      uint32_t[] namespaces);

    async NetworkLinkTypeChange(uint32_t type);

    async SocketProcessCrashed();

    // Re-create the rendering stack for a device reset.

    async ReinitRenderingForDeviceReset();

/**

     * Enable system-level sandboxing features, if available.  Can

     * usually only be performed zero or one times.  The child may

     * abnormally exit if this fails; the details are OS-specific.

*/

    async SetProcessSandbox(FileDescriptor? aBroker);

    async RequestMemoryReport(uint32_t generation,

                              bool anonymize,

                              bool minimizeMemoryUsage,

                              FileDescriptor? DMDFile)

        returns (uint32_t aGeneration);

#if defined(XP_WIN)

/**

     * Used by third-party modules telemetry (aka "untrusted modules" telemetry)

     * to pull data from content processes.

*/

    async GetUntrustedModulesData() returns (UntrustedModulesData? data);

/**

    * This method is used to notifty a child process to start

    * processing module loading events in UntrustedModulesProcessor.

    * This should be called when the parent process has gone idle.

*/

    async UnblockUntrustedModulesThread();

#endif  // defined(XP_WIN)

/**

     * 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 ClearImageCacheFromPrincipal(nullable nsIPrincipal aPrincipal);

    async ClearImageCacheFromBaseDomain(nsCString aBaseDomain);

    async ClearImageCache(bool privateLoader, bool chrome);

    async ClearStyleSheetCache(nullable nsIPrincipal? aForPrincipal,

                               nsCString? aBaseDomain);

    async SetOffline(bool offline);

    async SetConnectivity(bool connectivity);

    async SetCaptivePortalState(int32_t aState);

    async SetTRRMode(ResolverMode aMode, ResolverMode aModeFromPref);

    async NotifyVisited(VisitedQueryResult[] uri);

/**

     * Tell the child that the system theme has changed, and that a repaint is

     * necessary.

*/

    async ThemeChanged(FullLookAndFeel lookAndFeelData, ThemeChangeKind aKind);

    async PreferenceUpdate(Pref pref);

    async VarUpdate(GfxVarUpdate var);

    async UpdatePerfStatsCollectionMask(uint64_t aMask);

    async CollectPerfStatsJSON() returns (nsCString aStats);

    async CollectScrollingMetrics() returns (uint32_t pixelsScrolled, uint32_t scrollDurationMS);

    async NotifyAlertsObserver(nsCString topic, nsString data);

    async GeolocationUpdate(nullable nsIDOMGeoPosition aPosition);

    async GeolocationError(uint16_t errorCode);

    async UpdateDictionaryList(nsCString[] dictionaries);

    async UpdateFontList(SystemFontList fontList);

/**

     * The shared font list has been updated by the parent, so child processes

     * should globally reflow everything to pick up new character coverage etc.

     * If aFullRebuild is true, child processes must discard and recreate

     * their mappings to the shmem blocks, as those are no longer valid.

     * This message has raised priority so that it will take precedence over

     * vsync messages to the child.

*/

    [Priority=mediumhigh] async RebuildFontList(bool aFullRebuild);

/**

     * The shared font list has been modified, potentially adding matches

     * for src:local() names that were previously not known, so content

     * may need to be reflowed.

*/

    async FontListChanged();

/**

     * The font list or prefs have been updated in such a way that we might need

     * to do a reflow and maybe reframe.

*/

    async ForceGlobalReflow(bool aNeedsReframe);

/**

     * A new shmem block has been added to the font list; the child process

     * should map the new block and add to its index.

*/

    async FontListShmBlockAdded(uint32_t aGeneration, uint32_t aIndex,

                                SharedMemoryHandle aHandle);

    async UpdateAppLocales(nsCString[] appLocales);

    async UpdateRequestedLocales(nsCString[] requestedLocales);

/**

     * The system timezone has changed; the child process should ensure that

     * calls to get the default timezone return the new value.

*/

    async SystemTimezoneChanged();

    async UpdateL10nFileSources(L10nFileSourceDescriptor[] sources);

    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 ApplicationBackground();

    async ApplicationForeground();

    async GarbageCollect();

    async CycleCollect();

    async UnlinkGhosts();

/**

     * Start accessibility engine in content process.

*/

    async ActivateA11y();

/**

     * 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, nsCString updateURL);

/**

     * Send the remote type associated with the content process.

*/

    async RemoteType(nsCString aRemoteType, nsCString aProfile);

/**

     * Send BlobURLRegistrationData to child process.

*/

    async InitBlobURLs(BlobURLRegistrationData[] registrations);

/**

     * Send JS{Content, Window}ActorInfos to child process.

*/

    async InitJSActorInfos(JSProcessActorInfo[] aContentInfos, JSWindowActorInfo[] aWindowInfos);

/**

     * Unregister a previously registered JSWindowActor in the child process.

*/

    async UnregisterJSWindowActor(nsCString name);

/**

     * Unregister a previously registered JSProcessActor in the child process.

*/

    async UnregisterJSProcessActor(nsCString name);

    async SetXPCOMProcessAttributes(XPCOMInitData xpcomInit,

                                    StructuredCloneData initialData,

                                    FullLookAndFeel lookAndFeeldata,

                                    /* used on MacOSX/Linux/Android only: */

                                    SystemFontList systemFontList,

                                    SharedMemoryHandle? sharedUASheetHandle,

                                    uintptr_t sharedUASheetAddress,

                                    SharedMemoryHandle[] sharedFontListBlocks,

                                    bool aIsStartingUp);

    // 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(nullable nsIURI uri, uint32_t type);

    async UnregisterSheet(nullable nsIURI uri, uint32_t type);

/**

     * Notify idle observers in the child

*/

    async NotifyIdleObserver(uint64_t observerId, nsCString topic, nsString str);

    async InvokeDragSession(MaybeDiscardedWindowContext aSourceWindowContext,

                            MaybeDiscardedWindowContext aSourceTopWindowContext,

                            IPCTransferableData[] transfers, uint32_t action);

    async UpdateDragSession(IPCTransferableData[] transfers, EventMessage message);

    async EndDragSession(bool aDoneDrag, bool aUserCancelled,

                         LayoutDeviceIntPoint aDragEndPoint,

                         uint32_t aKeyModifiers,

                         uint32_t aDropEffect);

    async DomainSetChanged(uint32_t aSetType, uint32_t aChangeType, nullable nsIURI aDomain);

/**

     * Notify the child that it will soon be asked to shutdown.

     * This is sent with high priority right before the normal shutdown.

*/

    [Priority=control] async ShutdownConfirmedHP();

/**

     * 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 cache is emptied.

*/

    async NotifyEmptyHTTPCache();

/**

     * Send a `push` event without data to a service worker in the child.

*/

    async Push(nsCString scope, nullable nsIPrincipal principal, nsString messageId);

/**

     * Send a `push` event with data to a service worker in the child.

*/

    async PushWithData(nsCString scope, nullable nsIPrincipal principal,

                       nsString messageId, uint8_t[] data);

/**

     * Send a `pushsubscriptionchange` event to a service worker in the child.

*/

    async PushSubscriptionChange(nsCString scope, nullable nsIPrincipal principal);

    async GetFilesResponse(nsID aID, GetFilesResponseResult aResult);

    async BlobURLRegistration(nsCString aURI, IPCBlob aBlob,

                              nullable nsIPrincipal aPrincipal, nsCString aPartitionKey);

    async BlobURLUnregistration(nsCString aURI);

    async GMPsChanged(GMPCapabilityData[] capabilities);

    async ProvideAnonymousTemporaryFile(uint64_t aID, FileDescOrError aFD);

    async SetPermissionsWithKey(nsCString aPermissionKey, Permission[] aPermissions);

    async RefreshScreens(ScreenDetails[] aScreens);

    async ShareCodeCoverageMutex(CrossProcessMutexHandle handle);

    async FlushCodeCoverageCounters() returns (bool unused);

/*

     * IPC message to enable the input event queue on the main thread of the

     * content process.

*/

    async SetInputEventQueueEnabled();

/*

     * IPC message to flush the input event queue on the main thread of the

     * content process.

     * When the ContentParent stops sending the input event with input priority,

     * there may be some pending events in the input event queue and normal

     * event queue. Here is a possible scenario.

     * R: Runnables.

     * D: Enable the input priority event.

     * E: Disable the input priority evnet.

     *                     D       E

     * Normal Queue: R1      R2      R3

     * Input Queue:     II      I2      I3

     * To avoid the newly added normal events (e.g. R2, which may be an input

     * event) preempt the pending input events (e.g. I1), or the newly added

     * input events (e.g. I3) preempt the pending normal events (e.g. R2), we

     * have to flush all pending events before enabling and disabling the input

     * priority event.

     * To flush the normal event queue and the input event queue, we use three

     * IPC messages as the followings.

     * FI: Flush the input queue.

     * SI: Suspend the input queue.

     * RI: Resume the input queue.

     * Normal Queue: R1    FI    RI R2   FI    RI R3

     * Input Queue:     II    SI      I2    SI       I3

     * When the flush input request is processed before the other two requests,

     * we consume all input events until the suspend request. After handling the

     * suspend request, we stop consuming the input events until the resume

     * request to make sure we consume all pending normal events.

     * If we process the suspend request before the other two requests, we

     * ignore the flush request and consume all pending normal events until the

     * resume request.

*/

    async FlushInputEventQueue();

/*

     * IPC message to resume consuming the pending events in the input event

     * queue.

*/

    async ResumeInputEventQueue();

/*

     * IPC message to suspend consuming the pending events in the input event

     * queue.

*/

    [Priority=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);

    // This message is sent to content processes, and triggers the creation of a

    // new HttpChannelChild that will be connected to the parent channel

    // represented by registrarId.

    // This is on PContent not PNecko, as PNecko may not be initialized yet.

    // The returned loadInfo needs to be set on the channel - since the channel

    // moved to a new process it now has different properties.

    async CrossProcessRedirect(RedirectToRealChannelArgs args,

                               Endpoint<PStreamFilterParent>[] aEndpoint)

        returns (nsresult rv);

/**

    * This method is used to notifty content process to start delayed autoplay

    * media via browsing context.

*/

    async StartDelayedAutoplayMediaComponents(MaybeDiscardedBrowsingContext aContext);

/**

     * This method is used to dispatch MediaControlAction to content process in

     * order to control media within a specific browsing context tree.

*/

    async UpdateMediaControlAction(MaybeDiscardedBrowsingContext aContext,

                                   MediaControlAction aAction);

    // Begin subscribing to a new BrowsingContextGroup, sending down the current

    // value for every individual BrowsingContext.

    async RegisterBrowsingContextGroup(uint64_t aGroupId, SyncedContextInitializer[] aInits);

    // The BrowsingContextGroup has been destroyed in the parent process. The

    // content process won't destroy the group until it receives this message or

    // during shutdown.

//

    // When the content process receives this message, all contexts in the group

    // should have already been destroyed.

    async DestroyBrowsingContextGroup(uint64_t aGroupId);

#if defined(MOZ_SANDBOX) && defined(MOZ_DEBUG) && defined(ENABLE_TESTS)

    // Initialize top-level actor for testing content process sandbox.

    async InitSandboxTesting(Endpoint<PSandboxTestingChild> aEndpoint);

#endif

    async LoadURI(MaybeDiscardedBrowsingContext aContext, nsDocShellLoadState aLoadState, bool aSetNavigating)

        returns (bool aSuccess);

    async InternalLoad(nsDocShellLoadState aLoadState);

    async DisplayLoadError(MaybeDiscardedBrowsingContext aContext, nsString aURI);

    async GoBack(MaybeDiscardedBrowsingContext aContext, int32_t? aCancelContentJSEpoch, bool aRequireUserInteraction, bool aUserActivation);

    async GoForward(MaybeDiscardedBrowsingContext aContext, int32_t? aCancelContentJSEpoch, bool aRequireUserInteraction, bool aUserActivation);

    async GoToIndex(MaybeDiscardedBrowsingContext aContext, int32_t aIndex, int32_t? aCancelContentJSEpoch, bool aUserActivation);

    async Reload(MaybeDiscardedBrowsingContext aContext, uint32_t aReloadFlags);

    async StopLoad(MaybeDiscardedBrowsingContext aContext, uint32_t aStopFlags);

    async OnAllowAccessFor(MaybeDiscardedBrowsingContext aParentContext,

                           nsCString aTrackingOrigin,

                           uint32_t aCookieBehavior,

                           StorageAccessPermissionGrantedReason aReason);

    async OnContentBlockingDecision(MaybeDiscardedBrowsingContext aContext,

                                    BlockingDecision aReason,

                                    uint32_t aRejectedReason);

/**

     * Abort orientationPendingPromises for documents in the child which

     * are part of a BrowsingContextGroup.

*/

    async AbortOrientationPendingPromises(MaybeDiscardedBrowsingContext aContext);

    async HistoryCommitIndexAndLength(MaybeDiscardedBrowsingContext aContext,

                                      uint32_t aIndex, uint32_t aLength,

                                      nsID aChangeID);

    async GetLayoutHistoryState(MaybeDiscardedBrowsingContext aContext)

        returns (nullable nsILayoutHistoryState aState, Wireframe? aWireframe);

    async DispatchLocationChangeEvent(MaybeDiscardedBrowsingContext aContext);

    // Dispatches a "beforeunload" event to each in-process content window in the

    // subtree beginning at `aStartingAt`, and returns the result as documented in

    // the `PermitUnloadResult` enum.

    async DispatchBeforeUnloadToSubtree(MaybeDiscardedBrowsingContext aStartingAt)

        returns (PermitUnloadResult result);

    // Update the cached list of codec supported in the given process.

    async UpdateMediaCodecsSupported(RemoteDecodeIn aLocation, MediaCodecsSupported aSupported);

    // Send the list of the supported mimetypes in the given process. GeckoView-specific

    async DecoderSupportedMimeTypes(nsCString[] supportedTypes);

    // Used to initialize the global variable in content processes with the

    // latched value in the parent process. See dom/LocalStorageCommon.h for more

    // details.

    async InitNextGenLocalStorageEnabled(bool enabled);

    async PRemotePrintJob();

parent:

    async SynchronizeLayoutHistoryState(MaybeDiscardedBrowsingContext aContext,

                                        nullable nsILayoutHistoryState aState);

    async SessionHistoryEntryTitle(MaybeDiscardedBrowsingContext aContext,

                                   nsString aTitle);

    async SessionHistoryEntryScrollRestorationIsManual(MaybeDiscardedBrowsingContext aContext,

                                                       bool aIsManual);

    async SessionHistoryEntryScrollPosition(MaybeDiscardedBrowsingContext aContext,

                                            int32_t aX, int32_t aY);

    async SessionHistoryEntryCacheKey(MaybeDiscardedBrowsingContext aContext,

                                      uint32_t aCacheKey);

    async SessionHistoryEntryStoreWindowNameInContiguousEntries(MaybeDiscardedBrowsingContext aContext,

                                                                nsString aName);

    async SessionHistoryEntryWireframe(MaybeDiscardedBrowsingContext aContext,

                                       Wireframe aWireframe);

    async GetLoadingSessionHistoryInfoFromParent(MaybeDiscardedBrowsingContext aContext)

        returns (LoadingSessionHistoryInfo? aLoadingInfo);

    async RemoveFromBFCache(MaybeDiscardedBrowsingContext aContext);

    async InitBackground(Endpoint<PBackgroundStarterParent> aEndpoint);

    async CreateGMPService();

    async InitStreamFilter(uint64_t channelId, nsString addonId)

        returns (Endpoint<PStreamFilterChild> aEndpoint);

    async PRemoteSpellcheckEngine();

    async InitCrashReporter(NativeThreadId tid);

    sync IsSecureURI(nullable nsIURI aURI, OriginAttributes aOriginAttributes)

        returns (bool isSecureURI);

    async AccumulateMixedContentHSTS(nullable nsIURI aURI, bool aActive,

                                     OriginAttributes aOriginAttributes);

    [Nested=inside_cpow] async PHal();

    async PHeapSnapshotTempFileHelper();

    async PNecko();

#ifdef MOZ_WEBSPEECH

    async PSpeechSynthesis();

#endif

    async PMedia();

#ifdef MOZ_WEBRTC

    async PWebrtcGlobal();

#endif

    async CreateAudioIPCConnection() returns (FileDescOrError fd);

    sync PURLClassifier(nullable nsIPrincipal principal)

        returns (bool success);

    async PURLClassifierLocal(nullable nsIURI uri, IPCURLClassifierFeature[] features);

    async PSessionStorageObserver();

    async PBenchmarkStorage();

    // Services remoting

    async StartVisitedQueries(nullable nsIURI[] uri);

    async SetURITitle(nullable nsIURI uri, nsString title);

    async LoadURIExternal(nullable nsIURI uri,

                          nullable nsIPrincipal triggeringPrincipal,

                          nullable nsIPrincipal redirectPrincipal,

                          MaybeDiscardedBrowsingContext browsingContext,

                          bool wasExternallyTriggered,

                          bool hasValidUserGestureActivation);

    async ExtProtocolChannelConnectParent(uint64_t registrarId);

    sync SyncMessage(nsString aMessage, ClonedMessageData aData)

      returns (StructuredCloneData[] retval);

    async ShowAlert(nullable nsIAlertNotification alert);

    async CloseAlert(nsString name, bool contextClosed);

    async DisableNotifications(nullable nsIPrincipal principal);

    async OpenNotificationSettings(nullable nsIPrincipal principal);

    async AddSecurityState(MaybeDiscardedWindowContext aContext, uint32_t aStateFlags);

    // 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);

    // Creates a helper for forwarding data from an nsExternalAppHandler

    // running in the content process, to one running in the parent

    // process.

    // Bug 1574372 aims to run nsExternalAppHandler entirely in the

    // parent so that we can remove this.

//

    // Serializes the uri, loadInfo, contentType, referrer, contentDisposition

    // headers and contentLength of the channel so that we can make them

    // available to the parent instance via a nsIChannel helper. Also

    // passes whether the original channel was an instance of nsIFileChannel.

//

    // aContext is the BrowsingContext that initiated the load, and created the

    // channel.

//

    // Pass true for aForceSave to always save this content to disk, regardless of

    // nsIMIMEInfo and other such influences.

    // Pass true for aShouldCloseWindow to specify that aContext was opened specifically

    // for this load, and should be closed once we've handled it.

    async PExternalHelperApp(nullable nsIURI uri,

                             LoadInfoArgs loadInfoArgs,

                             nsCString aMimeContentType,

                             nsCString aContentDisposition,

                             uint32_t aContentDispositionHint,

                             nsString aContentDispositionFilename,

                             bool aForceSave,

                             int64_t aContentLength,

                             bool aWasFileChannel,

                             nullable nsIURI aReferrer,

                             MaybeDiscardedBrowsingContext aContext,

                             bool aShouldCloseWindow);

    async PHandlerService();

    async AddGeolocationListener(bool highAccuracy);

    async RemoveGeolocationListener();

    async SetGeolocationHigherAccuracy(bool enable);

    async ConsoleMessage(nsString message);

    async ScriptErrorWithStack(nsString message, nsString sourceName, nsString sourceLine,

                               uint32_t lineNumber, uint32_t colNumber, uint32_t flags,

                               nsCString category, bool privateWindow,

                               bool fromChromeContext, ClonedMessageData stack);

    // Places the items within dataTransfer on the clipboard.

    async SetClipboard(IPCTransferable aTransferable,

                       int32_t aWhichClipboard, MaybeDiscardedWindowContext aRequestingWindowContext);

    // Given a list of supported types, returns the clipboard data for the

    // first type that matches.

    // aRequestingWindowContext is the window that is requesting the clipboard,

    // which is used for content analysis.

    sync GetClipboard(nsCString[] aTypes, int32_t aWhichClipboard,

                      MaybeDiscardedWindowContext aRequestingWindowContext)

        returns (IPCTransferableData transferableData);

    // Requests getting data from clipboard.

    async GetClipboardAsync(nsCString[] aTypes, int32_t aWhichClipboard,

                            MaybeDiscardedWindowContext aRequestingWindowContext,

                            nsIPrincipal aRequestingPrincipal)

        returns (ClipboardReadRequestOrError aClipboardReadRequestOrError);

    // Requests getting data from clipboard.

    sync GetClipboardDataSnapshotSync(nsCString[] aTypes, int32_t aWhichClipboard,

                                      MaybeDiscardedWindowContext aRequestingWindowContext)

        returns (ClipboardReadRequestOrError aClipboardReadRequestOrError);

    // 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);

/**

     * Notify the parent that the child has started a clipboard write request,

     * and that the data will be sent over another IPC message once it is ready.

     * @param  aClipboardType

     *         The clipboard type defined in nsIClipboard.

     * @param  aSettingWindowContext

     *         The window context that is setting the clipboard, if any. This is used

     *         to possibly bypass Content Analysis if a set clipboard and get clipboard

     *         operation are done on the same page.

*/

    async PClipboardWriteRequest(int32_t aClipboardType, MaybeDiscardedWindowContext aSettingWindowContext);

    sync GetIconForExtension(nsCString aFileExt, uint32_t aIconSize)

        returns (uint8_t[] bits);

    // Tell the parent that the child has gone idle for the first time.

    async FirstIdle();

    async CopyFavicon(nullable nsIURI oldURI, nullable nsIURI newURI, bool isPrivate);

    async FindImageText(IPCImage image, nsCString[] languages)

        returns (TextRecognitionResultOrError result);

    // 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);

/**

     * Notifies the parent that the child needs no more ForceKill dump.

*/

    [Priority=control] async NotifyShutdownSuccess();

/**

     * 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,

                                    nullable nsIPrincipal aPrincipal,

                                    nullable nsIPrincipal aTopLevelPrincipal,

                                    bool aIsHandlingUserInput,

                                    bool aMaybeUnsafePermissionDelegate,

                                    TabId tabId);

/**

     * If the profiler is running when the process shuts down, this sends the

     * profile data collected so far.

     * @param aProfile

     *   This may contain an empty string (unknown issue), an error message

     *   starting with '*', or a profile as a stringified JSON object.

*/

    async ShutdownProfile(nsCString aProfile);

/**

     * This sends any collected perf stats data on shutdown.

*/

    async ShutdownPerfStats(nsCString aPerfStats);

/**

     * A shared font list (see gfx/thebes/SharedFontList.*) contains a list

     * of shared-memory blocks that are used to store all the font list data.

     * The font list created in the parent process is the only one that can

     * create or store objects into the shared memory; content processes font

     * lists have read-only access to it.

     * To minimize the cost of record allocations, the shared font list

     * bump-allocates new objects that it adds to the shared memory blocks

     * (i.e. the records stored in the shared memory blocks are only ever

     * appended, and never freed except when the entire font list is

     * reconstructed).

     * When initially created by the parent process, the font list may contain

     * nothing except a header, and the list of the system's installed font

     * family names. Additional data about the families (styled faces available

     * and character coverage) is appended to the font list during the session

     * as a given font is considered for use, because loading all data for all

     * installed fonts during startup is too expensive/slow.

     * During content process launch, a content process's first step in

     * gaining access to the font list is to call GetFontListShmBlock,

     * passing index zero in order to get access to the first block, which

     * contains the font list header and the list of font-family records

     * (which may be virtually all uninitialized at this time, containing

     * nothing but the family names). Once a content process determines a

     * font-family name it wants to use (e.g. from a CSS font-family list, or

     * from preferences), if that Family record has not yet been initialized,

     * it will call InitializeFamily (below) to have the parent process

     * populate Face records in the shared memory with the family's styles.

     * The content process can then pick the face with best style match from

     * the available faces according to the CSS font matching algorithm, load

     * its character map, then send the map to the parent process using

     * SetCharacterMap (so that the parent process can share the map with all

     * processes to avoid duplication of work).

     * At some point, as the parent process adds data to the font list, a new

     * shared-memory block will probably be needed. At that point the parent

     * will create a new block and append it to its share memory block list.

     * The new Block index will start to appear in Pointer records in the

     * shared memory, and the content process's can then fetch those other

     * blocks using this function as needed.

     * @param aGeneration

     *   The font list has a Generation ID stored in its Header, and any time

     *   the parent process needs to reinitialize the list (because of a change

     *   in the available font repertoire) a new Generation ID is assigned.

     *   Content processes pass the Generation of the list they're using in

     *   all messages, so that the parent can recognize if they're out of date

     *   and safely ignore such messages. (When the parent rebuilds the list,

     *   it will notify all content processes, but they may still send a few

     *   messages that relate to the obsolete list before they have processed

     *   this notification.)

     * @param aIndex

     *   (Zero-based) index of the shared-memory block to be mapped.

     *   In a typical case, there will be a handful of blocks altogether, so

     *   each content process only needs to make this request a few times.

     * @returns aHandle

     *   Handle that can be used to construct a SharedMemory that maps the

     *   requested block of memory.

     *   If aGeneration does not match the parent's font list generation ID, or

     *   if requesting a block that does not exist (i.e. with aIndex greater

     *   than or equal to the number of blocks actually in existence), returns

     *   a null handle.

     * This is a sync message because the content process needs font data in

     * order to perform font-matching (e.g. during reflow), and cannot continue

     * until it has mapped the font-list memory.

*/

    sync GetFontListShmBlock(uint32_t aGeneration, uint32_t aIndex)

        returns (SharedMemoryHandle aHandle);

/**

     * Ask the parent to initialize a given font family, so that face metadata

     * will be available. Content processes will only call this for families

     * where the Face data has not yet been populated, so it will generally be

     * called no more than once per family. (It may not be needed at all, if

     * the parent process has already initialized the families that content

     * wants to use.)

     * @param aGeneration

     *   Font-list generation, so requests relating to an obsolete list can be

     *   ignored (see comments for GetFontListShmBlock).

     * @param aFamilyIndex

     *   The 0-based index of the Family within the font-list that a content

     *   process needs to use.

     * @param aLoadCmaps

     *   If true, the parent should eagerly load character maps for the faces

     *   in the family.

     * This is a sync message because the content process cannot complete its

     * font-matching until the family is fully populated with Face records.

     * If we make it async, content processes will reflow using fallbacks,

     * and then have to reflow again once all the font information needed

     * becomes available.

*/

    sync InitializeFamily(uint32_t aGeneration, uint32_t aFamilyIndex,

                          bool aLoadCmaps);

/**

     * Record the character map of a given Face in the font list.

     * @param aGeneration

     *   Font-list generation, so requests relating to an obsolete list can be

     *   ignored (see comments for GetFontListShmBlock).

     * @param aFamilyIndex

     *   Index of the font family in the font list (see aAlias for which list).

     * @param aAlias

     *   Whether aFamilyIndex refers to the Families() or AliasFamilies() list.

     * @param aFaceIndex

     *   Index of the face within the family's Faces() list.

     * @param aMap

     *   The character coverage map of the face. (This will be stored as a

     *   SharedBitSet record within the shared font list, and the Face record

     *   will be updated to reference it.)

*/

    async SetCharacterMap(uint32_t aGeneration, uint32_t aFamilyIndex, bool aAlias,

                          uint32_t aFaceIndex, gfxSparseBitSet aMap);

/**

     * Ask the parent to set up the merged charmap for a family, to accelerate

     * future fallback searches.

     * aFamilyIndex may refer to an element in either Families() or AliasFamilies(),

     * with aAlias determining which.

*/

    async SetupFamilyCharMap(uint32_t aGeneration, uint32_t aFamilyIndex, bool aAlias);

/**

     * Ask the parent to try and complete the InitOtherFamilyNames task, because

     * we're trying to look up a localized font name. This is a sync method so that

     * the update will be available before the child continues reflow; however, it

     * is possible the task will have timed-out in the parent and not actually

     * completed during this call.

     * @param aGeneration

     *   Font-list generation, so requests relating to an obsolete list can be

     *   ignored (see comments for GetFontListShmBlock).

     * @param aDefer

     *   Parameter aDeferOtherFamilyNamesLoading to be passed to

     *   gfxPlatformFontList::InitOtherFamilyNames, to determine whether name

     *   loading should be deferred to a background task or run immediately.

     * @param aLoaded

     *   Returns whether the font name loading process has completed.

     * TODO: This is currently a sync message but can probably be made async,

     * at the cost of an increased chance of some testcases failing because

     * they depend on lazily-loaded font names.

*/

    sync InitOtherFamilyNames(uint32_t aGeneration, bool aDefer) returns (bool aLoaded);

/**

     * Ask the parent to load all font character maps, as we need to do an

     * exhaustive font-fallback search. This is done asynchronously; when it

     * finishes, the parent will trigger global reflow so that font selection

     * is re-done in all content, making use of the newly-loaded cmaps.

     * Normally this will only happen once per browser session (unless the

     * font list is rebuilt due to installation/removal of system fonts).

     * @param aGeneration

     *   Font-list generation, so requests relating to an obsolete list can be

     *   ignored (see comments for GetFontListShmBlock).

     * @param aStartIndex

     *   The family index to start from; the sender has determined that cmaps

     *   up to this point are already loaded.

*/

    async StartCmapLoading(uint32_t aGeneration, uint32_t aStartIndex);

/**

     * Ask the parent for a specific hyphenation resource (identified by URI)

     * as a shared memory block.

     * This is a sync method because at the point where a content process finds

     * that it requires a particular hyphenation dictionary, this is blocking

     * reflow; making it async would require scheduling another reflow after

     * the resource is available, and a possible layout "jump" as line-breaks

     * change. Note that the content process retains a reference to each such

     * resource it requests, so it will only make this call once per locale for

     * which hyphenation data exists.

     * @param aURI

     *   The URI (which currently must always point to an omnijar resource)

     *   for the required hyphenation dictionary.

     * @param aHandle

     *   Returns the shmem handle to the resource (or an invalid shmem handle

     *   in case of failure).

     * @param aLoaded

     *   Returns the size in bytes of the resource.

*/

    sync GetHyphDict(nullable nsIURI aURI) returns (SharedMemoryHandle aHandle, uint32_t aSize);

    async CreateWindow(PBrowser aThisTab,

                       MaybeDiscardedBrowsingContext aParent,

                       PBrowser aNewTab,

                       uint32_t aChromeFlags,

                       bool aCalledFromJS,

                       bool aForPrinting,

                       bool aForWindowDotPrint,

                       nullable nsIURI aURIToLoad,

                       nsCString aFeatures,

                       Modifiers aModifiers,

                       nullable nsIPrincipal aTriggeringPrincipal,

                       nullable nsIContentSecurityPolicy aCsp,

                       nullable nsIReferrerInfo aReferrerInfo,

                       OriginAttributes aOriginAttributes)

        returns (CreatedWindowInfo window);

    async CreateWindowInDifferentProcess(

      PBrowser aThisTab,

      MaybeDiscardedBrowsingContext aParent,

      uint32_t aChromeFlags,

      bool aCalledFromJS,

      nullable nsIURI aURIToLoad,

      nsCString aFeatures,

      Modifiers aModifiers,

      nsString aName,

      nullable nsIPrincipal aTriggeringPrincipal,

      nullable nsIContentSecurityPolicy aCsp,

      nullable nsIReferrerInfo aReferrerInfo,

      OriginAttributes aOriginAttributes);

/**

     * 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, nullable nsIPrincipal principal,

                              nsString messageId);

/**

     * Notify `push-message` observers with data in the parent.

*/

    async NotifyPushObserversWithData(nsCString scope, nullable nsIPrincipal principal,

                                      nsString messageId, uint8_t[] data);

/**

     * Notify `push-subscription-change` observers in the parent.

*/

    async NotifyPushSubscriptionChangeObservers(nsCString scope,

                                                nullable nsIPrincipal principal);

     async GetFilesRequest(nsID aID, nsString aDirectory, bool aRecursiveFlag);

     async DeleteGetFilesRequest(nsID aID);

     async StoreAndBroadcastBlobURLRegistration(nsCString url, IPCBlob blob,

                                                nullable nsIPrincipal principal, nsCString aPartitionKey);

     async UnstoreAndBroadcastBlobURLUnregistration(nsCString url, nullable nsIPrincipal principal);

/**

     * Messages for communicating child Glean data to the parent process

*/

    async RecordPageLoadEvent(PageLoadExtra event);

/**

     * 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);

    async AddMemoryReport(MemoryReport aReport);

    async BHRThreadHang(HangDetails aHangDetails);

/*

     * Adds a certificate exception for the given hostname and port.

*/

    async AddCertException(nullable nsIX509Cert aCert, nsCString aHostName,

                           int32_t aPort, OriginAttributes aOriginAttributes,

                           bool aIsTemporary)

          returns (nsresult success);

/*

     * Determines whether storage access can be granted automatically by the

     * storage access API without showing a user prompt.

*/

    async AutomaticStorageAccessPermissionCanBeGranted(nullable nsIPrincipal aPrincipal)

          returns (bool success);

/*

     * A 3rd party tracking origin (aTrackingOrigin) has received the permission

     * granted to have access to aGrantedOrigin when loaded by aParentWindowId.

*/

    async StorageAccessPermissionGrantedForOrigin(uint64_t aTopLevelWindowId,

                                                  MaybeDiscardedBrowsingContext aParentContext,

                                                  nullable nsIPrincipal aTrackingPrincipal,

                                                  nsCString aTrackingOrigin,

                                                  int aAllowMode,

                                                  StorageAccessPermissionGrantedReason? aReason,

                                                  bool aFrameOnly)

          returns (bool unused);

    async CompleteAllowAccessFor(MaybeDiscardedBrowsingContext aParentContext,

                                 uint64_t aTopLevelWindowId,

                                 nullable nsIPrincipal aTrackingPrincipal,

                                 nsCString aTrackingOrigin,

                                 uint32_t aCookieBehavior,

                                 StorageAccessPermissionGrantedReason aReason)

          returns (StorageAccessPromptChoices? choice);

    async SetAllowStorageAccessRequestFlag(

                                 nullable nsIPrincipal aEmbeddingPrincipal,

                                 nullable nsIURI aEmbeddedOrigin)

          returns (bool success);

    async TestAllowStorageAccessRequestFlag(

                                 nullable nsIPrincipal aEmbeddedPrincipal,

                                 nullable nsIURI aEmbeddingOrigin)

          returns (bool success);

    async StoreUserInteractionAsPermission(nullable nsIPrincipal aPrincipal);

    async TestCookiePermissionDecided(MaybeDiscardedBrowsingContext aContext,

                         nullable nsIPrincipal aPrincipal)

          returns (bool? allowed);

    async TestStorageAccessPermission(nullable nsIPrincipal aEmbeddingPrincipal,

                         nsCString aEmbeddedOrigin)

          returns (bool? allowed);

/**

    * When media element's controlled state changed in the content process, we

    * have to notify the chrome process in order to update the status of the

    * corresponding media controller, which is used to control all media in the

    * certain tab. We would use the browsing context to find the corresponding

    * controller.

*/

    async NotifyMediaPlaybackChanged(MaybeDiscardedBrowsingContext aContext,

                                     MediaPlaybackState aState);

/**

    * When media became audible or inaudible in content process, we have to

    * notify chrome process in order to which tab is audible.

*/

    async NotifyMediaAudibleChanged(MaybeDiscardedBrowsingContext aContext,

                                    MediaAudibleState aState);

/**

    * When media enabled or disabled the Picture-in-Picture mode, we have to

    * update that to the media controller in the chrome process.

*/

    async NotifyPictureInPictureModeChanged(

        MaybeDiscardedBrowsingContext aContext, bool aEnabled);

/**

    * This method is used to update media session's status when it's being

    * created or destroyed.

*/

    async NotifyMediaSessionUpdated(MaybeDiscardedBrowsingContext aContext, bool aIsCreated);

/**

     * This method is used to update media session's media metadata whenever its

     * metadata is being updated.

*/

    async NotifyUpdateMediaMetadata(MaybeDiscardedBrowsingContext aContext,

                                    MediaMetadataBase? aMetadata);

/**

     * This method is used to update media session's playback state whenever its

     * playback state is changed.

*/

    async NotifyMediaSessionPlaybackStateChanged(

        MaybeDiscardedBrowsingContext aContext,

        MediaSessionPlaybackState aMetadata);

/**

     * This method is used to update media session's supported media session

     * action when the action becomes supported or unsupported.

*/

    async NotifyMediaSessionSupportedActionChanged(

        MaybeDiscardedBrowsingContext aContext,

        MediaSessionAction aAction,

        bool aEnabled);

/**

     * This method is used to notify the media controller in chrome process that

     * the media element in the browsing context entered fullscreen.

*/

    async NotifyMediaFullScreenState(

        MaybeDiscardedBrowsingContext aContext,

        bool aIsInFullScreen);

/**

     * This method is used to update media session's position state whenever its

     * position state is being updated.

*/

    async NotifyPositionStateChanged(

        MaybeDiscardedBrowsingContext aContext,

        PositionState? aState);

/**

     * This method will make canonical browsing context to update the count of

     * callers which want to keep the page from being suspended even if the page

     * is inactive.

*/

    async AddOrRemovePageAwakeRequest(MaybeDiscardedBrowsingContext aContext,

                                      bool aShouldAddCount);

#if defined(XP_WIN)

/**

     * Due to sandboxing, a child process's UntrustedModulesProcessor cannot

     * obtain enough information about a DLL file to determine its

     * trustworthiness. This API asks the chrome process to perform that

     * evaluation.

*/

    async GetModulesTrust(ModulePaths aModPaths, bool aRunAtNormalPriority)

        returns (ModulesMapResult? modMapResult);

#endif  // defined(XP_WIN)

/**

     * Used to route shutdown diagnostic info from the content process

     * ServiceWorkers to the parent process' ServiceWorkerManager's

     * ServiceWorkerShutdownBlocker. (The only other actor chain available

     * for this would be very convoluted and create ordering problems).

*/

    async ReportServiceWorkerShutdownProgress(uint32_t aShutdownStateId,

                                              Progress aProgress);

/**

     * Whenever a document is updating the OrientationLock, we need to

     * reject the orientationPendingPromises in other processes.

*/

    async AbortOtherOrientationPendingPromises(MaybeDiscardedBrowsingContext aContext);

    async HistoryReload(MaybeDiscardedBrowsingContext aContext, uint32_t aReloadFlags);

    async NotifyOnHistoryReload(MaybeDiscardedBrowsingContext aContext,

                                bool aForceReload)

            returns (bool canReload, nsDocShellLoadState? loadState,

                     bool? reloadActiveEntry);

    async HistoryCommit(MaybeDiscardedBrowsingContext aContext,

                        uint64_t aLoadID, nsID aChangeID, uint32_t aLoadType,

                        bool aPersist, bool aCloneEntryChildren,

                        bool aChannelExpired, uint32_t aCacheKey);

    async HistoryGo(MaybeDiscardedBrowsingContext aContext, int32_t aOffset,

                    uint64_t aHistoryEpoch, bool aRequireUserInteraction,

                    bool aUserActivation) returns(int32_t? requestedIndex);

    async BlobURLDataRequest(nsCString aBlobURL,

                             nullable nsIPrincipal aTriggeringPrincipal,

                             nullable nsIPrincipal aLoadingPrincipal,

                             OriginAttributes aOriginAttributes,

                             uint64_t aInnerWindowId,

                             nsCString aPartitionKey)

      returns (BlobURLDataRequestResult aResult);

    async SetActiveSessionHistoryEntry(MaybeDiscardedBrowsingContext context,

                                       nsPoint? previousScrollPosition,

                                       SessionHistoryInfo info, uint32_t loadType,

                                       uint32_t updatedCacheKey, nsID changeID);

    async ReplaceActiveSessionHistoryEntry(

        MaybeDiscardedBrowsingContext context, SessionHistoryInfo info);

    async RemoveDynEntriesFromActiveSessionHistoryEntry(

        MaybeDiscardedBrowsingContext aContext);

    async RemoveFromSessionHistory(

        MaybeDiscardedBrowsingContext aContext, nsID changeID);

    // Called when a nsDocShellLoadState which was received over IPC is

    // destroyed in the content process to clean up pending state left behind

    // tracking the load state in the parent process.

    [LazySend] async CleanupPendingLoadState(uint64_t aLoadIdentifier);

both:

    async ScriptError(nsString message, nsString sourceName, nsString sourceLine,

                      uint32_t lineNumber, uint32_t colNumber, uint32_t flags,

                      nsCString category, bool privateWindow, uint64_t innerWindowId,

                      bool fromChromeContext);

/**

     * Used in fission to report timing data when the parent window is in

     * another process. Child frame will send data to its ContentParent which

     * will then identify the ContentParent for the innerWindowId and pass

     * the data to the correct process.

     * loadInfo is passed in order to enforce same-origin security checks

     * aData must be non-null.

*/

    async ReportFrameTimingData(LoadInfoArgs loadInfo, nsString entryName,

                                nsString initiatorType,

                                UniquePtr<PerformanceTimingData> aData);

    async CommitBrowsingContextTransaction(MaybeDiscardedBrowsingContext aContext,

                                           BrowsingContextTransaction aTransaction,

                                           uint64_t aEpoch);

    async AsyncMessage(nsString aMessage, ClonedMessageData aData);

/**

     * Notify `push-subscription-modified` observers in the parent and child.

*/

    async NotifyPushSubscriptionModifiedObservers(nsCString scope,

                                                  nullable nsIPrincipal principal);

/**

     * Send a Push error message to all service worker clients in the parent or

     * child.

*/

    async PushError(nsCString scope, nullable nsIPrincipal principal, nsString message,

                    uint32_t flags);

/**

     * Creates a new BrowsingContext, initialized with the values provided in

     * `BrowsingContextInitializer`.

     * This message may only be sent to the parent in limited situations. If the

     * new BrowsingContext has a parent window, it must be owned by the

     * embedding process, otherwise it must be owned by the opener, if set.

*/

    [LazySend] async CreateBrowsingContext(uint64_t aGroupId, BrowsingContextInitializer aInit);

/**

     * If aDoDiscard is true, discards the passed-in BrowsingContext. If the

     * BrowsingContext has already been discarded, this message does nothing.

     * If the receiver is the parent process, resolves when all content

     * processes have flagged the BrowsingContext as discarded, and if the

     * receiver is a child process, resolves when that child process has flagged

     * the BrowsingContext as discarded.

*/

    async DiscardBrowsingContext(MaybeDiscardedBrowsingContext aContext, bool aDoDiscard)

            returns (uint64_t unused);

/**

     * aContext is the one that's taking the affect. Either the one that

     * receives the focus, or the one that loses the focus.

     * aAncestorBrowsingContextToFocus can only be non-null when

     * aShouldClearAncestorFocus is true. This is the browsing context

     * that receives the focus when aContext loses the focus.

*/

    async AdjustWindowFocus(MaybeDiscardedBrowsingContext aContext,

                            bool aIsVisible, uint64_t aActionId,

                            bool aShouldClearAncestorFocus,

                            MaybeDiscardedBrowsingContext aAncestorBrowsingContextToFocus);

    async WindowClose(MaybeDiscardedBrowsingContext aContext,

                      bool aTrustedCaller);

    async WindowFocus(MaybeDiscardedBrowsingContext aContext,

                      CallerType aCallerType, uint64_t aActionId);

    async WindowBlur(MaybeDiscardedBrowsingContext aContext,

                     CallerType aCallerType);

    async RaiseWindow(MaybeDiscardedBrowsingContext aContext, CallerType aCallerType, uint64_t aActionId);

    async ClearFocus(MaybeDiscardedBrowsingContext aContext);

    async SetFocusedBrowsingContext(MaybeDiscardedBrowsingContext aContext, uint64_t aActionId);

    async SetActiveBrowsingContext(MaybeDiscardedBrowsingContext aContext, uint64_t aActionId);

    async UnsetActiveBrowsingContext(MaybeDiscardedBrowsingContext aContext, uint64_t aActionId);

    async SetFocusedElement(MaybeDiscardedBrowsingContext aContext, bool aNeedsFocus);

    async FinalizeFocusOuter(MaybeDiscardedBrowsingContext aContext, bool aCanFocus,

                             CallerType aCallerType);

parent:

    [LazySend] async InsertNewFocusActionId(uint64_t aActionId);

    async BlurToParent(MaybeDiscardedBrowsingContext aFocusedBrowsingContext,

                      MaybeDiscardedBrowsingContext aBrowsingContextToClear,

                      MaybeDiscardedBrowsingContext aAncestorBrowsingContextToFocus,

                      bool aIsLeavingDocument, bool aAdjustWidget,

                      bool aBrowsingContextToClearHandled,

                      bool aAncestorBrowsingContextToFocusHandled, uint64_t aActionId);

child:

    async BlurToChild(MaybeDiscardedBrowsingContext aFocusedBrowsingContext,

                      MaybeDiscardedBrowsingContext aBrowsingContextToClear,

                      MaybeDiscardedBrowsingContext aAncestorBrowsingContextToFocus,

                      bool aIsLeavingDocument, bool aAdjustWidget, uint64_t aActionId);

    async SetupFocusedAndActive(MaybeDiscardedBrowsingContext aFocusedBrowsingContext,

                                uint64_t aActionIdForFocused,

                                MaybeDiscardedBrowsingContext aActiveBrowsingContext,

                                uint64_t aActionId);

    async ReviseActiveBrowsingContext(uint64_t aOldActionId,

                                      MaybeDiscardedBrowsingContext aActiveBrowsingContext,

                                      uint64_t aNewActionId);

    async ReviseFocusedBrowsingContext(uint64_t aOldActionId,

                                       MaybeDiscardedBrowsingContext aFocusedBrowsingContext,

                                       uint64_t aNewActionId);

both:

    async MaybeExitFullscreen(MaybeDiscardedBrowsingContext aContext);

    async WindowPostMessage(MaybeDiscardedBrowsingContext aContext,

                            ClonedOrErrorMessageData aMessage,

                            PostMessageData aData);

    async CommitWindowContextTransaction(MaybeDiscardedWindowContext aContext,

                                         WindowContextTransaction aTransaction,

                                         uint64_t aEpoch);

child:

    // NOTE: These methods are only needed on the child, as the parent

    // WindowContext is managed using the PWindowGlobal actor's lifecycle.

    [LazySend] async CreateWindowContext(WindowContextInitializer aInit);

    async DiscardWindowContext(uint64_t aContextId) returns (bool unused);

parent:

    // Temporary (bug 1641989) conduit for Glean data in content processes.

    // Sent from time-to-time to limit the amount of data vulnerable to loss.

    // Buffer contains bincoded Rust structs.

    async FOGData(ByteBuf buf);

child:

    // Temporary (bug 1641989) conduit for Glean data in content processes.

    // Tells the child to flush any pending data. Used in tests and ping

    // assembly. Buffer contains bincoded Rust structs.

    async FlushFOGData() returns (ByteBuf buf);

parent:

    async SetContainerFeaturePolicy(MaybeDiscardedBrowsingContext aContainerContext,

                                    nullable FeaturePolicy aContainerFeaturePolicy);

    // Obtain an icon from the system widget toolkit, in nsIconDecoder

    // format.  Not supported (or needed) on all platforms; see the

    // implementation in ContentParent::RecvGetSystemIcon for details.

    async GetSystemIcon(nullable nsIURI aURI) returns (nsresult aResult, ByteBuf? aData);

#ifdef FUZZING_SNAPSHOT

    // Used by the child process to signal that it is ready to start fuzzing.

    // This can in particular be used to wait for a particular event in a

    // test document before taking the snapshot and starting e.g. IPC fuzzing.

    async SignalFuzzingReady();

#endif

};

Source code

Revision control

Copy as Markdown

Other Tools