summaryrefslogtreecommitdiffstats
path: root/dom/chrome-webidl
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-19 01:47:29 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-19 01:47:29 +0000
commit0ebf5bdf043a27fd3dfb7f92e0cb63d88954c44d (patch)
treea31f07c9bcca9d56ce61e9a1ffd30ef350d513aa /dom/chrome-webidl
parentInitial commit. (diff)
downloadfirefox-esr-upstream/115.8.0esr.tar.xz
firefox-esr-upstream/115.8.0esr.zip
Adding upstream version 115.8.0esr.upstream/115.8.0esr
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'dom/chrome-webidl')
-rw-r--r--dom/chrome-webidl/BrowserSessionStore.webidl59
-rw-r--r--dom/chrome-webidl/BrowsingContext.webidl429
-rw-r--r--dom/chrome-webidl/ChannelWrapper.webidl578
-rw-r--r--dom/chrome-webidl/ChromeUtils.webidl1071
-rw-r--r--dom/chrome-webidl/ClonedErrorHolder.webidl18
-rw-r--r--dom/chrome-webidl/DOMCollectedFrames.webidl29
-rw-r--r--dom/chrome-webidl/DebuggerNotification.webidl58
-rw-r--r--dom/chrome-webidl/DebuggerNotificationObserver.webidl31
-rw-r--r--dom/chrome-webidl/DebuggerUtils.webidl16
-rw-r--r--dom/chrome-webidl/DocumentL10n.webidl47
-rw-r--r--dom/chrome-webidl/DominatorTree.webidl70
-rw-r--r--dom/chrome-webidl/Flex.webidl94
-rw-r--r--dom/chrome-webidl/Fluent.webidl51
-rw-r--r--dom/chrome-webidl/FrameLoader.webidl243
-rw-r--r--dom/chrome-webidl/Glean.webidl45
-rw-r--r--dom/chrome-webidl/GleanPings.webidl15
-rw-r--r--dom/chrome-webidl/HeapSnapshot.webidl105
-rw-r--r--dom/chrome-webidl/IOUtils.webidl774
-rw-r--r--dom/chrome-webidl/ImageText.webidl29
-rw-r--r--dom/chrome-webidl/InspectorUtils.webidl189
-rw-r--r--dom/chrome-webidl/IteratorResult.webidl15
-rw-r--r--dom/chrome-webidl/JSActor.webidl49
-rw-r--r--dom/chrome-webidl/JSProcessActor.webidl94
-rw-r--r--dom/chrome-webidl/JSWindowActor.webidl186
-rw-r--r--dom/chrome-webidl/L10nOverlays.webidl24
-rw-r--r--dom/chrome-webidl/L10nRegistry.webidl180
-rw-r--r--dom/chrome-webidl/MatchGlob.webidl26
-rw-r--r--dom/chrome-webidl/MatchPattern.webidl150
-rw-r--r--dom/chrome-webidl/MediaController.webidl75
-rw-r--r--dom/chrome-webidl/MessageManager.webidl576
-rw-r--r--dom/chrome-webidl/MozDocumentObserver.webidl20
-rw-r--r--dom/chrome-webidl/MozSharedMap.webidl54
-rw-r--r--dom/chrome-webidl/MozStorageAsyncStatementParams.webidl22
-rw-r--r--dom/chrome-webidl/MozStorageStatementParams.webidl22
-rw-r--r--dom/chrome-webidl/MozStorageStatementRow.webidl11
-rw-r--r--dom/chrome-webidl/NetDashboard.webidl155
-rw-r--r--dom/chrome-webidl/PathUtils.webidl175
-rw-r--r--dom/chrome-webidl/PlacesEvent.webidl547
-rw-r--r--dom/chrome-webidl/PlacesObservers.webidl31
-rw-r--r--dom/chrome-webidl/PrecompiledScript.webidl43
-rw-r--r--dom/chrome-webidl/PromiseDebugging.webidl110
-rw-r--r--dom/chrome-webidl/SessionStoreUtils.webidl169
-rw-r--r--dom/chrome-webidl/StructuredCloneHolder.webidl40
-rw-r--r--dom/chrome-webidl/TelemetryStopwatch.webidl238
-rw-r--r--dom/chrome-webidl/UniFFI.webidl107
-rw-r--r--dom/chrome-webidl/UserInteraction.webidl113
-rw-r--r--dom/chrome-webidl/WebExtensionContentScript.webidl174
-rw-r--r--dom/chrome-webidl/WebExtensionPolicy.webidl342
-rw-r--r--dom/chrome-webidl/WindowGlobalActors.webidl198
-rw-r--r--dom/chrome-webidl/XULFrameElement.webidl31
-rw-r--r--dom/chrome-webidl/XULMenuElement.webidl19
-rw-r--r--dom/chrome-webidl/XULTextElement.webidl15
-rw-r--r--dom/chrome-webidl/XULTreeElement.webidl180
-rw-r--r--dom/chrome-webidl/moz.build108
54 files changed, 8250 insertions, 0 deletions
diff --git a/dom/chrome-webidl/BrowserSessionStore.webidl b/dom/chrome-webidl/BrowserSessionStore.webidl
new file mode 100644
index 0000000000..23d3df9457
--- /dev/null
+++ b/dom/chrome-webidl/BrowserSessionStore.webidl
@@ -0,0 +1,59 @@
+/* -*- Mode: IDL; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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/. */
+
+// object contains either a CollectedFileListValue or a CollectedNonMultipleSelectValue or Sequence<DOMString>
+typedef (DOMString or boolean or object) FormDataValue;
+
+[ChromeOnly, Exposed=Window]
+interface SessionStoreFormData {
+ [Cached, Pure]
+ readonly attribute ByteString? url;
+
+ [Cached, Pure]
+ readonly attribute record<DOMString, FormDataValue>? id;
+
+ [Cached, Pure]
+ readonly attribute record<DOMString, FormDataValue>? xpath;
+
+ [Cached, Pure]
+ readonly attribute DOMString? innerHTML;
+
+ [Cached, Frozen, Pure]
+ readonly attribute sequence<SessionStoreFormData?>? children;
+
+ object toJSON();
+};
+
+[GenerateConversionToJS]
+dictionary SessionStoreDisplaySize {
+ unsigned long width;
+ unsigned long height;
+};
+
+[GenerateConversionToJS]
+dictionary SessionStoreZoomData {
+ double resolution;
+ SessionStoreDisplaySize displaySize;
+};
+
+[ChromeOnly, Exposed=Window]
+interface SessionStoreScrollData {
+ [Cached, Pure]
+ readonly attribute ByteString? scroll;
+
+ [Cached, Pure]
+ readonly attribute sequence<SessionStoreScrollData?>? children;
+
+ object toJSON();
+};
+
+[GenerateConversionToJS]
+dictionary UpdateSessionStoreData {
+ // This is docshell caps, but on-disk format uses the disallow property name.
+ ByteString? disallow;
+ boolean isPrivate;
+ SessionStoreFormData? formdata;
+ SessionStoreScrollData? scroll;
+};
diff --git a/dom/chrome-webidl/BrowsingContext.webidl b/dom/chrome-webidl/BrowsingContext.webidl
new file mode 100644
index 0000000000..db60c47593
--- /dev/null
+++ b/dom/chrome-webidl/BrowsingContext.webidl
@@ -0,0 +1,429 @@
+/* -*- Mode: IDL; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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/. */
+
+interface URI;
+interface nsIDocShell;
+interface nsISecureBrowserUI;
+interface nsISHEntry;
+interface nsIPrintSettings;
+interface nsIWebProgress;
+
+interface mixin LoadContextMixin {
+ readonly attribute WindowProxy? associatedWindow;
+
+ readonly attribute WindowProxy? topWindow;
+
+ readonly attribute Element? topFrameElement;
+
+ readonly attribute boolean isContent;
+
+ [SetterThrows]
+ attribute boolean usePrivateBrowsing;
+
+ readonly attribute boolean useRemoteTabs;
+
+ readonly attribute boolean useRemoteSubframes;
+
+ [BinaryName="useTrackingProtectionWebIDL", SetterThrows]
+ attribute boolean useTrackingProtection;
+
+ [NewObject, Throws]
+ readonly attribute any originAttributes;
+};
+
+/**
+ * Allowed CSS display modes. This needs to be kept in
+ * sync with similar values in ServoStyleConsts.h
+ */
+enum DisplayMode {
+ "browser",
+ "minimal-ui",
+ "standalone",
+ "fullscreen",
+};
+
+/**
+ * CSS prefers-color-scheme values.
+ */
+enum PrefersColorSchemeOverride {
+ "none",
+ "light",
+ "dark",
+};
+
+/**
+ * Allowed overrides of platform/pref default behaviour for touch events.
+ */
+enum TouchEventsOverride {
+ "disabled", // Force-disable touch events.
+ "enabled", // Force-enable touch events.
+ "none", // Don't override behaviour for touch events.
+};
+
+[Exposed=Window, ChromeOnly]
+interface BrowsingContext {
+ static BrowsingContext? get(unsigned long long aId);
+
+ static BrowsingContext? getFromWindow(WindowProxy window);
+
+ static BrowsingContext? getCurrentTopByBrowserId(unsigned long long aId);
+
+ sequence<BrowsingContext> getAllBrowsingContextsInSubtree();
+
+ readonly attribute DOMString name;
+
+ readonly attribute BrowsingContext? parent;
+
+ readonly attribute BrowsingContext top;
+
+ [Cached, Frozen, Pure]
+ readonly attribute sequence<BrowsingContext> children;
+
+ readonly attribute nsIDocShell? docShell;
+
+ readonly attribute Element? embedderElement;
+
+ readonly attribute unsigned long long id;
+
+ readonly attribute BrowsingContext? opener;
+
+ readonly attribute BrowsingContextGroup group;
+
+ readonly attribute WindowProxy? window;
+
+ readonly attribute WindowContext? currentWindowContext;
+
+ readonly attribute WindowContext? parentWindowContext;
+
+ readonly attribute WindowContext? topWindowContext;
+
+ readonly attribute boolean ancestorsAreCurrent;
+
+ [SetterThrows] attribute [LegacyNullToEmptyString] DOMString customPlatform;
+
+ [SetterThrows] attribute [LegacyNullToEmptyString] DOMString customUserAgent;
+
+ readonly attribute DOMString embedderElementType;
+
+ readonly attribute boolean createdDynamically;
+
+ readonly attribute boolean isInBFCache;
+
+ readonly attribute boolean isDiscarded;
+
+ /**
+ * The sandbox flags on the browsing context. These reflect the value of the
+ * sandbox attribute of the associated IFRAME or CSP-protectable content, if
+ * existent. See the HTML5 spec for more details.
+ * These flags on the browsing context reflect the current state of the
+ * sandbox attribute, which is modifiable. They are only used when loading new
+ * content, sandbox flags are also immutably set on the document when it is
+ * loaded.
+ * The sandbox flags of a document depend on the sandbox flags on its
+ * browsing context and of its parent document, if any.
+ * See nsSandboxFlags.h for the possible flags.
+ */
+ [SetterThrows] attribute unsigned long sandboxFlags;
+
+ [SetterThrows] attribute boolean isActive;
+
+ /**
+ * Sets whether this is an app tab. Non-same-origin link navigations from app
+ * tabs may be forced to open in new contexts, rather than in the same context.
+ */
+ [SetterThrows] attribute boolean isAppTab;
+
+ /**
+ * Sets whether this is BC has siblings **at the toplevel** (e.g. in a tabbed
+ * browser environment). Used to determine if web content can resize the top
+ * window. Never set correctly for non-top BCs.
+ */
+ [SetterThrows] attribute boolean hasSiblings;
+
+ // The inRDMPane flag indicates whether or not Responsive Design Mode is
+ // active for the browsing context.
+ [SetterThrows] attribute boolean inRDMPane;
+
+ [SetterThrows] attribute float fullZoom;
+
+ [SetterThrows] attribute float textZoom;
+
+ // Override the dots-per-CSS-pixel scaling factor in this BrowsingContext
+ // and all of its descendants. May only be set on the top BC, and should
+ // only be set from the parent process.
+ //
+ // A value of 0.0 causes us to use the global default scaling factor.
+ //
+ // NOTE that this override only affects a few minor things (the value exposed
+ // to devicePixelRatio and some media queries in content, and responsive
+ // image selection). Most notably, it does _not_ affect rendering.
+ //
+ // It is intended for RDM, and is probably not what you want in other cases.
+ // If you want to change the actual device pixel ratio that rendering code
+ // uses, you probably want to change the fullZoom.
+ [SetterThrows] attribute float overrideDPPX;
+
+ [SetterThrows] attribute boolean suspendMediaWhenInactive;
+
+ // Default value for nsIContentViewer::authorStyleDisabled in any new
+ // browsing contexts created as a descendant of this one.
+ //
+ // Valid only for top browsing contexts.
+ [SetterThrows] attribute boolean authorStyleDisabledDefault;
+
+ /**
+ * Whether this docshell should save entries in global history.
+ */
+ [SetterThrows] attribute boolean useGlobalHistory;
+
+ // Extension to give chrome JS the ability to set the window screen
+ // orientation while in RDM.
+ [Throws] undefined setRDMPaneOrientation(OrientationType type, float rotationAngle);
+
+ // Extension to give chrome JS the ability to set a maxTouchPoints override
+ // while in RDM.
+ [Throws] undefined setRDMPaneMaxTouchPoints(octet maxTouchPoints);
+
+ // The watchedByDevTools flag indicates whether or not DevTools are currently
+ // debugging this browsing context.
+ [SetterThrows] attribute boolean watchedByDevTools;
+
+ // Enable some service workers testing features, for DevTools.
+ [SetterThrows] attribute boolean serviceWorkersTestingEnabled;
+
+ // Enable media query medium override, for DevTools.
+ [SetterThrows] attribute DOMString mediumOverride;
+
+ // Color-scheme simulation, for DevTools.
+ [SetterThrows] attribute PrefersColorSchemeOverride prefersColorSchemeOverride;
+
+ /**
+ * A unique identifier for the browser element that is hosting this
+ * BrowsingContext tree. Every BrowsingContext in the element's tree will
+ * return the same ID in all processes and it will remain stable regardless of
+ * process changes. When a browser element's frameloader is switched to
+ * another browser element this ID will remain the same but hosted under the
+ * under the new browser element.
+ */
+ [SetterThrows] attribute unsigned long long browserId;
+
+ [SetterThrows] attribute DisplayMode displayMode;
+
+ /**
+ * This allows chrome to override the default choice of whether touch events
+ * are available in a specific BrowsingContext and its descendents.
+ */
+ readonly attribute TouchEventsOverride touchEventsOverride;
+
+ /**
+ * Returns true if the top-level BrowsingContext has been configured to
+ * default-target user-initiated link clicks to _blank.
+ */
+ readonly attribute boolean targetTopLevelLinkClicksToBlank;
+
+ /**
+ * Partially determines whether script execution is allowed in this
+ * BrowsingContext. Script execution will be permitted only if this
+ * attribute is true and script execution is allowed in the parent
+ * WindowContext.
+ *
+ * May only be set in the parent process.
+ */
+ [SetterThrows] attribute boolean allowJavascript;
+
+ /**
+ * Determines whether we're forcing a desktop-mode viewport. Only settable in
+ * the top browsing context from the parent process.
+ */
+ [SetterThrows] attribute boolean forceDesktopViewport;
+
+ /*
+ * Default load flags (as defined in nsIRequest) that will be set on all
+ * requests made by this BrowsingContext.
+ */
+ [SetterThrows] attribute long defaultLoadFlags;
+
+ /**
+ * The nsID of the browsing context in the session history.
+ */
+ [NewObject, Throws]
+ readonly attribute any historyID;
+
+ readonly attribute ChildSHistory? childSessionHistory;
+
+ // Resets the location change rate limit. Used for testing.
+ undefined resetLocationChangeRateLimit();
+
+ readonly attribute long childOffset;
+};
+
+BrowsingContext includes LoadContextMixin;
+
+[Exposed=Window, ChromeOnly]
+interface CanonicalBrowsingContext : BrowsingContext {
+ sequence<WindowGlobalParent> getWindowGlobals();
+
+ readonly attribute WindowGlobalParent? currentWindowGlobal;
+
+ readonly attribute WindowProxy? topChromeWindow;
+
+ // XXX(nika): This feels kinda hacky, but will do for now while we don't
+ // synchronously create WindowGlobalParent. It can throw if somehow the
+ // content process has died.
+ [Throws]
+ readonly attribute UTF8String? currentRemoteType;
+
+ readonly attribute WindowGlobalParent? embedderWindowGlobal;
+
+ undefined notifyStartDelayedAutoplayMedia();
+ [Throws] undefined notifyMediaMutedChanged(boolean muted);
+
+ readonly attribute nsISecureBrowserUI? secureBrowserUI;
+
+ /**
+ * Returns an nsIWebProgress object for this BrowsingContext, if this
+ * is a top-level content BC.
+ *
+ * Progress listeners attached to this will get notifications filtered by
+ * nsBrowserStatusFilter, and don't get any notifications from sub frames.
+ */
+ readonly attribute nsIWebProgress? webProgress;
+
+ static unsigned long countSiteOrigins(sequence<BrowsingContext> roots);
+
+ /**
+ * Loads a given URI. This will give priority to loading the requested URI
+ * in the object implementing this interface. If it can't be loaded here
+ * however, the URI dispatcher will go through its normal process of content
+ * loading.
+ *
+ * @param aURI
+ * The URI to load. No fixup will be performed on this URI.
+ * @param aLoadURIOptions
+ * A JSObject defined in LoadURIOptions.webidl holding info like e.g.
+ * the triggeringPrincipal, the referrer info.
+ */
+ [Throws]
+ undefined loadURI(URI aURI, optional LoadURIOptions aOptions = {});
+
+ /**
+ * Like `loadURI` but takes a DOMString instead. This will use nsIURIFixup
+ * to "fix up" the input if it doesn't parse as a string. If an existing
+ * DOM URL or nsIURI object is available to you, prefer using `loadURI`
+ * directly.
+ *
+ * @param aURI
+ * The URI to load. For HTTP and FTP URLs and possibly others,
+ * characters above U+007F will be converted to UTF-8 and then URL-
+ * escaped per the rules of RFC 2396.
+ * @param aLoadURIOptions
+ * A JSObject defined in LoadURIOptions.webidl holding info like e.g.
+ * the triggeringPrincipal, the referrer info.
+ */
+ [Throws]
+ undefined fixupAndLoadURIString(DOMString aURI, optional LoadURIOptions aOptions = {});
+
+ /**
+ * Print the current document.
+ *
+ * @param aOuterWindowID the ID of the outer window to print
+ * @param aPrintSettings print settings to use; printSilent can be
+ * set to prevent prompting.
+ * @return A Promise that resolves once printing is finished.
+ */
+ [NewObject, BinaryName="printJS"]
+ Promise<undefined> print(nsIPrintSettings aPrintSettings);
+
+ /**
+ * These methods implement the nsIWebNavigation methods of the same names
+ */
+ undefined goBack(optional long aCancelContentJSEpoch, optional boolean aRequireUserInteraction = false, optional boolean aUserActivation = false);
+ undefined goForward(optional long aCancelContentJSEpoch, optional boolean aRequireUserInteraction = false, optional boolean aUserActivation = false);
+ undefined goToIndex(long aIndex, optional long aCancelContentJSEpoch, optional boolean aUserActivation = false);
+ undefined reload(unsigned long aReloadFlags);
+ undefined stop(unsigned long aStopFlags);
+
+ readonly attribute nsISHistory? sessionHistory;
+ readonly attribute nsISHEntry? activeSessionHistoryEntry;
+
+ readonly attribute MediaController? mediaController;
+
+ undefined resetScalingZoom();
+
+ // The current URI loaded in this BrowsingContext according to nsDocShell.
+ // This may not match the current window global's document URI in some cases.
+ readonly attribute URI? currentURI;
+
+ undefined clearRestoreState();
+
+ // Force this browsing context, which must correspond to an app window, to
+ // be active regardless of the window being minimized or fully occluded.
+ [SetterThrows] attribute boolean forceAppWindowActive;
+
+ /**
+ * This allows chrome to override the default choice of whether touch events
+ * are available in a specific BrowsingContext and its descendents.
+ */
+ [SetterThrows] inherit attribute TouchEventsOverride touchEventsOverride;
+
+ /**
+ * Set to true to configure the top-level BrowsingContext to default-target
+ * user-initiated link clicks to _blank.
+ */
+ [SetterThrows] inherit attribute boolean targetTopLevelLinkClicksToBlank;
+
+ /**
+ * Set the cross-group opener of this BrowsingContext. This is used to
+ * retarget the download dialog to an opener window, and close this
+ * BrowsingContext, if the first load in a newly created BrowsingContext is a
+ * download.
+ *
+ * This value will be automatically set for documents created using
+ * `window.open`.
+ */
+ [Throws]
+ undefined setCrossGroupOpener(CanonicalBrowsingContext crossGroupOpener);
+
+ readonly attribute boolean isReplaced;
+
+
+ /**
+ * Notify APZ to start autoscrolling.
+ *
+ * (aAnchorX, aAnchorY) are the coordinates of the autoscroll anchor, in
+ * device coordinates relative to the screen.
+ * aScrollId and aPresShellId identify the scroll frame that content chose to
+ * scroll.
+ *
+ * Returns whether we were successfully able to notify APZ.
+ * If this function returns true, APZ (which may live in another process) may
+ * still reject the autoscroll, but it's then APZ's responsibility to notify
+ * content via an "autoscroll-rejected-by-apz" message.
+ */
+ boolean startApzAutoscroll(float aAnchorX, float aAnchorY,
+ unsigned long long aScrollId,
+ unsigned long aPresShellId);
+
+ /**
+ * Notify APZ to stop autoscrolling.
+ */
+ undefined stopApzAutoscroll(unsigned long long aScrollId,
+ unsigned long aPresShellId);
+
+ readonly attribute nsISHEntry? mostRecentLoadingSessionHistoryEntry;
+
+ /**
+ * Indicates if the embedder element or an ancestor has hidden
+ * visibility, or no frame.
+ */
+ readonly attribute boolean isUnderHiddenEmbedderElement;
+};
+
+[Exposed=Window, ChromeOnly]
+interface BrowsingContextGroup {
+ sequence<BrowsingContext> getToplevels();
+
+ readonly attribute unsigned long long id;
+};
diff --git a/dom/chrome-webidl/ChannelWrapper.webidl b/dom/chrome-webidl/ChannelWrapper.webidl
new file mode 100644
index 0000000000..b932e79c76
--- /dev/null
+++ b/dom/chrome-webidl/ChannelWrapper.webidl
@@ -0,0 +1,578 @@
+/* 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/. */
+
+interface LoadInfo;
+interface MozChannel;
+interface RemoteTab;
+interface URI;
+interface nsISupports;
+
+/**
+ * Load types that correspond to the external types in nsIContentPolicy.idl.
+ * Please also update that IDL when updating this list.
+ */
+enum MozContentPolicyType {
+ "main_frame",
+ "sub_frame",
+ "stylesheet",
+ "script",
+ "image",
+ "object",
+ "object_subrequest",
+ "xmlhttprequest",
+ "fetch",
+ "xslt",
+ "ping",
+ "beacon",
+ "xml_dtd",
+ "font",
+ "media",
+ "websocket",
+ "csp_report",
+ "imageset",
+ "web_manifest",
+ "speculative",
+ "other"
+};
+
+/**
+ * String versions of CLASSIFIED_* tracking flags from nsIClassifiedChannel.idl
+ */
+enum MozUrlClassificationFlags {
+ "fingerprinting",
+ "fingerprinting_content",
+ "cryptomining",
+ "cryptomining_content",
+ "emailtracking",
+ "emailtracking_content",
+ "tracking",
+ "tracking_ad",
+ "tracking_analytics",
+ "tracking_social",
+ "tracking_content",
+ "socialtracking",
+ "socialtracking_facebook",
+ "socialtracking_linkedin",
+ "socialtracking_twitter",
+ "any_basic_tracking",
+ "any_strict_tracking",
+ "any_social_tracking"
+};
+
+/**
+ * A thin wrapper around nsIChannel and nsIHttpChannel that allows JS
+ * callers to access them without XPConnect overhead.
+ */
+[ChromeOnly, Exposed=Window]
+interface ChannelWrapper : EventTarget {
+ /**
+ * Returns the wrapper instance for the given channel. The same wrapper is
+ * always returned for a given channel.
+ */
+ static ChannelWrapper get(MozChannel channel);
+
+ /**
+ * Returns the wrapper instance for the given channel. The same wrapper is
+ * always returned for a given channel.
+ */
+ static ChannelWrapper? getRegisteredChannel(unsigned long long aChannelId,
+ WebExtensionPolicy extension,
+ RemoteTab? remoteTab);
+
+ /**
+ * A unique ID for for the requests which remains constant throughout the
+ * redirect chain.
+ */
+ [Constant, StoreInSlot]
+ readonly attribute unsigned long long id;
+
+ // Not technically pure, since it's backed by a weak reference, but if JS
+ // has a reference to the previous value, we can depend on it not being
+ // collected.
+ [Pure]
+ attribute MozChannel? channel;
+
+
+ /**
+ * Cancels the request with the given nsresult status code.
+ *
+ * The optional reason parameter should be one of the BLOCKING_REASON
+ * constants from nsILoadInfo.idl
+ */
+ [Throws]
+ undefined cancel(unsigned long result, optional unsigned long reason = 0);
+
+ /**
+ * Redirects the wrapped HTTP channel to the given URI. For other channel
+ * types, this method will throw. The redirect is an internal redirect, and
+ * the behavior is the same as nsIHttpChannel.redirectTo.
+ */
+ [Throws]
+ undefined redirectTo(URI url);
+
+ /**
+ * Requests an upgrade of the HTTP channel to a secure request. For other channel
+ * types, this method will throw. The redirect is an internal redirect, and
+ * the behavior is the same as nsIHttpChannel.upgradeToSecure. Setting this
+ * flag is only effective during the WebRequest.onBeforeRequest in
+ * Web Extensions, calling this at any other point during the request will
+ * have no effect. Setting this flag in addition to calling redirectTo
+ * results in the redirect happening rather than the upgrade request.
+ */
+ [Throws]
+ undefined upgradeToSecure();
+
+ /**
+ * Suspends the underlying channel. The profilerText parameter is only used
+ * to annotate profiles.
+ */
+ [Throws]
+ undefined suspend(ByteString profileMarkerText);
+
+ /**
+ * Resumes (un-suspends) the underlying channel.
+ */
+ [Throws]
+ undefined resume();
+
+ /**
+ * The content type of the request, usually as read from the Content-Type
+ * header. This should be used in preference to the header to determine the
+ * content type of the channel.
+ */
+ [Pure]
+ attribute ByteString contentType;
+
+
+ /**
+ * For HTTP requests, the request method (e.g., GET, POST, HEAD). For other
+ * request types, returns an empty string.
+ */
+ [Cached, Pure]
+ readonly attribute ByteString method;
+
+ /**
+ * For requests with LoadInfo, the content policy type that corresponds to
+ * the request. For requests without LoadInfo, returns "other".
+ */
+ [Cached, Pure]
+ readonly attribute MozContentPolicyType type;
+
+
+ /**
+ * When true, the request is currently suspended by the wrapper. When false,
+ * the request is not suspended by the wrapper, but may still be suspended
+ * by another caller.
+ */
+ [Pure]
+ readonly attribute boolean suspended;
+
+
+ /**
+ * The final URI of the channel (as returned by NS_GetFinalChannelURI) after
+ * any redirects have been processed.
+ */
+ [Cached, Pure]
+ readonly attribute URI finalURI;
+
+ /**
+ * The string version of finalURI (but cheaper to access than
+ * finalURI.spec).
+ */
+ [Cached, Pure]
+ readonly attribute DOMString finalURL;
+
+
+ /**
+ * Returns true if the request matches the given request filter, and the
+ * given extension has permission to access it.
+ */
+ boolean matches(optional MozRequestFilter filter = {},
+ optional WebExtensionPolicy? extension = null,
+ optional MozRequestMatchOptions options = {});
+
+
+ /**
+ * Register's this channel as traceable by the given add-on when accessed
+ * via the process of the given RemoteTab.
+ */
+ undefined registerTraceableChannel(WebExtensionPolicy extension, RemoteTab? remoteTab);
+
+ /**
+ * The current HTTP status code of the request. This will be 0 if a response
+ * has not yet been received, or if the request is not an HTTP request.
+ */
+ [Cached, Pure]
+ readonly attribute unsigned long statusCode;
+
+ /**
+ * The HTTP status line for the request (e.g., "HTTP/1.0 200 Success"). This
+ * will be an empty string if a response has not yet been received, or if
+ * the request is not an HTTP request.
+ */
+ [Cached, Pure]
+ readonly attribute ByteString statusLine;
+
+
+ /**
+ * If the request has failed or been canceled, an opaque string representing
+ * the error. For requests that failed at the NSS layer, this is an NSS
+ * error message. For requests that failed for any other reason, it is the
+ * name of an nsresult error code. For requests which haven't failed, this
+ * is null.
+ *
+ * This string is used in the error message when notifying extension
+ * webRequest listeners of failure. The documentation specifically states
+ * that this value MUST NOT be parsed, and is only meant to be displayed to
+ * humans, but we all know how that works in real life.
+ */
+ [Cached, Pure]
+ readonly attribute DOMString? errorString;
+
+ /**
+ * Dispatched when the channel is closed with an error status. Check
+ * errorString for the error details.
+ */
+ attribute EventHandler onerror;
+
+ /**
+ * Checks the request's current status and dispatches an error event if the
+ * request has failed and one has not already been dispatched.
+ */
+ undefined errorCheck();
+
+
+ /**
+ * Dispatched when the channel begins receiving data.
+ */
+ attribute EventHandler onstart;
+
+ /**
+ * Dispatched when the channel has finished receiving data.
+ */
+ attribute EventHandler onstop;
+
+
+ /**
+ * Information about the proxy server which is handling this request, or
+ * null if the request is not proxied.
+ */
+ [Cached, Frozen, GetterThrows, Pure]
+ readonly attribute MozProxyInfo? proxyInfo;
+
+ /**
+ * For HTTP requests, the IP address of the remote server handling the
+ * request. For other request types, returns null.
+ */
+ [Cached, Pure]
+ readonly attribute ByteString? remoteAddress;
+
+
+ /**
+ * The LoadInfo object for this channel, if available. Null for channels
+ * without load info, until support for those is removed.
+ */
+ [Cached, Pure]
+ readonly attribute LoadInfo? loadInfo;
+
+ /**
+ * True if this load for a service worker script (either a main script or import scripts).
+ */
+ [Cached, Pure]
+ readonly attribute boolean isServiceWorkerScript;
+
+ /**
+ * True if this load was triggered by a system caller. This currently always
+ * false if the request has no LoadInfo or is a top-level document load.
+ */
+ [Cached, Pure]
+ readonly attribute boolean isSystemLoad;
+
+ /**
+ * The URL of the principal that triggered this load. This is equivalent to
+ * the LoadInfo's triggeringPrincipal, and will only ever be null for
+ * requests without LoadInfo.
+ */
+ [Cached, Pure]
+ readonly attribute ByteString? originURL;
+
+ /**
+ * The URL of the document loading the content for this request. This is
+ * equivalent to the LoadInfo's loadingPrincipal. This may only ever be null
+ * for top-level requests and requests without LoadInfo.
+ */
+ [Cached, Pure]
+ readonly attribute ByteString? documentURL;
+
+ /**
+ * The URI version of originURL. Will be null only when originURL is null.
+ */
+ [Pure]
+ readonly attribute URI? originURI;
+
+ /**
+ * The URI version of documentURL. Will be null only when documentURL is
+ * null.
+ */
+ [Pure]
+ readonly attribute URI? documentURI;
+
+
+ /**
+ * True if extensions may modify this request. This is currently false only
+ * if the request belongs to a document which has access to the
+ * mozAddonManager API.
+ */
+ [Cached, GetterThrows, Pure]
+ readonly attribute boolean canModify;
+
+
+ /**
+ * The BrowsingContext ID of the frame that the request belongs to, or 0 if it
+ * is a top-level load or does not belong to a document.
+ */
+ [Cached, Constant]
+ readonly attribute long long frameId;
+
+ /**
+ * The BrowsingContext ID of the parent frame of the window that the request
+ * belongs to, 0 if that parent frame is the top-level frame, and -1 if the
+ * request belongs to a top-level frame.
+ */
+ [Cached, Constant]
+ readonly attribute long long parentFrameId;
+
+ /**
+ * For cross-process requests, the <browser> or <iframe> element to which the
+ * content loading this request belongs. For requests that don't originate
+ * from a remote browser, this is null.
+ *
+ * This is not an Element because those are by default only exposed in
+ * Window, but we're exposed in System.
+ */
+ [Cached, Pure]
+ readonly attribute nsISupports? browserElement;
+
+ /**
+ * Returns an array of objects that combine the url and frameId from the
+ * ancestorPrincipals and ancestorOuterWindowIDs on loadInfo.
+ * The immediate parent is the first entry, the last entry is always the top
+ * level frame. It will be an empty list for toplevel window loads and
+ * non-subdocument resource loads within a toplevel window. For the latter,
+ * originURL will provide information on what window is doing the load. It
+ * will be null if the request is not associated with a window (e.g. XHR with
+ * mozBackgroundRequest = true).
+ */
+ [Cached, Frozen, GetterThrows, Pure]
+ readonly attribute sequence<MozFrameAncestorInfo>? frameAncestors;
+
+ /**
+ * For HTTP requests, returns an array of request headers which will be, or
+ * have been, sent with this request.
+ *
+ * For non-HTTP requests, throws NS_ERROR_UNEXPECTED.
+ */
+ [Throws]
+ sequence<MozHTTPHeader> getRequestHeaders();
+
+ /**
+ * For HTTP requests: returns the value of the request header, null if not set.
+ *
+ * For non-HTTP requests, throws NS_ERROR_UNEXPECTED.
+ */
+ [Throws]
+ ByteString? getRequestHeader(ByteString header);
+
+ /**
+ * For HTTP requests, returns an array of response headers which were
+ * received for this request, in the same format as returned by
+ * getRequestHeaders.
+
+ * Throws NS_ERROR_NOT_AVAILABLE if a response has not yet been received, or
+ * NS_ERROR_UNEXPECTED if the channel is not an HTTP channel.
+ *
+ * Note: The Content-Type header is handled specially. That header is
+ * usually not mutable after the request has been received, and the content
+ * type must instead be changed via the contentType attribute. If a caller
+ * attempts to set the Content-Type header via setRequestHeader, however,
+ * that value is assigned to the contentType attribute and its original
+ * string value is cached. That original value is returned in place of the
+ * actual Content-Type header.
+ */
+ [Throws]
+ sequence<MozHTTPHeader> getResponseHeaders();
+
+ /**
+ * Sets the given request header to the given value, overwriting any
+ * previous value. Setting a header to a null string has the effect of
+ * removing it. If merge is true, then the passed value will be merged
+ * to any existing value that exists for the header. Otherwise, any prior
+ * value for the header will be overwritten. Merge is ignored for headers
+ * that cannot be merged.
+ *
+ * For non-HTTP requests, throws NS_ERROR_UNEXPECTED.
+ */
+ [Throws]
+ undefined setRequestHeader(ByteString header,
+ ByteString value,
+ optional boolean merge = false);
+
+ /**
+ * Sets the given response header to the given value, overwriting any
+ * previous value. Setting a header to a null string has the effect of
+ * removing it. If merge is true, then the passed value will be merged
+ * to any existing value that exists for the header (e.g. handling multiple
+ * Set-Cookie headers). Otherwise, any prior value for the header will be
+ * overwritten. Merge is ignored for headers that cannot be merged.
+ *
+ * For non-HTTP requests, throws NS_ERROR_UNEXPECTED.
+ *
+ * Note: The content type header is handled specially by this function. See
+ * getResponseHeaders() for details.
+ */
+ [Throws]
+ undefined setResponseHeader(ByteString header,
+ ByteString value,
+ optional boolean merge = false);
+
+ /**
+ * Provides the tracking classification data when it is available.
+ */
+ [Cached, Frozen, GetterThrows, Pure]
+ readonly attribute MozUrlClassification? urlClassification;
+
+ /**
+ * Indicates if this response and its content window hierarchy is third
+ * party.
+ */
+ [Cached, Constant]
+ readonly attribute boolean thirdParty;
+
+ /**
+ * The current bytes sent of the request. This will be 0 if a request has not
+ * sent yet, or if the request is not an HTTP request.
+ */
+ [Cached, Pure]
+ readonly attribute unsigned long long requestSize;
+
+ /**
+ * The current bytes received of the response. This will be 0 if a response
+ * has not recieved yet, or if the request is not an HTTP response.
+ */
+ [Cached, Pure]
+ readonly attribute unsigned long long responseSize;
+};
+
+/**
+ * Wrapper for first and third party tracking classification data.
+ */
+dictionary MozUrlClassification {
+ required sequence<MozUrlClassificationFlags> firstParty;
+ required sequence<MozUrlClassificationFlags> thirdParty;
+};
+
+/**
+ * Information about the proxy server handing a request. This is approximately
+ * equivalent to nsIProxyInfo.
+ */
+dictionary MozProxyInfo {
+ /**
+ * The hostname of the server.
+ */
+ required ByteString host;
+ /**
+ * The TCP port of the server.
+ */
+ required long port;
+ /**
+ * The type of proxy (e.g., HTTP, SOCKS).
+ */
+ required ByteString type;
+
+ /**
+ * True if the proxy is responsible for DNS lookups.
+ */
+ required boolean proxyDNS;
+
+ /**
+ * The authentication username for the proxy, if any.
+ */
+ ByteString? username = null;
+
+ /**
+ * The timeout, in seconds, before the network stack will failover to the
+ * next candidate proxy server if it has not received a response.
+ */
+ unsigned long failoverTimeout;
+
+ /**
+ * Any non-empty value will be passed directly as Proxy-Authorization header
+ * value for the CONNECT request attempt. However, this header set on the
+ * resource request itself takes precedence.
+ */
+ ByteString? proxyAuthorizationHeader = null;
+
+ /**
+ * An optional key used for additional isolation of this proxy connection.
+ */
+ ByteString? connectionIsolationKey = null;
+};
+
+/**
+ * MozFrameAncestorInfo combines loadInfo::AncestorPrincipals with
+ * loadInfo::AncestorOuterWindowIDs for easier access in the WebRequest API.
+ *
+ * url represents the parent of the loading window.
+ * frameId is the outerWindowID for the parent of the loading window.
+ *
+ * For further details see nsILoadInfo.idl and Document::AncestorPrincipals.
+ */
+dictionary MozFrameAncestorInfo {
+ required ByteString url;
+ required unsigned long long frameId;
+};
+
+/**
+ * Represents an HTTP request or response header.
+ */
+dictionary MozHTTPHeader {
+ /**
+ * The case-insensitive, non-case-normalized header name.
+ */
+ required ByteString name;
+ /**
+ * The header value.
+ */
+ required ByteString value;
+};
+
+/**
+ * An object used for filtering requests.
+ */
+dictionary MozRequestFilter {
+ /**
+ * If present, the request only matches if its `type` attribute matches one
+ * of the given types.
+ */
+ sequence<MozContentPolicyType>? types = null;
+
+ /**
+ * If present, the request only matches if its finalURI matches the given
+ * match pattern set.
+ */
+ MatchPatternSet? urls = null;
+
+ /**
+ * If present, the request only matches if the loadInfo privateBrowsingId matches
+ * against the given incognito value.
+ */
+ boolean? incognito = null;
+};
+
+dictionary MozRequestMatchOptions {
+ /**
+ * True if we're matching for the proxy portion of a proxied request.
+ */
+ boolean isProxy = false;
+};
diff --git a/dom/chrome-webidl/ChromeUtils.webidl b/dom/chrome-webidl/ChromeUtils.webidl
new file mode 100644
index 0000000000..5f85b521e5
--- /dev/null
+++ b/dom/chrome-webidl/ChromeUtils.webidl
@@ -0,0 +1,1071 @@
+/* -*- Mode: IDL; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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/.
+ */
+
+interface nsIDOMProcessChild;
+interface nsIDOMProcessParent;
+interface Principal;
+
+/**
+ * An optimized QueryInterface method, generated by generateQI.
+ *
+ * For JS callers, this behaves like a normal QueryInterface function. When
+ * called with a supported interface, it returns its `this` object. When
+ * called with an unsupported interface, it throws NS_ERROR_NO_INTERFACE.
+ *
+ * C++ callers use a fast path, and never call the JSAPI or WebIDL methods of
+ * this object.
+ */
+[ChromeOnly, Exposed=Window]
+interface MozQueryInterface {
+ [Throws]
+ legacycaller any (any aIID);
+};
+
+/**
+ * Options for a marker created with the addProfilerMarker method.
+ * All fields are optional.
+ */
+dictionary ProfilerMarkerOptions {
+ // A timestamp to use as the start time of the marker.
+ // If no start time is provided, the marker will have no duration.
+ // In window and ChromeWorker contexts, use a timestamp from
+ // `performance.now()`.
+ // In JS modules, use `Cu.now()` to get a timestamp.
+ DOMHighResTimeStamp startTime = 0;
+
+ // If captureStack is true, a profiler stack will be captured and associated
+ // with the marker.
+ boolean captureStack = false;
+
+ // Markers are created by default in the JavaScript category, but this can be
+ // overridden.
+ // Examples of correct values: "JavaScript", "Test", "Other", ...
+ // See ProfilingCategoryList.h for the complete list of valid values.
+ // Using an unrecognized value will set the category to "Other".
+ ByteString category = "JavaScript";
+
+ // Inner window ID to use for the marker. If the global object is a window,
+ // the inner window id of the marker will be set automatically.
+ // If a marker that relates to a specific window is added from a JS module,
+ // setting the inner window id will allow the profiler to show which window
+ // the marker applies to.
+ unsigned long long innerWindowId = 0;
+};
+
+dictionary InteractionData {
+ unsigned long interactionCount = 0;
+ unsigned long interactionTimeInMilliseconds = 0;
+ unsigned long scrollingDistanceInPixels = 0;
+};
+
+/**
+ * Confidence value of credit card fields. This is used by the native
+ * Fathom Credit Card model to return the score to JS.
+ */
+dictionary FormAutofillConfidences {
+ double ccNumber = 0;
+ double ccName = 0;
+};
+
+/**
+ * A collection of static utility methods that are only exposed to system code.
+ * This is exposed in all the system globals where we can expose stuff by
+ * default, so should only include methods that are **thread-safe**.
+ */
+[ChromeOnly, Exposed=(Window,Worker)]
+namespace ChromeUtils {
+ /**
+ * Get the |NodeId| for the given JS Object.
+ * |NodeId| is the identifier of |JS::ubi::Node|.
+ */
+ NodeId getObjectNodeId(object obj);
+
+ /**
+ * Serialize a snapshot of the heap graph, as seen by |JS::ubi::Node| and
+ * restricted by |boundaries|, and write it to the provided file path.
+ *
+ * @param boundaries The portion of the heap graph to write.
+ *
+ * @returns The path to the file the heap snapshot was written
+ * to. This is guaranteed to be within the temp
+ * directory and its file name will match the regexp
+ * `\d+(\-\d+)?\.fxsnapshot`.
+ */
+ [Throws]
+ DOMString saveHeapSnapshot(optional HeapSnapshotBoundaries boundaries = {});
+
+ /**
+ * This is the same as saveHeapSnapshot, but with a different return value.
+ *
+ * @returns The snapshot ID of the file. This is the file name
+ * without the temp directory or the trailing
+ * `.fxsnapshot`.
+ */
+ [Throws]
+ DOMString saveHeapSnapshotGetId(optional HeapSnapshotBoundaries boundaries = {});
+
+ /**
+ * Deserialize a core dump into a HeapSnapshot.
+ *
+ * @param filePath The file path to read the heap snapshot from.
+ */
+ [Throws, NewObject]
+ HeapSnapshot readHeapSnapshot(DOMString filePath);
+
+ /**
+ * Efficient way to know if DevTools are active in the current process.
+ *
+ * This doesn't help know what particular context is being debugged,
+ * but can help strip off code entirely when DevTools aren't used at all.
+ *
+ * BrowsingContext.isWatchedByDevTools is a more precise way to know
+ * when one precise tab is being debugged.
+ */
+ boolean isDevToolsOpened();
+
+ /**
+ * API exposed to DevTools JS code in order to know when devtools are being active in the current process.
+ *
+ * This API counts the number of calls to these methods, allowing to track many DevTools instances.
+ */
+ undefined notifyDevToolsOpened();
+ undefined notifyDevToolsClosed();
+
+
+ /**
+ * Return the keys in a weak map. This operation is
+ * non-deterministic because it is affected by the scheduling of the
+ * garbage collector and the cycle collector.
+ *
+ * @param aMap weak map or other JavaScript value
+ * @returns If aMap is a weak map object, return the keys of the weak
+ * map as an array. Otherwise, return undefined.
+ */
+ [Throws, NewObject]
+ any nondeterministicGetWeakMapKeys(any map);
+
+ /**
+ * Return the keys in a weak set. This operation is
+ * non-deterministic because it is affected by the scheduling of the
+ * garbage collector and the cycle collector.
+ *
+ * @param aSet weak set or other JavaScript value
+ * @returns If aSet is a weak set object, return the keys of the weak
+ * set as an array. Otherwise, return undefined.
+ */
+ [Throws, NewObject]
+ any nondeterministicGetWeakSetKeys(any aSet);
+
+ /**
+ * Converts a buffer to a Base64 URL-encoded string per RFC 4648.
+ *
+ * @param source The buffer to encode.
+ * @param options Additional encoding options.
+ * @returns The encoded string.
+ */
+ [Throws]
+ ByteString base64URLEncode(BufferSource source,
+ Base64URLEncodeOptions options);
+
+ /**
+ * Decodes a Base64 URL-encoded string per RFC 4648.
+ *
+ * @param string The string to decode.
+ * @param options Additional decoding options.
+ * @returns The decoded buffer.
+ */
+ [Throws, NewObject]
+ ArrayBuffer base64URLDecode(ByteString string,
+ Base64URLDecodeOptions options);
+
+ /**
+ * Cause the current process to fatally crash unless the given condition is
+ * true. This is similar to MOZ_RELEASE_ASSERT in C++ code.
+ *
+ * WARNING: This message is included publicly in the crash report, and must
+ * not contain private information.
+ *
+ * Crash report will be augmented with the current JS stack information.
+ */
+ undefined releaseAssert(boolean condition,
+ optional DOMString message = "<no message>");
+
+#ifdef NIGHTLY_BUILD
+
+ /**
+ * If the chrome code has thrown a JavaScript Dev Error
+ * in the current JSRuntime. the first such error, or `undefined`
+ * otherwise.
+ *
+ * A JavaScript Dev Error is an exception thrown by JavaScript
+ * code that matches both conditions:
+ * - it was thrown by chrome code;
+ * - it is either a `ReferenceError`, a `TypeError` or a `SyntaxError`.
+ *
+ * Such errors are stored regardless of whether they have been
+ * caught.
+ *
+ * This mechanism is designed to help ensure that the code of
+ * Firefox is free from Dev Errors, even if they are accidentally
+ * caught by clients.
+ *
+ * The object returned is not an exception. It has fields:
+ * - DOMString stack
+ * - DOMString filename
+ * - DOMString lineNumber
+ * - DOMString message
+ */
+ [Throws]
+ readonly attribute any recentJSDevError;
+
+ /**
+ * Reset `recentJSDevError` to `undefined` for the current JSRuntime.
+ */
+ undefined clearRecentJSDevError();
+#endif // NIGHTLY_BUILD
+
+ /**
+ * Clears the stylesheet cache by baseDomain. This includes associated
+ * state-partitioned cache.
+ */
+ undefined clearStyleSheetCacheByBaseDomain(UTF8String baseDomain);
+
+ /**
+ * Clears the stylesheet cache by principal.
+ */
+ undefined clearStyleSheetCacheByPrincipal(Principal principal);
+
+ /**
+ * Clears the entire stylesheet cache.
+ */
+ undefined clearStyleSheetCache();
+
+ /**
+ * If the profiler is currently running and recording the current thread,
+ * add a marker for the current thread. No-op otherwise.
+ *
+ * @param name The name of the marker.
+ * @param options Either a timestamp to use as the start time of the
+ * marker, or a ProfilerMarkerOptions object that can
+ * contain startTime, captureStack or category fields.
+ * If this parameter is omitted, the marker will have
+ * no duration.
+ * In window and ChromeWorker contexts, use a
+ * timestamp from `performance.now()`.
+ * In JS modules, use `Cu.now()` to get a timestamp.
+ * @param text Text to associate with the marker.
+ */
+ undefined addProfilerMarker(UTF8String name,
+ optional (ProfilerMarkerOptions or DOMHighResTimeStamp) options = {},
+ optional UTF8String text);
+
+ /**
+ * Return the symbolic name of any given XPCOM error code (nsresult):
+ * "NS_OK", "NS_ERROR_FAILURE",...
+ */
+ UTF8String getXPCOMErrorName(unsigned long aErrorCode);
+
+ /**
+ * Return a fractional number representing the current time (in milliseconds from the Epoch).
+ * Should be JS_Now()/1000 so that it can be compared to Date.now in Javascript.
+ */
+ double dateNow();
+
+ /**
+ * Defines a getter on a specified object that will be created upon first
+ * use.
+ *
+ * @param aTarget
+ * The object to define the lazy getter on.
+ * @param aName
+ * The name of the getter to define on aTarget.
+ * @param aLambda
+ * A function that returns what the getter should return. This will
+ * only ever be called once.
+ */
+ [Throws]
+ undefined defineLazyGetter(object aTarget, any aName, object aLambda);
+
+ /**
+ * IF YOU ADD NEW METHODS HERE, MAKE SURE THEY ARE THREAD-SAFE.
+ */
+};
+
+/**
+ * Additional ChromeUtils methods that are _not_ thread-safe, and hence not
+ * exposed in workers.
+ */
+[Exposed=Window]
+partial namespace ChromeUtils {
+ /**
+ * A helper that converts OriginAttributesDictionary to a opaque suffix string.
+ *
+ * @param originAttrs The originAttributes from the caller.
+ */
+ ByteString
+ originAttributesToSuffix(optional OriginAttributesDictionary originAttrs = {});
+
+ /**
+ * Returns true if the members of |originAttrs| match the provided members
+ * of |pattern|.
+ *
+ * @param originAttrs The originAttributes under consideration.
+ * @param pattern The pattern to use for matching.
+ */
+ boolean
+ originAttributesMatchPattern(optional OriginAttributesDictionary originAttrs = {},
+ optional OriginAttributesPatternDictionary pattern = {});
+
+ /**
+ * Returns an OriginAttributesDictionary with values from the |origin| suffix
+ * and unspecified attributes added and assigned default values.
+ *
+ * @param origin The origin URI to create from.
+ * @returns An OriginAttributesDictionary with values from
+ * the origin suffix and unspecified attributes
+ * added and assigned default values.
+ */
+ [Throws]
+ OriginAttributesDictionary
+ createOriginAttributesFromOrigin(DOMString origin);
+
+ /**
+ * Returns an OriginAttributesDictionary with values from the origin |suffix|
+ * and unspecified attributes added and assigned default values.
+ *
+ * @param suffix The origin suffix to create from.
+ * @returns An OriginAttributesDictionary with values from
+ * the origin suffix and unspecified attributes
+ * added and assigned default values.
+ */
+ [Throws]
+ OriginAttributesDictionary
+ CreateOriginAttributesFromOriginSuffix(DOMString suffix);
+
+ /**
+ * Returns an OriginAttributesDictionary that is a copy of |originAttrs| with
+ * unspecified attributes added and assigned default values.
+ *
+ * @param originAttrs The origin attributes to copy.
+ * @returns An OriginAttributesDictionary copy of |originAttrs|
+ * with unspecified attributes added and assigned
+ * default values.
+ */
+ OriginAttributesDictionary
+ fillNonDefaultOriginAttributes(optional OriginAttributesDictionary originAttrs = {});
+
+ /**
+ * Returns true if the 2 OriginAttributes are equal.
+ */
+ boolean
+ isOriginAttributesEqual(optional OriginAttributesDictionary aA = {},
+ optional OriginAttributesDictionary aB = {});
+
+ /**
+ * Returns the base domain portion of a given partitionKey.
+ * Returns the empty string for an empty partitionKey.
+ * Throws for invalid partition keys.
+ */
+ [Throws]
+ DOMString
+ getBaseDomainFromPartitionKey(DOMString partitionKey);
+
+ /**
+ * Returns the partitionKey for a given URL.
+ *
+ * The function will treat the URL as a first party and construct the
+ * partitionKey according to the scheme, site and port in the URL.
+ *
+ * Throws for invalid urls.
+ */
+ [Throws]
+ DOMString
+ getPartitionKeyFromURL(DOMString url);
+
+ /**
+ * Loads and compiles the script at the given URL and returns an object
+ * which may be used to execute it repeatedly, in different globals, without
+ * re-parsing.
+ */
+ [NewObject]
+ Promise<PrecompiledScript>
+ compileScript(DOMString url, optional CompileScriptOptionsDictionary options = {});
+
+ /**
+ * Returns an optimized QueryInterface method which, when called from
+ * JavaScript, acts as an ordinary QueryInterface function call, and when
+ * called from XPConnect, circumvents JSAPI entirely.
+ *
+ * The list of interfaces may include a mix of JS ID objects and interface
+ * name strings.
+ *
+ * nsISupports is implicitly supported, and must not be included in the
+ * interface list.
+ */
+ [Affects=Nothing, NewObject]
+ MozQueryInterface generateQI(sequence<any> interfaces);
+
+ /**
+ * Waive Xray on a given value. Identity op for primitives.
+ */
+ [Throws]
+ any waiveXrays(any val);
+
+ /**
+ * Strip off Xray waivers on a given value. Identity op for primitives.
+ */
+ [Throws]
+ any unwaiveXrays(any val);
+
+ /**
+ * Gets the name of the JSClass of the object.
+ *
+ * if |unwrap| is true, all wrappers are unwrapped first. Unless you're
+ * specifically trying to detect whether the object is a proxy, this is
+ * probably what you want.
+ */
+ DOMString getClassName(object obj, optional boolean unwrap = true);
+
+ /**
+ * Returns whether the object is a DOM object.
+ *
+ * if |unwrap| is true, all wrappers are unwrapped first. Unless you're
+ * specifically trying to detect whether the object is a proxy, this is
+ * probably what you want.
+ */
+ boolean isDOMObject(object obj, optional boolean unwrap = true);
+
+ /**
+ * Clones the properties of the given object into a new object in the given
+ * target compartment (or the caller compartment if no target is provided).
+ * Property values themeselves are not cloned.
+ *
+ * Ignores non-enumerable properties, properties on prototypes, and properties
+ * with getters or setters.
+ */
+ [Throws]
+ object shallowClone(object obj, optional object? target = null);
+
+ /**
+ * Dispatches the given callback to the main thread when it would be
+ * otherwise idle. Similar to Window.requestIdleCallback, but not bound to a
+ * particular DOM windw.
+ */
+ [Throws]
+ undefined idleDispatch(IdleRequestCallback callback,
+ optional IdleRequestOptions options = {});
+
+ /**
+ * Synchronously loads and evaluates the js file located at
+ * 'aResourceURI' with a new, fully privileged global object.
+ *
+ * If `aTargetObj` is specified all properties exported by the module are
+ * copied to that object. This is deprecated and should not be used in
+ * new code.
+ *
+ * @param aResourceURI A resource:// URI string to load the module from.
+ * @param aTargetObj the object to install the exported properties on or null.
+ * @returns the module code's global object.
+ *
+ * The implementation maintains a hash of aResourceURI->global obj.
+ * Subsequent invocations of import with 'aResourceURI' pointing to
+ * the same file will not cause the module to be re-evaluated, but
+ * the symbols in EXPORTED_SYMBOLS will be exported into the
+ * specified target object and the global object returned as above.
+ */
+ [Throws]
+ object import(UTF8String aResourceURI, optional object aTargetObj);
+
+ /**
+ * Synchronously loads and evaluates the JS module source located at
+ * 'aResourceURI'.
+ *
+ * @param aResourceURI A resource:// URI string to load the module from.
+ * @returns the module's namespace object.
+ *
+ * The implementation maintains a hash of aResourceURI->global obj.
+ * Subsequent invocations of import with 'aResourceURI' pointing to
+ * the same file will not cause the module to be re-evaluated.
+ */
+ [Throws]
+ object importESModule(DOMString aResourceURI, optional ImportESModuleOptionsDictionary options = {});
+
+ /**
+ * Defines a property on the given target which lazily imports a JavaScript
+ * module when accessed.
+ *
+ * The first time the property is accessed, the module at the given URL is
+ * imported, and the property is replaced with the module's exported symbol
+ * of the same name.
+ *
+ * Some points to note when using this utility:
+ *
+ * - The cached module export is always stored on the `this` object that was
+ * used to access the getter. This means that if you define the lazy
+ * getter on a prototype, the module will be re-imported every time the
+ * property is accessed on a new instance.
+ *
+ * - The getter property may be overwritten by simple assignment, but as
+ * with imports, the new property value is always defined on the `this`
+ * object that the setter is called with.
+ *
+ * - If the module import fails, the getter will throw an error, and the
+ * property will not be replaced. Each subsequent attempt to access the
+ * getter will attempt to re-import the object, which will likely continue
+ * to result in errors.
+ *
+ * @param target The target object on which to define the property.
+ * @param id The name of the property to define, and of the symbol to
+ * import.
+ * @param resourceURI The resource URI of the module, as passed to
+ * ChromeUtils.import.
+ */
+ [Throws]
+ undefined defineModuleGetter(object target, DOMString id, DOMString resourceURI);
+
+ /**
+ * Defines propertys on the given target which lazily imports a ES module
+ * when accessed.
+ *
+ * @param target The target object on which to define the property.
+ * @param modules An object with a property for each module property to be
+ * imported, where the property name is the name of the
+ * imported symbol and the value is the module URI.
+ */
+ [Throws]
+ undefined defineESModuleGetters(object target, object modules);
+
+ /**
+ * Returns the scripted location of the first ancestor stack frame with a
+ * principal which is subsumed by the given principal. If no such frame
+ * exists on the call stack, returns null.
+ */
+ object? getCallerLocation(Principal principal);
+
+ /**
+ * Creates a JS Error object with the given message and stack.
+ *
+ * If a stack object is provided, the error object is created in the global
+ * that it belongs to.
+ */
+ [Throws]
+ object createError(DOMString message, optional object? stack = null);
+
+ /**
+ * Request performance metrics to the current process & all content processes.
+ */
+ [NewObject]
+ Promise<sequence<PerformanceInfoDictionary>> requestPerformanceMetrics();
+
+ /**
+ * Set the collection of specific detailed performance timing information.
+ * Selecting 0 for the mask will end existing collection. All metrics that
+ * are chosen will be cleared after updating the mask.
+ *
+ * @param aCollectionMask A bitmask where each bit corresponds to a metric
+ * to be collected as listed in PerfStats::Metric.
+ */
+ undefined setPerfStatsCollectionMask(unsigned long long aCollectionMask);
+
+ /**
+ * Collect results of detailed performance timing information.
+ * The output is a JSON string containing performance timings.
+ */
+ [NewObject]
+ Promise<DOMString> collectPerfStats();
+
+ /**
+ * Returns a Promise containing a sequence of I/O activities
+ */
+ [NewObject]
+ Promise<sequence<IOActivityDataDictionary>> requestIOActivity();
+
+ /**
+ * Returns a Promise containing all processes info
+ */
+ [NewObject]
+ Promise<ParentProcInfoDictionary> requestProcInfo();
+
+ /**
+ * For testing purpose.
+ */
+ [ChromeOnly]
+ boolean vsyncEnabled();
+
+ [ChromeOnly, Throws]
+ boolean hasReportingHeaderForOrigin(DOMString aOrigin);
+
+ [ChromeOnly]
+ PopupBlockerState getPopupControlState();
+
+ /**
+ * Milliseconds from the last iframe loading an external protocol.
+ */
+ [ChromeOnly]
+ double lastExternalProtocolIframeAllowed();
+
+ /**
+ * For testing purpose we need to reset this value.
+ */
+ [ChromeOnly]
+ undefined resetLastExternalProtocolIframeAllowed();
+
+ /**
+ * For webdriver consistency purposes, we need to be able to end a wheel
+ * transaction from the browser chrome.
+ */
+ [ChromeOnly]
+ undefined endWheelTransaction();
+
+ /**
+ * Register a new toplevel window global actor. This method may only be
+ * called in the parent process. |name| must be globally unique.
+ *
+ * See JSWindowActor.webidl for WindowActorOptions fields documentation.
+ */
+ [ChromeOnly, Throws]
+ undefined registerWindowActor(UTF8String aName, optional WindowActorOptions aOptions = {});
+
+ [ChromeOnly]
+ undefined unregisterWindowActor(UTF8String aName);
+
+ /**
+ * Register a new toplevel content global actor. This method may only be
+ * called in the parent process. |name| must be globally unique.
+ *
+ * See JSProcessActor.webidl for ProcessActorOptions fields documentation.
+ */
+ [ChromeOnly, Throws]
+ undefined registerProcessActor(UTF8String aName, optional ProcessActorOptions aOptions = {});
+
+ [ChromeOnly]
+ undefined unregisterProcessActor(UTF8String aName);
+
+ [ChromeOnly]
+ // aError should a nsresult.
+ boolean isClassifierBlockingErrorCode(unsigned long aError);
+
+ /**
+ * If leak detection is enabled, print a note to the leak log that this
+ * process will intentionally crash. This should be called only on child
+ * processes for testing purpose.
+ */
+ [ChromeOnly, Throws]
+ undefined privateNoteIntentionalCrash();
+
+ /**
+ * nsIDOMProcessChild for the current process.
+ */
+ [ChromeOnly]
+ readonly attribute nsIDOMProcessChild? domProcessChild;
+
+ /**
+ * nsIDOMProcessParent for all processes.
+ *
+ * The first is for the parent process and all the next are for the content
+ * processes.
+ */
+ [Throws, ChromeOnly]
+ sequence<nsIDOMProcessParent> getAllDOMProcesses();
+
+ /**
+ * Returns a record of user interaction data. Currently only typing,
+ * but will include scrolling and potentially other metrics.
+ *
+ * Valid keys: "Typing"
+ */
+ [Throws, ChromeOnly]
+ record<DOMString, InteractionData> consumeInteractionData();
+
+ /**
+ * Returns a record of user scrolling interactions collected from content processes.
+ *
+ * Valid keys: "Scrolling"
+ */
+ [NewObject]
+ Promise<InteractionData> collectScrollingData();
+
+ [Throws]
+ sequence<FormAutofillConfidences> getFormAutofillConfidences(sequence<Element> elements);
+
+ /**
+ * Returns whether the background of the element is dark.
+ */
+ boolean isDarkBackground(Element element);
+
+ /**
+ * Starts the JSOracle process for ORB JavaScript validation, if it hasn't started already.
+ */
+ undefined ensureJSOracleStarted();
+
+ /**
+ * The number of currently alive utility processes.
+ */
+ [ChromeOnly]
+ readonly attribute unsigned long aliveUtilityProcesses;
+
+ /**
+ * Get a list of all possible Utility process Actor Names ; mostly useful to
+ * perform testing and ensure about:processes display is sound and misses no
+ * actor name.
+ */
+ [ChromeOnly]
+ sequence<UTF8String> getAllPossibleUtilityActorNames();
+};
+
+/*
+ * This type is a WebIDL representation of mozilla::ProcType.
+ * These must match the similar ones in E10SUtils.sys.mjs, RemoteTypes.h,
+ * ProcInfo.h and ChromeUtils.cpp
+ */
+enum WebIDLProcType {
+ "web",
+ "webIsolated",
+ "file",
+ "extension",
+ "privilegedabout",
+ "privilegedmozilla",
+ "withCoopCoep",
+ "webServiceWorker",
+ "browser",
+ "ipdlUnitTest",
+ "gmpPlugin",
+ "gpu",
+ "vr",
+ "rdd",
+ "socket",
+ "remoteSandboxBroker",
+#ifdef MOZ_ENABLE_FORKSERVER
+ "forkServer",
+#endif
+ "utility",
+ "preallocated",
+ "unknown",
+};
+
+/**
+ * These dictionaries hold information about Firefox running processes and
+ * threads.
+ *
+ * See widget/ProcInfo.h for fields documentation.
+ */
+dictionary ThreadInfoDictionary {
+ long long tid = 0;
+ DOMString name = "";
+ unsigned long long cpuCycleCount = 0;
+ unsigned long long cpuTime = 0;
+};
+
+dictionary WindowInfoDictionary {
+ // Window ID, as known to the parent process.
+ unsigned long long outerWindowId = 0;
+
+ // URI of the document loaded in the window.
+ URI? documentURI = null;
+
+ // Title of the document loaded in the window.
+ // Commonly empty for subframes.
+ DOMString documentTitle = "";
+
+ // `true` if this window is the root for the process.
+ boolean isProcessRoot = false;
+
+ // `true` if this is loaded in the same process as the parent, `false` otherwise.
+ boolean isInProcess = false;
+};
+
+/*
+ * Add new entry to WebIDLUtilityActorName here and update accordingly
+ * UtilityActorNameToWebIDL in dom/base/ChromeUtils.cpp as well as
+ * UtilityActorName in toolkit/components/processtools/ProcInfo.h
+ */
+enum WebIDLUtilityActorName {
+ "unknown",
+ "audioDecoder_Generic",
+ "audioDecoder_AppleMedia",
+ "audioDecoder_WMF",
+ "mfMediaEngineCDM",
+ "jSOracle",
+ "windowsUtils",
+};
+
+dictionary UtilityActorsDictionary {
+ WebIDLUtilityActorName actorName = "unknown";
+};
+
+/**
+ * Information on a child process.
+ *
+ * # Limitation
+ *
+ * If we lose a race with a process or thread attempting to close the
+ * target process, not all information is available.
+ *
+ * Missing information will generally have its default value.
+ */
+dictionary ChildProcInfoDictionary {
+ // --- System info
+
+ // The cross-process descriptor for this process.
+ long long pid = 0;
+
+ // The best end-user measure for "memory used" that we can obtain without
+ // triggering expensive computations. The value is in bytes.
+ // On Mac and Linux this matches the values shown by the system monitors.
+ // On Windows this will return the Commit Size.
+ unsigned long long memory = 0;
+
+ // Total CPU time spent by the process, in ns.
+ unsigned long long cpuTime = 0;
+
+ // Total CPU cycles used by this process.
+ // On Windows where the resolution of CPU timings is 16ms, this can
+ // be used to determine if a process is idle or slightly active.
+ unsigned long long cpuCycleCount = 0;
+
+ // Thread information for this process.
+ sequence<ThreadInfoDictionary> threads = [];
+
+ // --- Firefox info
+
+ // Internal-to-Firefox process identifier.
+ unsigned long long childID = 0;
+
+ // The origin of the process, e.g. the subset of domain names
+ // that this subset serves.
+ UTF8String origin = "";
+
+ // Type of this child process.
+ WebIDLProcType type = "web";
+
+ // The windows implemented by this process.
+ sequence<WindowInfoDictionary> windows = [];
+
+ // The utility process list of actors if any
+ sequence<UtilityActorsDictionary> utilityActors = [];
+};
+
+/**
+ * Information on the parent process.
+ */
+dictionary ParentProcInfoDictionary {
+ // --- System info
+
+ // The cross-process descriptor for this process.
+ long long pid = 0;
+
+ // The best end-user measure for "memory used" that we can obtain without
+ // triggering expensive computations. The value is in bytes.
+ // On Mac and Linux this matches the values shown by the system monitors.
+ // On Windows this will return the Commit Size.
+ unsigned long long memory = 0;
+
+ // Total CPU time spent by the process, in ns.
+ unsigned long long cpuTime = 0;
+
+ // Total CPU cycles used by this process.
+ // On Windows where the resolution of CPU timings is 16ms, this can
+ // be used to determine if a process is idle or slightly active.
+ unsigned long long cpuCycleCount = 0;
+
+ // Thread information for this process.
+ sequence<ThreadInfoDictionary> threads = [];
+
+ // Information on children processes.
+ sequence<ChildProcInfoDictionary> children = [];
+
+ // --- Firefox info
+ // Type of this parent process.
+ // As of this writing, this is always `browser`.
+ WebIDLProcType type = "browser";
+};
+
+/**
+ * Dictionaries duplicating IPDL types in dom/ipc/DOMTypes.ipdlh
+ * Used by requestPerformanceMetrics
+ */
+dictionary MediaMemoryInfoDictionary {
+ unsigned long long audioSize = 0;
+ unsigned long long videoSize = 0;
+ unsigned long long resourcesSize = 0;
+};
+
+dictionary MemoryInfoDictionary {
+ unsigned long long domDom = 0;
+ unsigned long long domStyle = 0;
+ unsigned long long domOther = 0;
+ unsigned long long jsMemUsage = 0;
+ required MediaMemoryInfoDictionary media;
+};
+
+dictionary CategoryDispatchDictionary
+{
+ unsigned short category = 0;
+ unsigned short count = 0;
+};
+
+dictionary PerformanceInfoDictionary {
+ ByteString host = "";
+ unsigned long pid = 0;
+ unsigned long long windowId = 0;
+ unsigned long long duration = 0;
+ unsigned long long counterId = 0;
+ boolean isWorker = false;
+ boolean isTopLevel = false;
+ required MemoryInfoDictionary memoryInfo;
+ sequence<CategoryDispatchDictionary> items = [];
+};
+
+/**
+ * Used by requestIOActivity() to return the number of bytes
+ * that were read (rx) and/or written (tx) for a given location.
+ *
+ * Locations can be sockets or files.
+ */
+dictionary IOActivityDataDictionary {
+ ByteString location = "";
+ unsigned long long rx = 0;
+ unsigned long long tx = 0;
+};
+
+/**
+ * Used by principals and the script security manager to represent origin
+ * attributes. The first dictionary is designed to contain the full set of
+ * OriginAttributes, the second is used for pattern-matching (i.e. does this
+ * OriginAttributesDictionary match the non-empty attributes in this pattern).
+ *
+ * IMPORTANT: If you add any members here, you need to do the following:
+ * (1) Add them to both dictionaries.
+ * (2) Update the methods on mozilla::OriginAttributes, including equality,
+ * serialization, deserialization, and inheritance.
+ * (3) Update the methods on mozilla::OriginAttributesPattern, including matching.
+ */
+[GenerateInitFromJSON]
+dictionary OriginAttributesDictionary {
+ unsigned long userContextId = 0;
+ boolean inIsolatedMozBrowser = false;
+ unsigned long privateBrowsingId = 0;
+ DOMString firstPartyDomain = "";
+ DOMString geckoViewSessionContextId = "";
+ DOMString partitionKey = "";
+};
+
+[GenerateInitFromJSON, GenerateToJSON]
+dictionary OriginAttributesPatternDictionary {
+ unsigned long userContextId;
+ boolean inIsolatedMozBrowser;
+ unsigned long privateBrowsingId;
+ DOMString firstPartyDomain;
+ DOMString geckoViewSessionContextId;
+ // partitionKey takes precedence over partitionKeyPattern.
+ DOMString partitionKey;
+ PartitionKeyPatternDictionary partitionKeyPattern;
+};
+
+dictionary PartitionKeyPatternDictionary {
+ DOMString scheme;
+ DOMString baseDomain;
+ long port;
+};
+
+dictionary CompileScriptOptionsDictionary {
+ /**
+ * The character set from which to decode the script.
+ */
+ DOMString charset = "utf-8";
+
+ /**
+ * If true, certain parts of the script may be parsed lazily, the first time
+ * they are used, rather than eagerly parsed at load time.
+ */
+ boolean lazilyParse = false;
+
+ /**
+ * If true, the script will be compiled so that its last expression will be
+ * returned as the value of its execution. This makes certain types of
+ * optimization impossible, and disables the JIT in many circumstances, so
+ * should not be used when not absolutely necessary.
+ */
+ boolean hasReturnValue = false;
+};
+
+dictionary ImportESModuleOptionsDictionary {
+ /**
+ * If true, a distinct module loader will be used, in the system principal,
+ * but with a distinct global so that the DevTools can load a distinct set
+ * of modules and do not interfere with its debuggee.
+ */
+ boolean loadInDevToolsLoader;
+};
+
+/**
+ * A JS object whose properties specify what portion of the heap graph to
+ * write. The recognized properties are:
+ *
+ * * globals: [ global, ... ]
+ * Dump only nodes that either:
+ * - belong in the compartment of one of the given globals;
+ * - belong to no compartment, but do belong to a Zone that contains one of
+ * the given globals;
+ * - are referred to directly by one of the last two kinds of nodes; or
+ * - is the fictional root node, described below.
+ *
+ * * debugger: Debugger object
+ * Like "globals", but use the Debugger's debuggees as the globals.
+ *
+ * * runtime: true
+ * Dump the entire heap graph, starting with the JSRuntime's roots.
+ *
+ * One, and only one, of these properties must exist on the boundaries object.
+ *
+ * The root of the dumped graph is a fictional node whose ubi::Node type name is
+ * "CoreDumpRoot". If we are dumping the entire ubi::Node graph, this root node
+ * has an edge for each of the JSRuntime's roots. If we are dumping a selected
+ * set of globals, the root has an edge to each global, and an edge for each
+ * incoming JS reference to the selected Zones.
+ */
+dictionary HeapSnapshotBoundaries {
+ sequence<object> globals;
+ object debugger;
+ boolean runtime;
+};
+
+dictionary Base64URLEncodeOptions {
+ /** Specifies whether the output should be padded with "=" characters. */
+ required boolean pad;
+};
+
+enum Base64URLDecodePadding {
+ /**
+ * Fails decoding if the input is unpadded. RFC 4648, section 3.2 requires
+ * padding, unless the referring specification prohibits it.
+ */
+ "require",
+
+ /** Tolerates padded and unpadded input. */
+ "ignore",
+
+ /**
+ * Fails decoding if the input is padded. This follows the strict base64url
+ * variant used in JWS (RFC 7515, Appendix C) and HTTP Encrypted
+ * Content-Encoding (draft-ietf-httpbis-encryption-encoding-01).
+ */
+ "reject"
+};
+
+dictionary Base64URLDecodeOptions {
+ /** Specifies the padding mode for decoding the input. */
+ required Base64URLDecodePadding padding;
+};
+
+// Keep this in sync with PopupBlocker::PopupControlState!
+enum PopupBlockerState {
+ "openAllowed",
+ "openControlled",
+ "openBlocked",
+ "openAbused",
+ "openOverridden",
+};
diff --git a/dom/chrome-webidl/ClonedErrorHolder.webidl b/dom/chrome-webidl/ClonedErrorHolder.webidl
new file mode 100644
index 0000000000..8ab62f99ed
--- /dev/null
+++ b/dom/chrome-webidl/ClonedErrorHolder.webidl
@@ -0,0 +1,18 @@
+/* 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/. */
+
+/**
+ * A stub object to hold an Error, Exception, or DOMException object to be
+ * transferred via structured clone. The object will automatically be decoded
+ * directly into the type of the error object that it wraps.
+ *
+ * This is a temporary workaround for lack of native Error and Exception
+ * cloning support, and can be removed once bug 1556604 and bug 1561357 are
+ * fixed.
+ */
+[ChromeOnly, Exposed=Window]
+interface ClonedErrorHolder {
+ [Throws]
+ constructor(object aError);
+};
diff --git a/dom/chrome-webidl/DOMCollectedFrames.webidl b/dom/chrome-webidl/DOMCollectedFrames.webidl
new file mode 100644
index 0000000000..4875fbf8ba
--- /dev/null
+++ b/dom/chrome-webidl/DOMCollectedFrames.webidl
@@ -0,0 +1,29 @@
+/* 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/.
+ */
+
+/**
+ * A single frame collected by the |CompositionRecorder|.
+ */
+[GenerateConversionToJS]
+dictionary DOMCollectedFrame {
+ /**
+ * The offset of the frame past the start point of the recording (in
+ * milliseconds).
+ */
+ required double timeOffset;
+ /** A data: URI containing the PNG image data of the frame. */
+ required ByteString dataUri;
+};
+
+/**
+ * Information about frames collected by the |CompositionRecorder|.
+ */
+[GenerateConversionToJS]
+dictionary DOMCollectedFrames {
+ /** The collected frames. */
+ required sequence<DOMCollectedFrame> frames;
+ /** The start point of the recording (in milliseconds). */
+ required double recordingStart;
+};
diff --git a/dom/chrome-webidl/DebuggerNotification.webidl b/dom/chrome-webidl/DebuggerNotification.webidl
new file mode 100644
index 0000000000..d549eb7ae9
--- /dev/null
+++ b/dom/chrome-webidl/DebuggerNotification.webidl
@@ -0,0 +1,58 @@
+/* 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/. */
+
+enum DebuggerNotificationType {
+ // DebuggerNotification
+ "setTimeout",
+ "clearTimeout",
+ "setInterval",
+ "clearInterval",
+ "requestAnimationFrame",
+ "cancelAnimationFrame",
+
+ // CallbackDebuggerNotification
+ "setTimeoutCallback",
+ "setIntervalCallback",
+ "requestAnimationFrameCallback",
+
+ // EventCallbackDebuggerNotification
+ "domEvent",
+};
+
+[ChromeOnly, Exposed=Window]
+interface DebuggerNotification {
+ readonly attribute DebuggerNotificationType type;
+
+ // The global object that has triggered the notification.
+ readonly attribute object global;
+};
+
+// For DOM events, we send notifications just before, and just after the
+// event handler has been dispatched so that listeners
+enum CallbackDebuggerNotificationPhase {
+ "pre",
+ "post",
+};
+
+// A base notification type for notifications that are dispatched as pairs with
+// a before and after notification.
+[ChromeOnly, Exposed=Window]
+interface CallbackDebuggerNotification : DebuggerNotification {
+ readonly attribute CallbackDebuggerNotificationPhase phase;
+};
+
+enum EventCallbackDebuggerNotificationType {
+ "global",
+ "node",
+ "xhr",
+ "worker",
+ "websocket",
+};
+
+// A notification that about the engine calling a DOM event handler.
+[ChromeOnly, Exposed=Window]
+interface EventCallbackDebuggerNotification : CallbackDebuggerNotification {
+ readonly attribute Event event;
+ readonly attribute EventCallbackDebuggerNotificationType targetType;
+};
diff --git a/dom/chrome-webidl/DebuggerNotificationObserver.webidl b/dom/chrome-webidl/DebuggerNotificationObserver.webidl
new file mode 100644
index 0000000000..e37d2dc312
--- /dev/null
+++ b/dom/chrome-webidl/DebuggerNotificationObserver.webidl
@@ -0,0 +1,31 @@
+/* -*- Mode: IDL; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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/.
+ */
+
+callback DebuggerNotificationCallback = undefined (DebuggerNotification n);
+
+[ChromeOnly, Exposed=(Window, Worker)]
+interface DebuggerNotificationObserver {
+ [Throws]
+ constructor();
+
+ // Throws if the object is not a browser global or does not support
+ // debugger notifications.
+ // Returns false if already connected to this global.
+ [Throws]
+ boolean connect(object global);
+
+ // Throws if the object is not a browser global or does not support
+ // debugger notifications.
+ // Returns false if not connected to this global.
+ [Throws]
+ boolean disconnect(object global);
+
+ // Returns false if listener already added.
+ boolean addListener(DebuggerNotificationCallback handler);
+
+ // Returns false if listener was not found.
+ boolean removeListener(DebuggerNotificationCallback handler);
+};
diff --git a/dom/chrome-webidl/DebuggerUtils.webidl b/dom/chrome-webidl/DebuggerUtils.webidl
new file mode 100644
index 0000000000..31421efcaa
--- /dev/null
+++ b/dom/chrome-webidl/DebuggerUtils.webidl
@@ -0,0 +1,16 @@
+/* -*- Mode: IDL; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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/.
+ */
+
+// Interfaces and structures for use by the debugger and other devtools.
+
+// Data sent to the devtools when new data has been received in an HTML parse.
+[GenerateToJSON]
+dictionary HTMLContent {
+ DOMString parserID;
+ DOMString uri;
+ DOMString contents;
+ boolean complete;
+};
diff --git a/dom/chrome-webidl/DocumentL10n.webidl b/dom/chrome-webidl/DocumentL10n.webidl
new file mode 100644
index 0000000000..5f252de2cb
--- /dev/null
+++ b/dom/chrome-webidl/DocumentL10n.webidl
@@ -0,0 +1,47 @@
+/* -*- Mode: IDL; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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/.
+ */
+
+/**
+ * DocumentL10n is a public interface for handling DOM localization.
+ *
+ * In it's current form it exposes the DOMLocalization API which
+ * allows for localization-specific DOM operations on a defined
+ * localization context, and retrival of formatted localization
+ * messages out of that context.
+ *
+ * The context is created when `<link rel="localization"/>` elements
+ * are added to the document, and is removed in case all links
+ * of that type are removed from it.
+ */
+[LegacyNoInterfaceObject,
+ Exposed=Window]
+interface DocumentL10n : DOMLocalization {
+ /**
+ * A promise which gets resolved when the initial DOM localization resources
+ * fetching is complete and the initial translation of the DOM is finished.
+ */
+ readonly attribute Promise<any> ready;
+
+ /**
+ * An overload for the DOMLocalization::connectRoot which takes an optional second
+ * argument to allow the user to express an intent of translating the root
+ * as soon as the localization becomes available.
+ *
+ * If the root is being connected while the document is still being parsed,
+ * then irrelevant of the value of the second argument, it will be translated
+ * as part of the initial translation step right after the parsing completes.
+ *
+ * If the root is being connected after the document is parsed, then the
+ * second argument controls whether the root is also going to get translated,
+ * or just connected.
+ *
+ * This is a temporary workaround to avoid having to wait for the `DocumentL10n`
+ * to become active. It should be unnecessary once we remove JSM and make
+ * the `TranslateFragment` be available immediately when `DocumentL10n` becomes
+ * available.
+ */
+ [Throws] undefined connectRoot(Node aElement, optional boolean aTranslate = false);
+};
diff --git a/dom/chrome-webidl/DominatorTree.webidl b/dom/chrome-webidl/DominatorTree.webidl
new file mode 100644
index 0000000000..518f0e9802
--- /dev/null
+++ b/dom/chrome-webidl/DominatorTree.webidl
@@ -0,0 +1,70 @@
+/* -*- Mode: IDL; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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/.
+ */
+
+typedef unsigned long long NodeId;
+typedef unsigned long long NodeSize;
+
+/**
+ * In a directed graph with a root node `R`, a node `A` is said to "dominate" a
+ * node `B` iff every path from `R` to `B` contains `A`. A node `A` is said to
+ * be the "immediate dominator" of a node `B` iff it dominates `B`, is not `B`
+ * itself, and does not dominate any other nodes which also dominate `B` in
+ * turn.
+ *
+ * If we take every node from a graph `G` and create a new graph `T` with edges
+ * to each node from its immediate dominator, then `T` is a tree (each node has
+ * only one immediate dominator, or none if it is the root). This tree is called
+ * a "dominator tree".
+ *
+ * This interface represents a dominator tree constructed from a HeapSnapshot's
+ * heap graph. The domination relationship and dominator trees are useful tools
+ * for analyzing heap graphs because they tell you:
+ *
+ * - Exactly what could be reclaimed by the GC if some node `A` became
+ * unreachable: those nodes which are dominated by `A`,
+ *
+ * - The "retained size" of a node in the heap graph, in contrast to its
+ * "shallow size". The "shallow size" is the space taken by a node itself,
+ * not counting anything it references. The "retained size" of a node is its
+ * shallow size plus the size of all the things that would be collected if
+ * the original node wasn't (directly or indirectly) referencing them. In
+ * other words, the retained size is the shallow size of a node plus the
+ * shallow sizes of every other node it dominates. For example, the root
+ * node in a binary tree might have a small shallow size that does not take
+ * up much space itself, but it dominates the rest of the binary tree and
+ * its retained size is therefore significant (assuming no external
+ * references into the tree).
+ */
+[ChromeOnly, Exposed=(Window,Worker)]
+interface DominatorTree {
+ /**
+ * The `NodeId` for the root of the dominator tree. This is a "meta-root" in
+ * that it has an edge to each GC root in the heap snapshot this dominator
+ * tree was created from.
+ */
+ readonly attribute NodeId root;
+
+ /**
+ * Get the retained size of the node with the given id. If given an invalid
+ * id, null is returned. Throws an error on OOM.
+ */
+ [Throws]
+ NodeSize? getRetainedSize(NodeId node);
+
+ /**
+ * Get the set of ids of nodes immediately dominated by the node with the
+ * given id. The resulting array is sorted by greatest to least retained
+ * size. If given an invalid id, null is returned. Throws an error on OOM.
+ */
+ [Throws]
+ sequence<NodeId>? getImmediatelyDominated(NodeId node);
+
+ /**
+ * Get the immediate dominator of the node with the given id. Returns null if
+ * given an invalid id, or the id of the root node.
+ */
+ NodeId? getImmediateDominator(NodeId node);
+};
diff --git a/dom/chrome-webidl/Flex.webidl b/dom/chrome-webidl/Flex.webidl
new file mode 100644
index 0000000000..f04897e65c
--- /dev/null
+++ b/dom/chrome-webidl/Flex.webidl
@@ -0,0 +1,94 @@
+/* -*- Mode: IDL; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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/.
+ */
+
+/**
+ * These objects support visualization of flex containers by the
+ * dev tools.
+ */
+
+/**
+ * A flex container's main and cross axes are either horizontal or
+ * vertical, each with two possible directions.
+ */
+enum FlexPhysicalDirection {
+ "horizontal-lr",
+ "horizontal-rl",
+ "vertical-tb",
+ "vertical-bt",
+};
+
+[ChromeOnly, Exposed=Window]
+interface Flex
+{
+ sequence<FlexLineValues> getLines();
+
+ /**
+ * The physical direction in which successive flex items are placed,
+ * within a flex line in this flex container.
+ */
+ readonly attribute FlexPhysicalDirection mainAxisDirection;
+
+ /**
+ * The physical direction in which successive flex lines are placed
+ * in this flex container (if it is or were multi-line).
+ */
+ readonly attribute FlexPhysicalDirection crossAxisDirection;
+};
+
+/**
+ * This indicates which flex factor (flex-grow vs. flex-shrink) the
+ * flex layout algorithm uses internally when resolving flexible sizes
+ * in a given flex line, per flexbox spec section 9.7 step 1. Note that
+ * this value doesn't necessarily mean that any items on this line
+ * are *actually* growing (or shrinking). This simply indicates what
+ * the layout algorithm "wants" to do, based on the free space --
+ * and items will stretch from their flex base size in the corresponding
+ * direction, if permitted by their min/max constraints and their
+ * corresponding flex factor.
+ */
+enum FlexLineGrowthState { "shrinking", "growing" };
+
+[ChromeOnly, Exposed=Window]
+interface FlexLineValues
+{
+ readonly attribute FlexLineGrowthState growthState;
+ readonly attribute double crossStart;
+ readonly attribute double crossSize;
+
+ // firstBaselineOffset measures from flex-start edge.
+ readonly attribute double firstBaselineOffset;
+
+ // lastBaselineOffset measures from flex-end edge.
+ readonly attribute double lastBaselineOffset;
+
+ /**
+ * getItems() returns FlexItemValues only for the Elements in
+ * this Flex container -- ignoring struts and abs-pos Elements.
+ */
+ sequence<FlexItemValues> getItems();
+};
+
+/**
+ * Item main sizes have either been unclamped, clamped to the minimum,
+ * or clamped to the maximum.
+ */
+enum FlexItemClampState {
+ "unclamped", "clamped_to_min", "clamped_to_max"
+};
+
+[ChromeOnly, Exposed=Window]
+interface FlexItemValues
+{
+ readonly attribute Node? node;
+ readonly attribute DOMRectReadOnly frameRect;
+ readonly attribute double mainBaseSize;
+ readonly attribute double mainDeltaSize;
+ readonly attribute double mainMinSize;
+ readonly attribute double mainMaxSize;
+ readonly attribute double crossMinSize;
+ readonly attribute double crossMaxSize;
+ readonly attribute FlexItemClampState clampState;
+};
diff --git a/dom/chrome-webidl/Fluent.webidl b/dom/chrome-webidl/Fluent.webidl
new file mode 100644
index 0000000000..5a8d6fca2b
--- /dev/null
+++ b/dom/chrome-webidl/Fluent.webidl
@@ -0,0 +1,51 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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/. */
+
+[ChromeOnly, Exposed=Window]
+interface FluentResource {
+ constructor(UTF8String source);
+};
+
+[ChromeOnly, Exposed=Window]
+interface FluentPattern {};
+
+/**
+ * FluentMessage is a structure storing an unresolved L10nMessage,
+ * as returned by the Fluent Bundle.
+ *
+ * It stores a FluentPattern of the value and attributes, which
+ * can be then passed to bundle.formatPattern.
+ */
+
+dictionary FluentMessage {
+ FluentPattern? value = null;
+ required record<UTF8String, FluentPattern> attributes;
+};
+
+typedef record<UTF8String, (UTF8String or double)?> L10nArgs;
+
+dictionary FluentBundleOptions {
+ boolean useIsolating = false;
+ UTF8String pseudoStrategy;
+};
+
+dictionary FluentBundleAddResourceOptions {
+ boolean allowOverrides = false;
+};
+
+[ChromeOnly, Exposed=Window]
+interface FluentBundle {
+ [Throws]
+ constructor((UTF8String or sequence<UTF8String>) aLocales, optional FluentBundleOptions aOptions = {});
+
+ [Pure, Cached]
+ readonly attribute sequence<UTF8String> locales;
+
+ undefined addResource(FluentResource aResource, optional FluentBundleAddResourceOptions aOptions = {});
+ boolean hasMessage(UTF8String id);
+ FluentMessage? getMessage(UTF8String id);
+ [Throws]
+ UTF8String formatPattern(FluentPattern pattern, optional L10nArgs? aArgs = null, optional object aErrors);
+};
diff --git a/dom/chrome-webidl/FrameLoader.webidl b/dom/chrome-webidl/FrameLoader.webidl
new file mode 100644
index 0000000000..df3d03f2b7
--- /dev/null
+++ b/dom/chrome-webidl/FrameLoader.webidl
@@ -0,0 +1,243 @@
+/* -*- Mode: IDL; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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/.
+ */
+
+interface LoadContext;
+interface RemoteTab;
+interface URI;
+interface nsIDocShell;
+interface nsIPrintSettings;
+interface nsIWebBrowserPersistDocumentReceiver;
+interface nsIWebProgressListener;
+
+[ChromeOnly,
+ Exposed=Window]
+interface FrameLoader {
+ /**
+ * Get the docshell from the frame loader.
+ */
+ [GetterThrows]
+ readonly attribute nsIDocShell? docShell;
+
+ /**
+ * Get this frame loader's RemoteTab, if it has a remote frame. Otherwise,
+ * returns null.
+ */
+ readonly attribute RemoteTab? remoteTab;
+
+ /**
+ * Get an nsILoadContext for the top-level docshell. For remote
+ * frames, a shim is returned that contains private browsing and app
+ * information.
+ */
+ readonly attribute LoadContext? loadContext;
+
+ /**
+ * Get the root BrowsingContext within the frame.
+ * This may be null immediately after creating a remote frame.
+ */
+ readonly attribute BrowsingContext? browsingContext;
+
+ /**
+ * Find out whether the loader's frame is at too great a depth in
+ * the frame tree. This can be used to decide what operations may
+ * or may not be allowed on the loader's docshell.
+ */
+ [Pure]
+ readonly attribute boolean depthTooGreat;
+
+ /**
+ * Find out whether the loader's frame is a remote frame.
+ */
+ readonly attribute boolean isRemoteFrame;
+
+ // Note, when frameloaders are swapped, also messageManagers are swapped.
+ readonly attribute MessageSender? messageManager;
+
+ /**
+ * Force a remote browser to recompute its dimension and screen position.
+ */
+ [Throws]
+ undefined requestUpdatePosition();
+
+ /**
+ * Force a TabStateFlush from native sessionStoreListeners.
+ * Returns a promise that resolves when all session store data has been
+ * flushed.
+ */
+ [NewObject]
+ Promise<undefined> requestTabStateFlush();
+
+ /**
+ * Force Epoch update in native sessionStoreListeners.
+ */
+ undefined requestEpochUpdate(unsigned long aEpoch);
+
+ /**
+ * Request a session history update in native sessionStoreListeners.
+ */
+ undefined requestSHistoryUpdate();
+
+ /**
+ * Creates a print preview document in this frame, or updates the existing
+ * print preview document with new print settings.
+ *
+ * @param aPrintSettings The print settings to use to layout the print
+ * preview document.
+ * @param aSourceBrowsingContext Optionally, the browsing context that
+ * contains the document from which the print preview is to be generated,
+ * which must be in the same process as the browsing context of the frame
+ * loader itself.
+ *
+ * This should only be passed on the first call. It should not be passed
+ * for any subsequent calls that are made to update the existing print
+ * preview document with a new print settings object.
+ * @return A Promise that resolves with a PrintPreviewSuccessInfo on success.
+ */
+ [NewObject]
+ Promise<unsigned long> printPreview(nsIPrintSettings aPrintSettings,
+ BrowsingContext? aSourceBrowsingContext);
+
+ /**
+ * Inform the print preview document that we're done with it.
+ */
+ undefined exitPrintPreview();
+
+ /**
+ * The element which owns this frame loader.
+ *
+ * For example, if this is a frame loader for an <iframe>, this attribute
+ * returns the iframe element.
+ */
+ [Pure]
+ readonly attribute Element? ownerElement;
+
+
+ /**
+ * Cached childID of the ContentParent owning the RemoteTab in this frame
+ * loader. This can be used to obtain the childID after the RemoteTab died.
+ */
+ [Pure]
+ readonly attribute unsigned long long childID;
+
+ /**
+ * Find out whether the owner content really is a mozbrowser. <xul:browser>
+ * is not considered to be a mozbrowser frame.
+ */
+ [Pure]
+ readonly attribute boolean ownerIsMozBrowserFrame;
+
+ /**
+ * The last known width of the frame. Reading this property will not trigger
+ * a reflow, and therefore may not reflect the current state of things. It
+ * should only be used in asynchronous APIs where values are not guaranteed
+ * to be up-to-date when received.
+ */
+ [Pure]
+ readonly attribute unsigned long lazyWidth;
+
+ /**
+ * The last known height of the frame. Reading this property will not trigger
+ * a reflow, and therefore may not reflect the current state of things. It
+ * should only be used in asynchronous APIs where values are not guaranteed
+ * to be up-to-date when received.
+ */
+ [Pure]
+ readonly attribute unsigned long lazyHeight;
+
+ /**
+ * Is `true` if the frameloader is dead (destroy has been called on it)
+ */
+ [Pure]
+ readonly attribute boolean isDead;
+};
+
+/**
+ * Interface for objects which represent a document that can be
+ * serialized with nsIWebBrowserPersist. This interface is
+ * asynchronous because the actual document can be in another process
+ * (e.g., if this object is a FrameLoader for an out-of-process
+ * frame).
+ *
+ * @see nsIWebBrowserPersistDocumentReceiver
+ * @see nsIWebBrowserPersistDocument
+ * @see nsIWebBrowserPersist
+ *
+ * @param aContext
+ * The browsing context of the subframe we'd like to persist.
+ * If set to nullptr, WebBrowserPersistable will attempt to persist
+ * the top-level document. If the browsing context is for a subframe
+ * that is not held beneath the WebBrowserPersistable, aRecv's onError
+ * method will be called with NS_ERROR_NO_CONTENT.
+ * @param aRecv
+ * The nsIWebBrowserPersistDocumentReceiver is a callback that
+ * will be fired once the document is ready for persisting.
+ */
+interface mixin WebBrowserPersistable
+{
+ [Throws]
+ undefined startPersistence(BrowsingContext? aContext,
+ nsIWebBrowserPersistDocumentReceiver aRecv);
+};
+
+enum PrintPreviewOrientation {
+ "landscape",
+ "portrait",
+ "unspecified"
+};
+
+/**
+ * Interface for the object that's used to resolve the Promise returned from
+ * FrameLoader.printPreview() if that method successfully creates the print
+ * preview document/successfully updates it with new settings.
+ */
+[GenerateConversionToJS]
+dictionary PrintPreviewSuccessInfo {
+ /**
+ * The total number of sheets of paper required to print, taking into account
+ * the provided nsIPrintSettings. This takes into account page range
+ * selection, the pages-per-sheet, whether duplex printing is enabled, etc.
+ */
+ unsigned long sheetCount = 0;
+
+ /**
+ * The total number of virtual pages, not taking into account page range
+ * selection, the pages-per-sheet, whether duplex printing is enabled, etc.
+ */
+ unsigned long totalPageCount = 0;
+
+ /**
+ * Whether the preview is empty because of page range selection.
+ */
+ boolean isEmpty = false;
+
+ /**
+ * Whether the document or any subdocument has a selection that can be
+ * printed.
+ */
+ boolean hasSelection = false;
+
+ /**
+ * Whether the previewed document has a selection itself.
+ */
+ boolean hasSelfSelection = false;
+
+ /**
+ * Specified orientation of the document, or "unspecified".
+ */
+ PrintPreviewOrientation orientation = "unspecified";
+
+ /**
+ * Specified page width of the document in inches, or null if no @page size was specified.
+ */
+ float? pageWidth = null;
+
+ /**
+ * Specified page height of the document in inches, or null if no @page size was specified.
+ */
+ float? pageHeight = null;
+};
+
+FrameLoader includes WebBrowserPersistable;
diff --git a/dom/chrome-webidl/Glean.webidl b/dom/chrome-webidl/Glean.webidl
new file mode 100644
index 0000000000..f8f55e2418
--- /dev/null
+++ b/dom/chrome-webidl/Glean.webidl
@@ -0,0 +1,45 @@
+/* -*- Mode: IDL; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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/.
+ */
+
+interface nsISupports;
+
+[ChromeOnly, Exposed=Window]
+interface GleanCategory {
+ /**
+ * Get a metric by name.
+ *
+ * Returns an object of the corresponding metric type,
+ * with only the allowed functions available.
+ */
+ getter nsISupports (DOMString identifier);
+};
+
+[ChromeOnly, Exposed=Window]
+interface GleanImpl {
+ /**
+ * Get a metric category by name.
+ *
+ * Returns an object for further metric lookup.
+ */
+ getter GleanCategory (DOMString identifier);
+};
+
+[ChromeOnly, Exposed=Window]
+interface GleanLabeled {
+ /**
+ * Get a specific metric for a given label.
+ *
+ * If a set of acceptable labels were specified in the `metrics.yaml` file,
+ * and the given label is not in the set, it will be recorded under the
+ * special `OTHER_LABEL` label.
+ *
+ * If a set of acceptable labels was not specified in the `metrics.yaml` file,
+ * only the first 16 unique labels will be used.
+ * After that, any additional labels will be recorded under the special
+ * `OTHER_LABEL` label.
+ */
+ getter nsISupports (DOMString identifier);
+};
diff --git a/dom/chrome-webidl/GleanPings.webidl b/dom/chrome-webidl/GleanPings.webidl
new file mode 100644
index 0000000000..3dee22205b
--- /dev/null
+++ b/dom/chrome-webidl/GleanPings.webidl
@@ -0,0 +1,15 @@
+/* -*- Mode: IDL; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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/.
+ */
+
+interface nsIGleanPing;
+
+[ChromeOnly, Exposed=Window]
+interface GleanPingsImpl {
+ /**
+ * Get a ping by name.
+ */
+ getter nsIGleanPing (DOMString identifier);
+};
diff --git a/dom/chrome-webidl/HeapSnapshot.webidl b/dom/chrome-webidl/HeapSnapshot.webidl
new file mode 100644
index 0000000000..8b1b0b1a14
--- /dev/null
+++ b/dom/chrome-webidl/HeapSnapshot.webidl
@@ -0,0 +1,105 @@
+/* -*- Mode: IDL; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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/.
+ */
+
+/**
+ * A HeapSnapshot represents a snapshot of the heap graph
+ */
+[ChromeOnly, Exposed=(Window,Worker)]
+interface HeapSnapshot {
+ /**
+ * A time stamp of when the heap snapshot was taken, if available. Units are
+ * microseconds since midnight (00:00:00) 1 January 1970 UTC.
+ */
+ readonly attribute unsigned long long? creationTime;
+
+ /**
+ * Take a census of the heap snapshot.
+ *
+ * This is the same as |Debugger.Memory.prototype.takeCensus|, but operates on
+ * the offline heap snapshot's serialized heap graph rather than the live heap
+ * graph. The same optional configuration options that can be passed to that
+ * function can be passed here.
+ *
+ * The returned value is determined by the `"breakdown"` option used, and is
+ * usually a `Map`, `Object`, or `Array`. For example, the following breakdown
+ *
+ * {
+ * by: "coarseType",
+ * objects: { by: "objectClass" },
+ * other: { by: "internalType" }
+ * }
+ *
+ * produces a result like this:
+ *
+ * {
+ * "objects": {
+ * "Function": { "count": 404, "bytes": 37328 },
+ * "Object": { "count": 11, "bytes": 1264 },
+ * "Debugger": { "count": 1, "bytes": 416 },
+ * "ScriptSource": { "count": 1, "bytes": 64 },
+ * // ... omitted for brevity...
+ * },
+ * "scripts": { "count": 1, "bytes": 0 },
+ * "strings": { "count": 701, "bytes": 49080 },
+ * "other": {
+ * "js::Shape": { "count": 450, "bytes": 0 },
+ * "js::BaseShape": { "count": 21, "bytes": 0 },
+ * "js::ObjectGroup": { "count": 17, "bytes": 0 }
+ * }
+ * }
+ *
+ * See the `takeCensus` section of the `js/src/doc/Debugger/Debugger.Memory.md`
+ * file for detailed documentation.
+ */
+ [Throws]
+ any takeCensus(object? options);
+
+ /**
+ * Describe `node` with the specified `breakdown`. See the comment above
+ * `takeCensus` or `js/src/doc/Debugger/Debugger.Memory.md` for detailed
+ * documentation on breakdowns.
+ *
+ * Throws an error when `node` is not the id of a node in the heap snapshot,
+ * or if the breakdown is invalid.
+ */
+ [Throws]
+ any describeNode(object breakdown, NodeId node);
+
+ /**
+ * Compute the dominator tree for this heap snapshot.
+ *
+ * @see DominatorTree.webidl
+ */
+ [Throws]
+ DominatorTree computeDominatorTree();
+
+ /**
+ * Find the shortest retaining paths from the node associated with the ID
+ * `start` to each node associated with the IDs in `targets`. Find at most
+ * `maxNumPaths` retaining paths for each target node.
+ *
+ * The return value is a Map object mapping from each target node ID to an
+ * array of retaining paths. The array may be empty if we did not find any
+ * retaining paths.
+ *
+ * A path is an array of objects of the form:
+ *
+ * {
+ * predecessor: <node ID>,
+ * edge: <string or null>,
+ * }
+ *
+ * The first `predecessor` will always be `start`. The last edge in the path
+ * leads to the `target` node that is mapped to the path; the `target` does
+ * not appear as a `predecessor` in the path.
+ *
+ * Throws when `start` or any of the elements of `targets` are not an ID of a
+ * node in the snapshot, or if we encounter an out of memory exception.
+ */
+ [Throws]
+ object computeShortestPaths(NodeId start, sequence<NodeId> targets,
+ unsigned long long maxNumPaths);
+};
diff --git a/dom/chrome-webidl/IOUtils.webidl b/dom/chrome-webidl/IOUtils.webidl
new file mode 100644
index 0000000000..d22933ba5f
--- /dev/null
+++ b/dom/chrome-webidl/IOUtils.webidl
@@ -0,0 +1,774 @@
+/* -*- Mode: IDL; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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/.
+ */
+
+interface nsIFile;
+
+/**
+ * IOUtils is a simple, efficient interface for performing file I/O from a
+ * privileged chrome-only context. All asynchronous I/O tasks are run on
+ * a background thread.
+ *
+ * Pending I/O tasks will block shutdown at the |profileBeforeChange| phase.
+ * During this shutdown phase, no additional I/O tasks will be accepted --
+ * method calls to this interface will reject once shutdown has entered this
+ * phase.
+ *
+ * IOUtils methods may reject for any number of reasons. Reasonable attempts
+ * have been made to map each common operating system error to a |DOMException|.
+ * Most often, a caller only needs to check if a given file wasn't found by
+ * catching the rejected error and checking if |ex.name === 'NotFoundError'|.
+ * In other cases, it is likely sufficient to allow the error to be caught and
+ * reported elsewhere.
+ */
+[ChromeOnly, Exposed=(Window, Worker)]
+namespace IOUtils {
+ /**
+ * Reads up to |opts.maxBytes| of the file at |path| according to |opts|.
+ *
+ * NB: The maximum file size that can be read is UINT32_MAX.
+ *
+ * @param path An absolute file path.
+ *
+ * @return Resolves with an array of unsigned byte values read from disk,
+ * otherwise rejects with a DOMException.
+ */
+ [NewObject]
+ Promise<Uint8Array> read(DOMString path, optional ReadOptions opts = {});
+ /**
+ * Reads the UTF-8 text file located at |path| and returns the decoded
+ * contents as a |DOMString|.
+ *
+ * NB: The maximum file size that can be read is UINT32_MAX.
+ *
+ * @param path An absolute file path.
+ *
+ * @return Resolves with the file contents encoded as a string, otherwise
+ * rejects with a DOMException.
+ */
+ [NewObject]
+ Promise<UTF8String> readUTF8(DOMString path, optional ReadUTF8Options opts = {});
+ /**
+ * Read the UTF-8 text file located at |path| and return the contents
+ * parsed as JSON into a JS value.
+ *
+ * NB: The maximum file size that can be read is UINT32_MAX.
+ *
+ * @param path An absolute path.
+ *
+ * @return Resolves with the contents of the file parsed as JSON.
+ */
+ [NewObject]
+ Promise<any> readJSON(DOMString path, optional ReadUTF8Options opts = {});
+ /**
+ * Attempts to safely write |data| to a file at |path|.
+ *
+ * This operation can be made atomic by specifying the |tmpPath| option. If
+ * specified, then this method ensures that the destination file is not
+ * modified until the data is entirely written to the temporary file, after
+ * which point the |tmpPath| is moved to the specified |path|.
+ *
+ * The target file can also be backed up to a |backupFile| before any writes
+ * are performed to prevent data loss in case of corruption.
+ *
+ * @param path An absolute file path.
+ * @param data Data to write to the file at path.
+ *
+ * @return Resolves with the number of bytes successfully written to the file,
+ * otherwise rejects with a DOMException.
+ */
+ [NewObject]
+ Promise<unsigned long long> write(DOMString path, Uint8Array data, optional WriteOptions options = {});
+ /**
+ * Attempts to encode |string| to UTF-8, then safely write the result to a
+ * file at |path|. Works exactly like |write|.
+ *
+ * @param path An absolute file path.
+ * @param string A string to write to the file at path.
+ * @param options Options for writing the file.
+ *
+ * @return Resolves with the number of bytes successfully written to the file,
+ * otherwise rejects with a DOMException.
+ */
+ [NewObject]
+ Promise<unsigned long long> writeUTF8(DOMString path, UTF8String string, optional WriteOptions options = {});
+ /**
+ * Attempts to serialize |value| into a JSON string and encode it as into a
+ * UTF-8 string, then safely write the result to a file at |path|. Works
+ * exactly like |write|.
+ *
+ * @param path An absolute file path
+ * @param value The value to be serialized.
+ * @param options Options for writing the file. The "append" mode is not supported.
+ *
+ * @return Resolves with the number of bytes successfully written to the file,
+ * otherwise rejects with a DOMException.
+ */
+ [NewObject]
+ Promise<unsigned long long> writeJSON(DOMString path, any value, optional WriteOptions options = {});
+ /**
+ * Moves the file from |sourcePath| to |destPath|, creating necessary parents.
+ * If |destPath| is a directory, then the source file will be moved into the
+ * destination directory.
+ *
+ * @param sourcePath An absolute file path identifying the file or directory
+ * to move.
+ * @param destPath An absolute file path identifying the destination
+ * directory and/or file name.
+ *
+ * @return Resolves if the file is moved successfully, otherwise rejects with
+ * a DOMException.
+ */
+ [NewObject]
+ Promise<undefined> move(DOMString sourcePath, DOMString destPath, optional MoveOptions options = {});
+ /**
+ * Removes a file or directory at |path| according to |options|.
+ *
+ * @param path An absolute file path identifying the file or directory to
+ * remove.
+ *
+ * @return Resolves if the file is removed successfully, otherwise rejects
+ * with a DOMException.
+ */
+ [NewObject]
+ Promise<undefined> remove(DOMString path, optional RemoveOptions options = {});
+ /**
+ * Creates a new directory at |path| according to |options|.
+ *
+ * @param path An absolute file path identifying the directory to create.
+ *
+ * @return Resolves if the directory is created successfully, otherwise
+ * rejects with a DOMException.
+ */
+ [NewObject]
+ Promise<undefined> makeDirectory(DOMString path, optional MakeDirectoryOptions options = {});
+ /**
+ * Obtains information about a file, such as size, modification dates, etc.
+ *
+ * @param path An absolute file path identifying the file or directory to
+ * inspect.
+ *
+ * @return Resolves with a |FileInfo| object for the file at path, otherwise
+ * rejects with a DOMException.
+ *
+ * @see FileInfo
+ */
+ [NewObject]
+ Promise<FileInfo> stat(DOMString path);
+ /**
+ * Copies a file or directory from |sourcePath| to |destPath| according to
+ * |options|.
+ *
+ * @param sourcePath An absolute file path identifying the source file to be
+ * copied.
+ * @param destPath An absolute file path identifying the location for the
+ * copy.
+ *
+ * @return Resolves if the file was copied successfully, otherwise rejects
+ * with a DOMException.
+ */
+ [NewObject]
+ Promise<undefined> copy(DOMString sourcePath, DOMString destPath, optional CopyOptions options = {});
+ /**
+ * Updates the access time for the file at |path|.
+ *
+ * @param path An absolute file path identifying the file whose
+ * modification time is to be set. This file must exist
+ * and will not be created.
+ * @param modification An optional access time for the file expressed in
+ * milliseconds since the Unix epoch
+ * (1970-01-01T00:00:00Z). The current system time is used
+ * if this parameter is not provided.
+ *
+ * @return Resolves with the updated access time time expressed in
+ * milliseconds since the Unix epoch, otherwise rejects with a
+ * DOMException.
+ */
+ [NewObject]
+ Promise<long long> setAccessTime(DOMString path, optional long long access);
+ /**
+ * Updates the modification time for the file at |path|.
+ *
+ * @param path An absolute file path identifying the file whose
+ * modification time is to be set. This file must exist
+ * and will not be created.
+ * @param modification An optional modification time for the file expressed in
+ * milliseconds since the Unix epoch
+ * (1970-01-01T00:00:00Z). The current system time is used
+ * if this parameter is not provided.
+ *
+ * @return Resolves with the updated modification time expressed in
+ * milliseconds since the Unix epoch, otherwise rejects with a
+ * DOMException.
+ */
+ [NewObject]
+ Promise<long long> setModificationTime(DOMString path, optional long long modification);
+ /**
+ * Retrieves a (possibly empty) list of immediate children of the directory at
+ * |path|.
+ *
+ * @param path An absolute file path.
+ *
+ * @return Resolves with a sequence of absolute file paths representing the
+ * children of the directory at |path|, otherwise rejects with a
+ * DOMException.
+ */
+ [NewObject]
+ Promise<sequence<DOMString>> getChildren(DOMString path, optional GetChildrenOptions options = {});
+ /**
+ * Set the permissions of the file at |path|.
+ *
+ * Windows does not make a distinction between user, group, and other
+ * permissions like UNICES do. If a permission flag is set for any of user,
+ * group, or other has a permission, then all users will have that
+ * permission. Additionally, Windows does not support setting the
+ * "executable" permission.
+ *
+ * @param path An absolute file path
+ * @param permissions The UNIX file mode representing the permissions.
+ * @param honorUmask If omitted or true, any UNIX file mode value is
+ * modified by the process umask. If false, the exact value
+ * of UNIX file mode will be applied. This value has no effect
+ * on Windows.
+ *
+ * @return Resolves if the permissions were set successfully, otherwise
+ * rejects with a DOMException.
+ */
+ [NewObject]
+ Promise<undefined> setPermissions(DOMString path, unsigned long permissions, optional boolean honorUmask = true);
+ /**
+ * Return whether or not the file exists at the given path.
+ *
+ * @param path An absolute file path.
+ *
+ * @return A promise that resolves to whether or not the given file exists.
+ */
+ [NewObject]
+ Promise<boolean> exists(DOMString path);
+
+ /**
+ * Create a file with a unique name and return its path.
+ *
+ * @param parent An absolute path to the directory where the file is to be
+ * created.
+ * @param prefix A prefix for the filename.
+ *
+ * @return A promise that resolves to a unique filename.
+ */
+ [NewObject]
+ Promise<DOMString> createUniqueFile(DOMString parent, DOMString prefix, optional unsigned long permissions = 0644);
+
+ /**
+ * Create a directory with a unique name and return its path.
+ *
+ * @param parent An absolute path to the directory where the file is to be
+ * created.
+ * @param prefix A prefix for the directory name.
+ *
+ * @return A promise that resolves to a unique directory name.
+ */
+ [NewObject]
+ Promise<DOMString> createUniqueDirectory(DOMString parent, DOMString prefix, optional unsigned long permissions = 0755);
+
+ /**
+ * Compute the hash of a file as a hex digest.
+ *
+ * @param path The absolute path of the file to hash.
+ * @param method The hashing method to use.
+ *
+ * @return A promise that resolves to the hex digest of the file's hash in lowercase.
+ */
+ [NewObject]
+ Promise<UTF8String> computeHexDigest(DOMString path, HashAlgorithm method);
+
+#if defined(XP_WIN)
+ /**
+ * Return the Windows-specific file attributes of the file at the given path.
+ *
+ * @param path An absolute file path.
+ *
+ * @return A promise that resolves to the Windows-specific file attributes.
+ */
+ [NewObject]
+ Promise<WindowsFileAttributes> getWindowsAttributes(DOMString path);
+
+ /**
+ * Set the Windows-specific file attributes of the file at the given path.
+ *
+ * @param path An absolute file path.
+ * @param attrs The attributes to set. Attributes will only be set if they are
+ * |true| or |false| (i.e., |undefined| attributes are not
+ * changed).
+ *
+ * @return A promise that resolves is the attributes were set successfully.
+ */
+ [NewObject]
+ Promise<undefined> setWindowsAttributes(DOMString path, optional WindowsFileAttributes attrs = {});
+#elif defined(XP_MACOSX)
+ /**
+ * Return whether or not the file has a specific extended attribute.
+ *
+ * @param path An absolute path.
+ * @param attr The attribute to check for.
+ *
+ * @return A promise that resolves to whether or not the file has an extended
+ * attribute, or rejects with an error.
+ */
+ [NewObject]
+ Promise<boolean> hasMacXAttr(DOMString path, UTF8String attr);
+ /**
+ * Return the value of an extended attribute for a file.
+ *
+ * @param path An absolute path.
+ * @param attr The attribute to get the value of.
+ *
+ * @return A promise that resolves to the value of the extended attribute, or
+ * rejects with an error.
+ */
+ [NewObject]
+ Promise<Uint8Array> getMacXAttr(DOMString path, UTF8String attr);
+ /**
+ * Set the extended attribute on a file.
+ *
+ * @param path An absolute path.
+ * @param attr The attribute to set.
+ * @param value The value of the attribute to set.
+ *
+ * @return A promise that resolves to whether or not the file has an extended
+ * attribute, or rejects with an error.
+ */
+ [NewObject]
+ Promise<undefined> setMacXAttr(DOMString path, UTF8String attr, Uint8Array value);
+ /**
+ * Delete the extended attribute on a file.
+ *
+ * @param path An absolute path.
+ * @param attr The attribute to delete.
+ *
+ * @return A promise that resolves if the attribute was deleted, or rejects
+ * with an error.
+ */
+ [NewObject]
+ Promise<undefined> delMacXAttr(DOMString path, UTF8String attr);
+#endif
+
+ /**
+ * Return a nsIFile whose parent directory exists. The parent directory of the
+ * file will be created off main thread if it does not already exist.
+ *
+ * @param components The path components. The first component must be an
+ * absolute path.
+ *
+ * @return A promise that resolves to an nsIFile for the requested file.
+ */
+ [NewObject]
+ Promise<nsIFile> getFile(DOMString... components);
+
+ /**
+ * Return an nsIFile corresponding to a directory. It will be created
+ * off-main-thread if it does not already exist.
+ *
+ * @param components The path components. The first component must be an
+ * absolute path.
+ *
+ * @return A promise that resolves to an nsIFile for the requested directory.
+ */
+ [NewObject]
+ Promise<nsIFile> getDirectory(DOMString... components);
+};
+
+[Exposed=Window]
+partial namespace IOUtils {
+ /**
+ * The async shutdown client for the profile-before-change shutdown phase.
+ */
+ [Throws]
+ readonly attribute any profileBeforeChange;
+
+ /**
+ * The async shutdown client for the profile-before-change-telemetry shutdown
+ * phase.
+ *
+ * ONLY telemetry should register blockers on this client.
+ */
+ [Throws]
+ readonly attribute any sendTelemetry;
+};
+
+[Exposed=Worker]
+partial namespace IOUtils {
+ /**
+ * Synchronously opens the file at |path|. This API is only available in workers.
+ *
+ * @param path An absolute file path.
+ *
+ * @return A |SyncReadFile| object for the file.
+ */
+ [Throws]
+ SyncReadFile openFileForSyncReading(DOMString path);
+
+#ifdef XP_UNIX
+ /**
+ * Launch a child process; uses `base::LaunchApp` from IPC. (This WebIDL
+ * binding is currently Unix-only; it could also be supported on Windows
+ * but it would use u16-based strings, so it would basically be a separate
+ * copy of the bindings.)
+ *
+ * This interface was added for use by `Subprocess.sys.jsm`; other would-be
+ * callers may want to just use Subprocess instead of calling this directly.
+ *
+ * @param argv The command to run and its arguments.
+ * @param options Various parameters about how the child process is launched
+ * and its initial environment.
+ *
+ * @return The process ID. Note that various errors (e.g., the
+ * executable to be launched doesn't exist) may not be
+ * encountered until after the process is created, so a
+ * successful return doesn't necessarily imply a successful
+ * launch.
+ */
+ [Throws]
+ unsigned long launchProcess(sequence<UnixString> argv, LaunchOptions options);
+#endif
+};
+
+/**
+ * An object representing an open file, allowing parts of the file contents to be
+ * read synchronously. Only available in workers.
+ */
+[ChromeOnly, Exposed=Worker]
+interface SyncReadFile {
+ /**
+ * The file size, in bytes.
+ */
+ readonly attribute long long size;
+
+ /**
+ * Synchronously read |dest.length| bytes at offset |offset| into |dest|.
+ * Throws if the file has been closed already or if the read would be out-of-bounds.
+ *
+ * @param dest A Uint8Array whose entire contents will be overwritten with
+ * bytes read from the file.
+ * @param offset The file offset at which the read range begins. (The length of the
+ * range is given by |dest.length|.)
+ */
+ [Throws]
+ undefined readBytesInto(Uint8Array dest, long long offset);
+
+ /**
+ * Close the file. Subsequent calls to readBytesInto will throw.
+ * If the file is not closed manually, it will be closed once this object is GC'ed.
+ */
+ undefined close();
+};
+
+/**
+ * Options to be passed to the |IOUtils.readUTF8| method.
+ */
+dictionary ReadUTF8Options {
+ /**
+ * If true, this option indicates that the file to be read is compressed with
+ * LZ4-encoding, and should be decompressed before the data is returned to
+ * the caller.
+ */
+ boolean decompress = false;
+};
+
+/**
+ * Options to be passed to the |IOUtils.read| method.
+ */
+dictionary ReadOptions : ReadUTF8Options {
+ /**
+ * The offset into the file to read from. If unspecified, the file will be read
+ * from the start.
+ */
+ unsigned long long offset = 0;
+
+ /**
+ * The max bytes to read from the file at path. If unspecified, the entire
+ * file will be read. This option is incompatible with |decompress|.
+ */
+ unsigned long? maxBytes = null;
+};
+
+/**
+ * Modes for writing to a file.
+ */
+enum WriteMode {
+ /**
+ * Overwrite the contents of the file.
+ *
+ * The file will be created if it does not exist.
+ */
+ "overwrite",
+ /**
+ * Append to the end of the file.
+ *
+ * This mode will refuse to create the file if it does not exist.
+ */
+ "append",
+ /**
+ * Append to the end of the file, or create it if it does not exist.
+ */
+ "appendOrCreate",
+ /**
+ * Create a new file.
+ *
+ * This mode will refuse to overwrite an existing file.
+ */
+ "create",
+};
+
+/**
+ * Options to be passed to the |IOUtils.write| and |writeUTF8|
+ * methods.
+ */
+dictionary WriteOptions {
+ /**
+ * If specified, backup the destination file to this path before writing.
+ */
+ DOMString backupFile;
+ /**
+ * If specified, write the data to a file at |tmpPath| instead of directly to
+ * the destination. Once the write is complete, the destination will be
+ * overwritten by a move. Specifying this option will make the write a little
+ * slower, but also safer.
+ */
+ DOMString tmpPath;
+ /**
+ * The mode used to write to the file.
+ */
+ WriteMode mode = "overwrite";
+ /**
+ * If true, force the OS to write its internal buffers to the disk.
+ * This is considerably slower for the whole system, but safer in case of
+ * an improper system shutdown (e.g. due to a kernel panic) or device
+ * disconnection before the buffers are flushed.
+ */
+ boolean flush = false;
+ /**
+ * If true, compress the data with LZ4-encoding before writing to the file.
+ */
+ boolean compress = false;
+};
+
+/**
+ * Options to be passed to the |IOUtils.move| method.
+ */
+dictionary MoveOptions {
+ /**
+ * If true, fail if the destination already exists.
+ */
+ boolean noOverwrite = false;
+};
+
+/**
+ * Options to be passed to the |IOUtils.remove| method.
+ */
+dictionary RemoveOptions {
+ /**
+ * If true, no error will be reported if the target file is missing.
+ */
+ boolean ignoreAbsent = true;
+ /**
+ * If true, and the target is a directory, recursively remove files.
+ */
+ boolean recursive = false;
+
+ /**
+ * If true, a failed delete on a readonly file will be retried by first
+ * removing the readonly attribute.
+ *
+ * Only has an effect on Windows.
+ */
+ boolean retryReadonly = false;
+};
+
+/**
+ * Options to be passed to the |IOUtils.makeDirectory| method.
+ */
+dictionary MakeDirectoryOptions {
+ /**
+ * If true, create the directory and all necessary ancestors if they do not
+ * already exist. If false and any ancestor directories do not exist,
+ * |makeDirectory| will reject with an error.
+ */
+ boolean createAncestors = true;
+ /**
+ * If true, succeed even if the directory already exists (default behavior).
+ * Otherwise, fail if the directory already exists.
+ */
+ boolean ignoreExisting = true;
+ /**
+ * The file mode to create the directory with.
+ *
+ * This is ignored on Windows.
+ */
+ unsigned long permissions = 0755;
+
+};
+
+/**
+ * Options to be passed to the |IOUtils.copy| method.
+ */
+dictionary CopyOptions {
+ /**
+ * If true, fail if the destination already exists.
+ */
+ boolean noOverwrite = false;
+ /**
+ * If true, copy the source recursively.
+ */
+ boolean recursive = false;
+};
+
+/**
+ * Options to be passed to the |IOUtils.getChildren| method.
+ */
+dictionary GetChildrenOptions {
+ /**
+ * If true, no error will be reported if the target file is missing.
+ */
+ boolean ignoreAbsent = false;
+};
+
+/**
+ * Types of files that are recognized by the |IOUtils.stat| method.
+ */
+enum FileType { "regular", "directory", "other" };
+
+/**
+ * Basic metadata about a file.
+ */
+dictionary FileInfo {
+ /**
+ * The absolute path to the file on disk, as known when this file info was
+ * obtained.
+ */
+ DOMString path;
+
+ /**
+ * Identifies if the file at |path| is a regular file, directory, or something
+ * something else.
+ */
+ FileType type;
+
+ /**
+ * If this represents a regular file, the size of the file in bytes.
+ * Otherwise, -1.
+ */
+ long long size;
+
+ /**
+ * The timestamp of file creation, represented in milliseconds since Epoch
+ * (1970-01-01T00:00:00.000Z).
+ *
+ * This is only available on MacOS and Windows.
+ */
+ long long creationTime;
+
+ /**
+ * The timestmp of last file accesss, represented in milliseconds since Epoch
+ * (1970-01-01T00:00:00.000Z).
+ */
+ long long lastAccessed;
+
+ /**
+ * The timestamp of the last file modification, represented in milliseconds
+ * since Epoch (1970-01-01T00:00:00.000Z).
+ */
+ long long lastModified;
+
+ /**
+ * The permissions of the file, expressed as a UNIX file mode.
+ *
+ * NB: Windows does not make a distinction between user, group, and other
+ * permissions like UNICES do. The user, group, and other parts will always
+ * be identical on Windows.
+ */
+ unsigned long permissions;
+};
+
+/**
+ * The supported hash algorithms for |IOUtils.hashFile|.
+ */
+enum HashAlgorithm { "sha1", "sha256", "sha384", "sha512" };
+
+#ifdef XP_WIN
+/**
+ * Windows-specific file attributes.
+ */
+dictionary WindowsFileAttributes {
+ /**
+ * Whether or not the file is read-only.
+ */
+ boolean readOnly;
+ /**
+ * Whether or not the file is hidden.
+ */
+ boolean hidden;
+ /**
+ * Whether or not the file is classified as a system file.
+ */
+ boolean system;
+};
+#endif
+
+#ifdef XP_UNIX
+/**
+ * Used where the POSIX API allows an arbitrary byte string but in
+ * practice it's usually UTF-8, so JS strings are accepted for
+ * convenience.
+ */
+typedef (UTF8String or Uint8Array) UnixString;
+
+/**
+ * Options for the `launchApp` method. See also `base::LaunchOptions`
+ * in C++.
+ */
+dictionary LaunchOptions {
+ /**
+ * The environment variables, as a sequence of `NAME=value` strings.
+ * (The underlying C++ code can also inherit the current environment
+ * with optional changes; that feature could be added here if needed.)
+ */
+ required sequence<UnixString> environment;
+
+ /**
+ * The initial current working directory.
+ */
+ UnixString workdir;
+
+ /**
+ * File descriptors to pass to the child process. Any fds not
+ * mentioned here, other than stdin/out/err, will not be inherited
+ * even if they aren't marked close-on-exec.
+ */
+ sequence<FdMapping> fdMap;
+
+ /**
+ * On macOS 10.14+, disclaims responsibility for the child process
+ * with respect to privacy/security permission prompts and
+ * decisions. Ignored if not supported by the OS.
+ */
+ boolean disclaim = false;
+};
+
+/**
+ * Describes a file descriptor to give to the child process.
+ */
+dictionary FdMapping {
+ /**
+ * The fd in the parent process to pass. This must remain open during
+ * the call to `launchApp` but can be closed after it returns (or throws).
+ */
+ required unsigned long src;
+
+ /**
+ * The fd number to map it to in the child process.
+ */
+ required unsigned long dst;
+};
+#endif
diff --git a/dom/chrome-webidl/ImageText.webidl b/dom/chrome-webidl/ImageText.webidl
new file mode 100644
index 0000000000..262a82b353
--- /dev/null
+++ b/dom/chrome-webidl/ImageText.webidl
@@ -0,0 +1,29 @@
+/* -*- Mode: IDL; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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/.
+ */
+
+/**
+ * Text that has been extracted from an image using an image recognition API.
+ */
+dictionary ImageText {
+ /**
+ * A scalar value representing how confident the text recognition model was in the
+ * produced result.
+ */
+ required float confidence;
+
+ /**
+ * The recognized text.
+ */
+ required DOMString string;
+
+ /**
+ * A DOMQuad representing the bounds of the text. This can be a free-form four pointed
+ * polygon, and not necessarily a square or parallelogram. It does not actually contain
+ * CSSPixels, but the points are ranged 0-1 and represent a ratio of the width / height
+ * of the source image.
+ */
+ required DOMQuad quad;
+};
diff --git a/dom/chrome-webidl/InspectorUtils.webidl b/dom/chrome-webidl/InspectorUtils.webidl
new file mode 100644
index 0000000000..0c0a356728
--- /dev/null
+++ b/dom/chrome-webidl/InspectorUtils.webidl
@@ -0,0 +1,189 @@
+/* -*- Mode: IDL; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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/.
+ */
+
+/**
+ * A collection of utility methods for use by devtools.
+ *
+ * See InspectorUtils.h for documentation on these methods.
+ */
+[Func="nsContentUtils::IsCallerChromeOrFuzzingEnabled",
+ Exposed=Window]
+namespace InspectorUtils {
+ // documentOnly tells whether user and UA sheets should get included.
+ sequence<StyleSheet> getAllStyleSheets(Document document, optional boolean documentOnly = false);
+ sequence<CSSStyleRule> getCSSStyleRules(
+ Element element,
+ optional [LegacyNullToEmptyString] DOMString pseudo = "",
+ optional boolean relevantLinkVisited = false);
+ unsigned long getRuleLine(CSSRule rule);
+ unsigned long getRuleColumn(CSSRule rule);
+ unsigned long getRelativeRuleLine(CSSRule rule);
+ boolean hasRulesModifiedByCSSOM(CSSStyleSheet sheet);
+ unsigned long getSelectorCount(CSSStyleRule rule);
+ [Throws] UTF8String getSelectorText(CSSStyleRule rule,
+ unsigned long selectorIndex);
+ [Throws] unsigned long long getSpecificity(CSSStyleRule rule,
+ unsigned long selectorIndex);
+ [Throws] boolean selectorMatchesElement(
+ Element element,
+ CSSStyleRule rule,
+ unsigned long selectorIndex,
+ optional [LegacyNullToEmptyString] DOMString pseudo = "",
+ optional boolean includeVisitedStyle = false);
+ boolean isInheritedProperty(UTF8String property);
+ sequence<DOMString> getCSSPropertyNames(optional PropertyNamesOptions options = {});
+ sequence<PropertyPref> getCSSPropertyPrefs();
+ [Throws] sequence<DOMString> getCSSValuesForProperty(UTF8String property);
+ DOMString rgbToColorName(octet r, octet g, octet b);
+ InspectorRGBATuple? colorToRGBA(UTF8String colorString, optional Document? doc = null);
+ boolean isValidCSSColor(UTF8String colorString);
+ [Throws] sequence<DOMString> getSubpropertiesForCSSProperty(UTF8String property);
+ [Throws] boolean cssPropertyIsShorthand(UTF8String property);
+
+ [Throws] boolean cssPropertySupportsType(UTF8String property, InspectorPropertyType type);
+
+ // A version of CSS.supports that allows you to set UA or chrome context.
+ boolean supports(UTF8String conditionText, optional SupportsOptions options = {});
+
+ boolean isIgnorableWhitespace(CharacterData dataNode);
+ Node? getParentForNode(Node node, boolean showingAnonymousContent);
+ sequence<Node> getChildrenForNode(Node node,
+ boolean showingAnonymousContent,
+ boolean includeAssignedNodes);
+ [Throws] boolean setContentState(Element element, unsigned long long state);
+ [Throws] boolean removeContentState(
+ Element element,
+ unsigned long long state,
+ optional boolean clearActiveDocument = false);
+ unsigned long long getContentState(Element element);
+
+ // Get the font face(s) actually used to render the text in /range/,
+ // as a collection of InspectorFontFace objects (below).
+ // If /maxRanges/ is greater than zero, each InspectorFontFace will record
+ // up to /maxRanges/ fragments of content that used the face, for the caller
+ // to access via its .ranges attribute.
+ [NewObject, Throws] sequence<InspectorFontFace> getUsedFontFaces(
+ Range range,
+ optional unsigned long maxRanges = 0,
+ optional boolean skipCollapsedWhitespace = true);
+
+ sequence<DOMString> getCSSPseudoElementNames();
+ undefined addPseudoClassLock(Element element,
+ DOMString pseudoClass,
+ optional boolean enabled = true);
+ undefined removePseudoClassLock(Element element, DOMString pseudoClass);
+ boolean hasPseudoClassLock(Element element, DOMString pseudoClass);
+ undefined clearPseudoClassLocks(Element element);
+ [Throws] undefined parseStyleSheet(CSSStyleSheet sheet, UTF8String input);
+ boolean isCustomElementName([LegacyNullToEmptyString] DOMString name,
+ DOMString? namespaceURI);
+
+ boolean isElementThemed(Element element);
+
+ Element? containingBlockOf(Element element);
+
+ [NewObject] NodeList getOverflowingChildrenOfElement(Element element);
+};
+
+dictionary SupportsOptions {
+ boolean userAgent = false;
+ boolean chrome = false;
+ boolean quirks = false;
+};
+
+dictionary PropertyNamesOptions {
+ boolean includeAliases = false;
+ boolean includeShorthands = true;
+ boolean includeExperimentals = false;
+};
+
+dictionary PropertyPref {
+ required DOMString name;
+ required DOMString pref;
+};
+
+dictionary InspectorRGBATuple {
+ /*
+ * NOTE: This tuple is in the normal 0-255-sized RGB space but can be
+ * fractional and may extend outside the 0-255 range.
+ *
+ * a is in the range 0 - 1.
+ */
+ double r = 0;
+ double g = 0;
+ double b = 0;
+ double a = 1;
+};
+
+// Any update to this enum should probably also update
+// devtools/shared/css/constants.js
+enum InspectorPropertyType {
+ "color",
+ "gradient",
+ "timing-function",
+};
+
+dictionary InspectorVariationAxis {
+ required DOMString tag;
+ required DOMString name;
+ required float minValue;
+ required float maxValue;
+ required float defaultValue;
+};
+
+dictionary InspectorVariationValue {
+ required DOMString axis;
+ required float value;
+};
+
+dictionary InspectorVariationInstance {
+ required DOMString name;
+ required sequence<InspectorVariationValue> values;
+};
+
+dictionary InspectorFontFeature {
+ required DOMString tag;
+ required DOMString script;
+ required DOMString languageSystem;
+};
+
+[Func="nsContentUtils::IsCallerChromeOrFuzzingEnabled",
+ Exposed=Window]
+interface InspectorFontFace {
+ // An indication of how we found this font during font-matching.
+ // Note that the same physical font may have been found in multiple ways within a range.
+ readonly attribute boolean fromFontGroup;
+ readonly attribute boolean fromLanguagePrefs;
+ readonly attribute boolean fromSystemFallback;
+
+ // available for all fonts
+ readonly attribute DOMString name; // full font name as obtained from the font resource
+ readonly attribute DOMString CSSFamilyName; // a family name that could be used in CSS font-family
+ // (not necessarily the actual name that was used,
+ // due to aliases, generics, localized names, etc)
+ readonly attribute DOMString CSSGeneric; // CSS generic (serif, sans-serif, etc) that was mapped
+ // to this font, if any (frequently empty!)
+
+ [NewObject,Throws] sequence<InspectorVariationAxis> getVariationAxes();
+ [NewObject,Throws] sequence<InspectorVariationInstance> getVariationInstances();
+ [NewObject,Throws] sequence<InspectorFontFeature> getFeatures();
+
+ // A list of Ranges of text rendered with this face.
+ // This will list the first /maxRanges/ ranges found when InspectorUtils.getUsedFontFaces
+ // was called (so it will be empty unless a non-zero maxRanges argument was passed).
+ // Note that this indicates how the document was rendered at the time of calling
+ // getUsedFontFaces; it does not reflect any subsequent modifications, so if styles
+ // have been modified since calling getUsedFontFaces, it may no longer be accurate.
+ [Constant,Cached] readonly attribute sequence<Range> ranges;
+
+ // meaningful only when the font is a user font defined using @font-face
+ readonly attribute CSSFontFaceRule? rule; // null if no associated @font-face rule
+ readonly attribute long srcIndex; // index in the rule's src list, -1 if no @font-face rule
+ readonly attribute DOMString URI; // empty string if not a downloaded font, i.e. local
+ readonly attribute DOMString localName; // empty string if not a src:local(...) rule
+ readonly attribute DOMString format; // as per http://www.w3.org/TR/css3-webfonts/#referencing
+ readonly attribute DOMString metadata; // XML metadata from WOFF file (if any)
+};
diff --git a/dom/chrome-webidl/IteratorResult.webidl b/dom/chrome-webidl/IteratorResult.webidl
new file mode 100644
index 0000000000..b066ab409b
--- /dev/null
+++ b/dom/chrome-webidl/IteratorResult.webidl
@@ -0,0 +1,15 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=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 https://mozilla.org/MPL/2.0/. */
+
+/**
+ * A dictionary which represents the result of a call to a next() method on a
+ * JS iterator object.
+ */
+[GenerateConversionToJS, GenerateInit]
+dictionary IteratorResult {
+ required boolean done;
+ any value;
+};
diff --git a/dom/chrome-webidl/JSActor.webidl b/dom/chrome-webidl/JSActor.webidl
new file mode 100644
index 0000000000..db73fb7994
--- /dev/null
+++ b/dom/chrome-webidl/JSActor.webidl
@@ -0,0 +1,49 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=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/. */
+
+
+interface mixin JSActor {
+ [Throws]
+ undefined sendAsyncMessage(DOMString messageName,
+ optional any obj);
+
+ [NewObject]
+ Promise<any> sendQuery(DOMString messageName,
+ optional any obj);
+
+ readonly attribute UTF8String name;
+};
+
+/**
+ * WebIDL callback interface version of the nsIObserver interface for use when
+ * calling the observe method on JSActors.
+ *
+ * NOTE: This isn't marked as ChromeOnly, as it has no interface object, and
+ * thus cannot be conditionally exposed.
+ */
+[Exposed=Window]
+callback interface MozObserverCallback {
+ undefined observe(nsISupports subject, ByteString topic, DOMString? data);
+};
+
+/**
+ * WebIDL callback interface calling the `didDestroy`, and
+ * `actorCreated` methods on JSActors.
+ */
+[MOZ_CAN_RUN_SCRIPT_BOUNDARY]
+callback MozJSActorCallback = undefined();
+
+/**
+ * The didDestroy method, if present, will be called after the actor is no
+ * longer able to receive any more messages.
+ * The actorCreated method, if present, will be called immediately after the
+ * actor has been created and initialized.
+ */
+[GenerateInit]
+dictionary MozJSActorCallbacks {
+ [ChromeOnly] MozJSActorCallback didDestroy;
+ [ChromeOnly] MozJSActorCallback actorCreated;
+};
diff --git a/dom/chrome-webidl/JSProcessActor.webidl b/dom/chrome-webidl/JSProcessActor.webidl
new file mode 100644
index 0000000000..13a7062427
--- /dev/null
+++ b/dom/chrome-webidl/JSProcessActor.webidl
@@ -0,0 +1,94 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=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/. */
+
+/**
+ * An actor architecture designed to allow compositional parent/content
+ * communications. The lifetime of a JSProcessActor{Child, Parent} is the `ContentParent`
+ * (for the parent-side) / `ContentChild` (for the child-side).
+ */
+
+interface nsISupports;
+
+/**
+ * Base class for parent-side actor.
+ */
+[ChromeOnly, Exposed=Window]
+interface JSProcessActorParent {
+ [ChromeOnly]
+ constructor();
+
+ readonly attribute nsIDOMProcessParent manager;
+};
+JSProcessActorParent includes JSActor;
+
+[ChromeOnly, Exposed=Window]
+interface JSProcessActorChild {
+ [ChromeOnly]
+ constructor();
+
+ readonly attribute nsIDOMProcessChild manager;
+};
+JSProcessActorChild includes JSActor;
+
+
+/**
+ * Used by `ChromeUtils.registerProcessActor()` to register actors.
+ */
+dictionary ProcessActorOptions {
+ /**
+ * An array of remote type which restricts the actor is allowed to instantiate
+ * in specific process type. If this is defined, the prefix of process type
+ * matches the remote type by prefix match is allowed to instantiate, ex: if
+ * Fission is enabled, the prefix of process type will be `webIsolated`, it
+ * can prefix match remote type either `web` or `webIsolated`. If not passed,
+ * all content processes are allowed to instantiate the actor.
+ */
+ sequence<UTF8String> remoteTypes;
+
+ /**
+ * If this is set to `true`, allow this actor to be created for the parent
+ * process.
+ */
+ boolean includeParent = false;
+
+ /** This fields are used for configuring individual sides of the actor. */
+ ProcessActorSidedOptions parent;
+ ProcessActorChildOptions child;
+};
+
+dictionary ProcessActorSidedOptions {
+ /**
+ * The JSM path which should be loaded for the actor on this side.
+ *
+ * Mutually exclusive with `esModuleURI`.
+ *
+ * If neither this nor `esModuleURI` is passed, the specified side cannot receive
+ * messages, but may send them using `sendAsyncMessage` or `sendQuery`.
+ */
+ ByteString moduleURI;
+
+ /**
+ * The ESM path which should be loaded for the actor on this side.
+ *
+ * Mutually exclusive with `moduleURI`.
+ *
+ * If neither this nor `moduleURI` is passed, the specified side cannot
+ * receive messages, but may send them using `sendAsyncMessage` or
+ * `sendQuery`.
+ */
+ ByteString esModuleURI;
+};
+
+dictionary ProcessActorChildOptions : ProcessActorSidedOptions {
+ /**
+ * An array of observer topics to listen to. An observer will be added for each
+ * topic in the list.
+ *
+ * Unlike for JSWindowActor, observers are always invoked, and do not need to
+ * pass an inner or outer window as subject.
+ */
+ sequence<ByteString> observers;
+};
diff --git a/dom/chrome-webidl/JSWindowActor.webidl b/dom/chrome-webidl/JSWindowActor.webidl
new file mode 100644
index 0000000000..767b4854c5
--- /dev/null
+++ b/dom/chrome-webidl/JSWindowActor.webidl
@@ -0,0 +1,186 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=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/. */
+
+/**
+ * An actor architecture designed to allow compositional parent/content
+ * communications. The lifetime of a JSWindowActor{Child, Parent} is the `WindowGlobalParent`
+ * (for the parent-side) / `WindowGlobalChild` (for the child-side).
+ *
+ * See https://firefox-source-docs.mozilla.org/dom/ipc/jsactors.html for
+ * more details on how to use this architecture.
+ */
+
+interface nsISupports;
+
+[ChromeOnly, Exposed=Window]
+interface JSWindowActorParent {
+ [ChromeOnly]
+ constructor();
+
+ /**
+ * Actor initialization occurs after the constructor is called but before the
+ * first message is delivered. Until the actor is initialized, accesses to
+ * manager will fail.
+ */
+ readonly attribute WindowGlobalParent? manager;
+
+ /**
+ * The WindowContext associated with this JSWindowActorParent. For
+ * JSWindowActorParent this is identical to `manager`, but is also exposed as
+ * `windowContext` for consistency with `JSWindowActorChild`. Until the actor
+ * is initialized, accesses to windowContext will fail.
+ */
+ readonly attribute WindowContext? windowContext;
+
+ [Throws]
+ readonly attribute CanonicalBrowsingContext? browsingContext;
+};
+JSWindowActorParent includes JSActor;
+
+[ChromeOnly, Exposed=Window]
+interface JSWindowActorChild {
+ [ChromeOnly]
+ constructor();
+
+ /**
+ * Actor initialization occurs after the constructor is called but before the
+ * first message is delivered. Until the actor is initialized, accesses to
+ * manager will fail.
+ */
+ readonly attribute WindowGlobalChild? manager;
+
+ /**
+ * The WindowContext associated with this JSWindowActorChild. Until the actor
+ * is initialized, accesses to windowContext will fail.
+ */
+ readonly attribute WindowContext? windowContext;
+
+ [Throws]
+ readonly attribute Document? document;
+
+ [Throws]
+ readonly attribute BrowsingContext? browsingContext;
+
+ [Throws]
+ readonly attribute nsIDocShell? docShell;
+
+ /**
+ * NOTE: As this returns a window proxy, it may not be currently referencing
+ * the document associated with this JSWindowActor. Generally prefer using
+ * `document`.
+ */
+ [Throws]
+ readonly attribute WindowProxy? contentWindow;
+};
+JSWindowActorChild includes JSActor;
+
+/**
+ * Used by ChromeUtils.registerWindowActor() to register JS window actor.
+ */
+dictionary WindowActorOptions {
+ /**
+ * If this is set to `true`, allow this actor to be created for subframes,
+ * and not just toplevel window globals.
+ */
+ boolean allFrames = false;
+
+ /**
+ * If this is set to `true`, allow this actor to be created for window
+ * globals loaded in chrome browsing contexts, such as those used to load the
+ * tabbrowser.
+ */
+ boolean includeChrome = false;
+
+ /**
+ * An array of URL match patterns (as accepted by the MatchPattern
+ * class in MatchPattern.webidl) which restrict which pages the actor
+ * may be instantiated for. If this is defined, only documents URL which match
+ * are allowed to have the given actor created for them. Other
+ * documents will fail to have their actor constructed, returning nullptr.
+ */
+ sequence<DOMString> matches;
+
+ /**
+ * An array of remote type which restricts the actor is allowed to instantiate
+ * in specific process type. If this is defined, the prefix of process type
+ * matches the remote type by prefix match is allowed to instantiate, ex: if
+ * Fission is enabled, the prefix of process type will be `webIsolated`, it
+ * can prefix match remote type either `web` or `webIsolated`. If not passed,
+ * all content processes are allowed to instantiate the actor.
+ */
+ sequence<UTF8String> remoteTypes;
+
+ /**
+ * An array of MessageManagerGroup values which restrict which type
+ * of browser elements the actor is allowed to be loaded within.
+ */
+ sequence<DOMString> messageManagerGroups;
+
+ /** This fields are used for configuring individual sides of the actor. */
+ WindowActorSidedOptions parent;
+ WindowActorChildOptions child;
+};
+
+dictionary WindowActorSidedOptions {
+ /**
+ * The JSM path which should be loaded for the actor on this side.
+ *
+ * Mutually exclusive with `esModuleURI`.
+ *
+ * If neither this nor `esModuleURI` is passed, the specified side cannot receive
+ * messages, but may send them using `sendAsyncMessage` or `sendQuery`.
+ */
+ ByteString moduleURI;
+
+ /**
+ * The ESM path which should be loaded for the actor on this side.
+ *
+ * Mutually exclusive with `moduleURI`.
+ *
+ * If neither this nor `moduleURI` is passed, the specified side cannot
+ * receive messages, but may send them using `sendAsyncMessage` or
+ * `sendQuery`.
+ */
+ ByteString esModuleURI;
+};
+
+dictionary WindowActorEventListenerOptions : AddEventListenerOptions {
+ /**
+ * If this attribute is set to true (the default), this event will cause the
+ * actor to be created when it is fired. If the attribute is set false, the
+ * actor will not receive the event unless it had already been created through
+ * some other mechanism.
+ *
+ * This should be set to `false` for event listeners which are only intended
+ * to perform cleanup operations, and will have no effect if the actor doesn't
+ * already exist.
+ */
+ boolean createActor = true;
+};
+
+dictionary WindowActorChildOptions : WindowActorSidedOptions {
+ /**
+ * Events which this actor wants to be listening to. When these events fire,
+ * it will trigger actor creation, and then forward the event to the actor.
+ *
+ * NOTE: Listeners are not attached for windows loaded in chrome docshells.
+ *
+ * NOTE: `once` option is not support due to we register listeners in a shared
+ * location.
+ */
+ record<DOMString, WindowActorEventListenerOptions> events;
+
+ /**
+ * An array of observer topics to listen to. An observer will be added for each
+ * topic in the list.
+ *
+ * Observer notifications in the list use nsGlobalWindowInner or
+ * nsGlobalWindowOuter object as their subject, and the events will only be
+ * dispatched to the corresponding window actor. If additional observer
+ * notification's subjects are needed, please file a bug for that.
+ */
+ sequence<ByteString> observers;
+};
diff --git a/dom/chrome-webidl/L10nOverlays.webidl b/dom/chrome-webidl/L10nOverlays.webidl
new file mode 100644
index 0000000000..afe96cc58b
--- /dev/null
+++ b/dom/chrome-webidl/L10nOverlays.webidl
@@ -0,0 +1,24 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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/. */
+
+dictionary L10nOverlaysError {
+ short code;
+ DOMString translatedElementName;
+ DOMString sourceElementName;
+ DOMString l10nName;
+};
+
+[ChromeOnly,
+ Exposed=Window]
+namespace L10nOverlays {
+ const unsigned short ERROR_UNKNOWN = 1;
+ const unsigned short ERROR_FORBIDDEN_TYPE = 2;
+ const unsigned short ERROR_NAMED_ELEMENT_MISSING = 3;
+ const unsigned short ERROR_NAMED_ELEMENT_TYPE_MISMATCH = 4;
+ const unsigned short ERROR_TRANSLATED_ELEMENT_DISCONNECTED = 5;
+ const unsigned short ERROR_TRANSLATED_ELEMENT_DISALLOWED_DOM = 6;
+
+ sequence<L10nOverlaysError>? translateElement(Element element, optional L10nMessage translation = {});
+};
diff --git a/dom/chrome-webidl/L10nRegistry.webidl b/dom/chrome-webidl/L10nRegistry.webidl
new file mode 100644
index 0000000000..81932b2cd7
--- /dev/null
+++ b/dom/chrome-webidl/L10nRegistry.webidl
@@ -0,0 +1,180 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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/. */
+
+dictionary L10nFileSourceMockFile {
+ required UTF8String path;
+ required UTF8String source;
+};
+
+enum L10nFileSourceHasFileStatus {
+ "present",
+ "missing",
+ "unknown"
+};
+
+dictionary FileSourceOptions {
+ FluentBundleAddResourceOptions addResourceOptions = {};
+};
+
+/**
+ * A `ResourceId` refers to a localization resource that is either required
+ * or optional. The default for a `ResourceId` is that the resource is required.
+ *
+ * If a required resource is missing for a given locale, then the L10nRegistry
+ * will not generate a bundle for that locale, because the resource is required
+ * to be present in order for the bundle to be considered valid.
+ *
+ * If an optional resource is missing for a given locale, then the L10nRegistry
+ * will still generate a bundle for that locale, but entries for the missing
+ * optional resource will be missing in the bundle.
+ *
+ * It is recommended to only use this sparingly, since marking many resources as
+ * optional will increase the state space that the L10nRegistry solver has to cover,
+ * and it will have a negative impact on performance.
+ *
+ * We should also strive to have valid resources for all supported locales, so using
+ * optional resources should be reserved for exceptional circumstances such as
+ * experimental features and features under development.
+ */
+dictionary ResourceId {
+ required UTF8String path;
+ boolean _optional = false;
+};
+
+typedef (UTF8String or ResourceId) L10nResourceId;
+
+/**
+ * The interface represents a single source location for
+ * the registry.
+ *
+ * Examples of sources are:
+ * * Toolkit omni.ja Localization Directory
+ * * Browser omni.ja Localization Directory
+ * * Language Pack Toolkit Localization Directory
+ * * Language Pack Browser Localization Directory
+ */
+[ChromeOnly,
+ Exposed=Window]
+interface L10nFileSource {
+ /**
+ * The `name` is the name of the `L10nFileSource`.
+ *
+ * The `metaSource` is the name of the package that contains the
+ * `L10nFileSource`, e.g. `app` for sources packaged with the browser, or
+ * `langpack` for sources packaged in an addon.
+ *
+ * The `locales` is a list of locales for which resources are contained in
+ * the `L10nFileSource`.
+ *
+ * The `prePath` is the path prefix for files contained in the `L10nFileSource`.
+ *
+ * Optional argument `index` can be used to provide a list
+ * of files available in the source.
+ *
+ * This is particularly useful for custom file sources which
+ * provide a small number of known override files allowing the
+ * registry to avoid trying I/O on the source for all
+ * files not available in the source.
+ */
+ [Throws]
+ constructor(UTF8String name, UTF8String metaSource, sequence<UTF8String> locales, UTF8String prePath, optional FileSourceOptions options = {}, optional sequence<UTF8String> index);
+
+ /**
+ * Tests may want to introduce custom file sources and
+ * register them in a custom `L10nRegistry` to mock
+ * behavior of using localization with test file sources.
+ *
+ * # Example:
+ *
+ * ```
+ * let fs = [
+ * {
+ * "path": "/localization/en-US/test.ftl",
+ * "source": "key = Hello World!",
+ * }
+ * ];
+ * let mockSource = L10nFileSource.createMock("mock", "app", ["en-US"], "/localization/{locale}/", fs);
+ *
+ * let reg = new L10nRegistry();
+ * reg.registerSources([mockSource]);
+ *
+ * let loc = new Localization(["test.ftl"], reg);
+ * let value = await loc.formatValue("key");
+ * assert(value, "Hello World!");
+ * ```
+ */
+ [Throws]
+ static L10nFileSource createMock(UTF8String name, UTF8String metasource, sequence<UTF8String> locales, UTF8String prePath, sequence<L10nFileSourceMockFile> fs);
+
+ readonly attribute UTF8String name;
+ readonly attribute UTF8String metaSource;
+ [Pure, Cached, Frozen]
+ readonly attribute sequence<UTF8String> locales;
+ /**
+ * `prePath` is the root path used together with a relative path to construct the full path used to retrieve a file
+ * out of a file source.
+ *
+ * The `prePath` will usually contain a placeholder `{locale}` which gets replaced with a given locale.
+ */
+ readonly attribute UTF8String prePath;
+ [Pure, Cached, Frozen]
+ readonly attribute sequence<UTF8String>? index;
+
+ [Throws]
+ L10nFileSourceHasFileStatus hasFile(UTF8String locale, UTF8String path);
+ [NewObject]
+ Promise<FluentResource?> fetchFile(UTF8String locale, UTF8String path);
+ [Throws]
+ FluentResource? fetchFileSync(UTF8String locale, UTF8String path);
+};
+
+dictionary FluentBundleIteratorResult
+{
+ required FluentBundle? value;
+ required boolean done;
+};
+
+[LegacyNoInterfaceObject, Exposed=Window]
+interface FluentBundleIterator {
+ FluentBundleIteratorResult next();
+ [Alias="@@iterator"] FluentBundleIterator values();
+};
+
+[LegacyNoInterfaceObject, Exposed=Window]
+interface FluentBundleAsyncIterator {
+ [NewObject]
+ Promise<FluentBundleIteratorResult> next();
+ [Alias="@@asyncIterator"] FluentBundleAsyncIterator values();
+};
+
+dictionary L10nRegistryOptions {
+ FluentBundleOptions bundleOptions = {};
+};
+
+[ChromeOnly, Exposed=Window]
+interface L10nRegistry {
+ constructor(optional L10nRegistryOptions aOptions = {});
+
+ static L10nRegistry getInstance();
+
+ sequence<UTF8String> getAvailableLocales();
+
+ undefined registerSources(sequence<L10nFileSource> aSources);
+ undefined updateSources(sequence<L10nFileSource> aSources);
+ undefined removeSources(sequence<UTF8String> aSources);
+
+ [Throws]
+ boolean hasSource(UTF8String aName);
+ [Throws]
+ L10nFileSource? getSource(UTF8String aName);
+ sequence<UTF8String> getSourceNames();
+ undefined clearSources();
+
+ [Throws, NewObject]
+ FluentBundleIterator generateBundlesSync(sequence<UTF8String> aLocales, sequence<L10nResourceId> aResourceIds);
+
+ [Throws, NewObject]
+ FluentBundleAsyncIterator generateBundles(sequence<UTF8String> aLocales, sequence<L10nResourceId> aResourceIds);
+};
diff --git a/dom/chrome-webidl/MatchGlob.webidl b/dom/chrome-webidl/MatchGlob.webidl
new file mode 100644
index 0000000000..91554d21c4
--- /dev/null
+++ b/dom/chrome-webidl/MatchGlob.webidl
@@ -0,0 +1,26 @@
+/* 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/. */
+
+/**
+ * Represents a simple glob pattern matcher. Any occurrence of "*" in the glob
+ * pattern matches any literal string of characters in the string being
+ * compared. Additionally, if created with `allowQuestion = true`, any
+ * occurrence of "?" in the glob matches any single literal character.
+ */
+[ChromeOnly, Exposed=Window]
+interface MatchGlob {
+ [Throws]
+ constructor(UTF8String glob, optional boolean allowQuestion = true);
+
+ /**
+ * Returns true if the string matches the glob.
+ */
+ boolean matches(UTF8String string);
+
+ /**
+ * The glob string this MatchGlob represents.
+ */
+ [Constant]
+ readonly attribute UTF8String glob;
+};
diff --git a/dom/chrome-webidl/MatchPattern.webidl b/dom/chrome-webidl/MatchPattern.webidl
new file mode 100644
index 0000000000..4e75d39ba2
--- /dev/null
+++ b/dom/chrome-webidl/MatchPattern.webidl
@@ -0,0 +1,150 @@
+/* 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/. */
+
+interface Cookie;
+interface URI;
+
+/**
+ * A URL match pattern as used by the WebExtension and Chrome extension APIs.
+ *
+ * A match pattern is a string with one of the following formats:
+ *
+ * - "<all_urls>"
+ * The literal string "<all_urls>" matches any URL with a supported
+ * protocol.
+ *
+ * - <proto>://<host>/<path>
+ * A URL pattern with the following placeholders:
+ *
+ * - <proto>
+ * The protocol to match, or "*" to match either "http" or "https".
+ * - <host>
+ * The hostname to match. May be either a complete, literal hostname to
+ * match a specific host, the wildcard character "*", to match any host,
+ * or a subdomain pattern, with "*." followed by a domain name, to match
+ * that domain name or any subdomain thereof.
+ * - <path>
+ * A glob pattern for paths to match. A "*" may appear anywhere within
+ * the path, and will match any string of characters. If no "*" appears,
+ * the URL path must exactly match the pattern path.
+ */
+[ChromeOnly, Exposed=Window]
+interface MatchPattern {
+ [Throws]
+ constructor(DOMString pattern, optional MatchPatternOptions options = {});
+
+ /**
+ * Returns true if the given URI matches the pattern.
+ *
+ * If explicit is true, only explicit domain matches, without wildcards, are
+ * considered.
+ */
+ [Throws]
+ boolean matches(URI uri, optional boolean explicit = false);
+
+ [Throws]
+ boolean matches(DOMString url, optional boolean explicit = false);
+
+ /**
+ * Returns true if a URL exists which a) would be able to access the given
+ * cookie, and b) would be matched by this match pattern.
+ */
+ boolean matchesCookie(Cookie cookie);
+
+ /**
+ * Returns true if this pattern will match any host which would be matched
+ * by the given pattern.
+ */
+ boolean subsumes(MatchPattern pattern);
+
+ /**
+ * Returns true if this pattern will match any host which would be matched
+ * by the given pattern, ignoring the scheme.
+ */
+ boolean subsumesDomain(MatchPattern pattern);
+
+ /**
+ * Returns true if there is any host which would be matched by both this
+ * pattern and the given pattern.
+ */
+ boolean overlaps(MatchPattern pattern);
+
+ /**
+ * The match pattern string represented by this pattern.
+ */
+ [Constant]
+ readonly attribute DOMString pattern;
+};
+
+/**
+ * A set of MatchPattern objects, which implements the MatchPattern API and
+ * matches when any of its sub-patterns matches.
+ */
+[ChromeOnly, Exposed=Window]
+interface MatchPatternSet {
+ [Throws]
+ constructor(sequence<(DOMString or MatchPattern)> patterns, optional MatchPatternOptions options = {});
+
+ /**
+ * Returns true if the given URI matches any sub-pattern.
+ *
+ * If explicit is true, only explicit domain matches, without wildcards, are
+ * considered.
+ */
+ [Throws]
+ boolean matches(URI uri, optional boolean explicit = false);
+
+ [Throws]
+ boolean matches(DOMString url, optional boolean explicit = false);
+
+ /**
+ * Returns true if any sub-pattern matches the given cookie.
+ */
+ boolean matchesCookie(Cookie cookie);
+
+ /**
+ * Returns true if any sub-pattern subsumes the given pattern.
+ */
+ boolean subsumes(MatchPattern pattern);
+
+ /**
+ * Returns true if any sub-pattern subsumes the given pattern,
+ * ignoring any of the schemes in the patterns.
+ */
+ boolean subsumesDomain(MatchPattern pattern);
+
+ /**
+ * Returns true if any sub-pattern overlaps the given pattern.
+ */
+ boolean overlaps(MatchPattern pattern);
+
+ /**
+ * Returns true if any sub-pattern overlaps any sub-pattern the given
+ * pattern set.
+ */
+ boolean overlaps(MatchPatternSet patternSet);
+
+ /**
+ * Returns true if any sub-pattern overlaps *every* sub-pattern in the given
+ * pattern set.
+ */
+ boolean overlapsAll(MatchPatternSet patternSet);
+
+ [Cached, Constant, Frozen]
+ readonly attribute sequence<MatchPattern> patterns;
+};
+
+dictionary MatchPatternOptions {
+ /**
+ * If true, the path portion of the pattern is ignored, and replaced with a
+ * wildcard. The `pattern` property is updated to reflect this.
+ */
+ boolean ignorePath = false;
+
+ /**
+ * If true, the set of schemes this pattern can match is restricted to
+ * those accessible by WebExtensions.
+ */
+ boolean restrictSchemes = true;
+};
diff --git a/dom/chrome-webidl/MediaController.webidl b/dom/chrome-webidl/MediaController.webidl
new file mode 100644
index 0000000000..b16282877a
--- /dev/null
+++ b/dom/chrome-webidl/MediaController.webidl
@@ -0,0 +1,75 @@
+/* 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/.
+ */
+
+/**
+ * This enum lists all supported behaviors on the media controller.
+ */
+enum MediaControlKey {
+ "focus",
+ "play",
+ "pause",
+ "playpause",
+ "previoustrack",
+ "nexttrack",
+ "seekbackward",
+ "seekforward",
+ "skipad",
+ "seekto",
+ "stop",
+};
+
+/**
+ * MediaController is used to control media playback for a tab, and each tab
+ * would only have one media controller, which can be accessed from the
+ * canonical browsing context.
+ */
+[Exposed=Window, ChromeOnly]
+interface MediaController : EventTarget {
+ readonly attribute unsigned long long id;
+ readonly attribute boolean isActive;
+ readonly attribute boolean isAudible;
+ readonly attribute boolean isPlaying;
+ readonly attribute MediaSessionPlaybackState playbackState;
+
+ [Throws]
+ MediaMetadataInit getMetadata();
+
+ [Frozen, Cached, Pure]
+ readonly attribute sequence<MediaControlKey> supportedKeys;
+
+ attribute EventHandler onactivated;
+ attribute EventHandler ondeactivated;
+
+ // Following events would only be dispatched after controller is active.
+ attribute EventHandler onmetadatachange;
+ attribute EventHandler onplaybackstatechange;
+ attribute EventHandler onpositionstatechange;
+ attribute EventHandler onsupportedkeyschange;
+
+ undefined focus();
+ undefined play();
+ undefined pause();
+ undefined stop();
+ undefined prevTrack();
+ undefined nextTrack();
+ undefined seekBackward();
+ undefined seekForward();
+ undefined skipAd();
+ undefined seekTo(double seekTime, optional boolean fastSeek = false);
+};
+
+[ChromeOnly,Exposed=Window,HeaderFile="mozilla/dom/MediaControlService.h"]
+namespace MediaControlService {
+ // This is used to generate fake media control keys event in testing.
+ undefined generateMediaControlKey(MediaControlKey aKey);
+
+ // This is used to get the media metadata from the current main controller in
+ // testing.
+ MediaMetadataInit getCurrentActiveMediaMetadata();
+
+ // This is used to get the actual media playback state from the current main
+ // controller in testing.
+ MediaSessionPlaybackState getCurrentMediaSessionPlaybackState();
+};
diff --git a/dom/chrome-webidl/MessageManager.webidl b/dom/chrome-webidl/MessageManager.webidl
new file mode 100644
index 0000000000..d77f1751ee
--- /dev/null
+++ b/dom/chrome-webidl/MessageManager.webidl
@@ -0,0 +1,576 @@
+/* -*- Mode: IDL; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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/. */
+
+interface nsIEventTarget;
+interface Principal;
+
+/**
+ * Message managers provide a way for chrome-privileged JS code to
+ * communicate with each other, even across process boundaries.
+ *
+ * Message managers are separated into "parent side" and "child side".
+ * These don't always correspond to process boundaries, but can. For
+ * each child-side message manager, there is always exactly one
+ * corresponding parent-side message manager that it sends messages
+ * to. However, for each parent-side message manager, there may be
+ * either one or many child-side managers it can message.
+ *
+ * Message managers that always have exactly one "other side" are of
+ * type MessageSender. Parent-side message managers that have many
+ * "other sides" are of type MessageBroadcaster.
+ *
+ * Child-side message managers can send synchronous messages to their
+ * parent side, but not the other way around.
+ *
+ * There are two realms of message manager hierarchies. One realm
+ * approximately corresponds to DOM elements, the other corresponds to
+ * process boundaries.
+ *
+ * Message managers corresponding to DOM elements
+ * ==============================================
+ *
+ * In this realm of message managers, there are
+ * - "frame message managers" which correspond to frame elements
+ * - "window message managers" which correspond to top-level chrome
+ * windows
+ * - "group message managers" which correspond to named message
+ * managers with a specific window MM as the parent
+ * - the "global message manager", on the parent side. See below.
+ *
+ * The DOM-realm message managers can communicate in the ways shown by
+ * the following diagram. The parent side and child side can
+ * correspond to process boundaries, but don't always.
+ *
+ * Parent side Child side
+ * ------------- ------------
+ * global MMg
+ * |
+ * +-->window MMw1
+ * | |
+ * | +-->frame MMp1_1<------------>frame MMc1_1
+ * | |
+ * | +-->frame MMp1_2<------------>frame MMc1_2
+ * | |
+ * | +-->group MMgr1
+ * | | |
+ * | | +-->frame MMp2_1<------->frame MMc2_1
+ * | | |
+ * | | +-->frame MMp2_2<------->frame MMc2_2
+ * | |
+ * | +-->group MMgr2
+ * | | ...
+ * | |
+ * | ...
+ * |
+ * +-->window MMw2
+ * ...
+ *
+ * For example: a message sent from MMc1_1, from the child side, is
+ * sent only to MMp1_1 on the parent side. However, note that all
+ * message managers in the hierarchy above MMp1_1, in this diagram
+ * MMw1 and MMg, will also notify their message listeners when the
+ * message arrives.
+ *
+ * A message sent from MMc2_1 will be sent to MMp2_1 and also notify
+ * all message managers in the hierarchy above that, including the
+ * group message manager MMgr1.
+
+ * For example: a message broadcast through the global MMg on the
+ * parent side would be broadcast to MMw1, which would transitively
+ * broadcast it to MMp1_1, MM1p_2. The message would next be
+ * broadcast to MMgr1, which would broadcast it to MMp2_1 and MMp2_2.
+ * After that it would broadcast to MMgr2 and then to MMw2, and so
+ * on down the hierarchy.
+ *
+ * ***** PERFORMANCE AND SECURITY WARNING *****
+ * Messages broadcast through the global MM and window or group MMs
+ * can result in messages being dispatched across many OS processes,
+ * and to many processes with different permissions. Great care
+ * should be taken when broadcasting.
+ *
+ * Interfaces
+ * ----------
+ *
+ * The global MMg and window MMw's are message broadcasters implementing
+ * MessageBroadcaster while the frame MMp's are simple message senders (MessageSender).
+ * Their counterparts in the content processes are message senders implementing
+ * ContentFrameMessageManager.
+ *
+ * MessageListenerManager
+ * / \
+ * MessageSender MessageBroadcaster
+ * |
+ * SyncMessageSender (content process/in-process only)
+ * |
+ * ContentFrameMessageManager (content process/in-process only)
+ * |
+ * nsIInProcessContentFrameMessageManager (in-process only)
+ *
+ *
+ * Message managers in the chrome process also implement FrameScriptLoader.
+ *
+ *
+ * Message managers corresponding to process boundaries
+ * ====================================================
+ *
+ * The second realm of message managers is the "process message
+ * managers". With one exception, these always correspond to process
+ * boundaries. The picture looks like
+ *
+ * Parent process Child processes
+ * ---------------- -----------------
+ * global (GPPMM)
+ * |
+ * +-->parent in-process PIPMM<-->child in-process CIPPMM
+ * |
+ * +-->parent (PPMM1)<------------------>child (CPMM1)
+ * |
+ * +-->parent (PPMM2)<------------------>child (CPMM2)
+ * ...
+ *
+ * Note, PIPMM and CIPPMM both run in the parent process.
+ *
+ * For example: the parent-process PPMM1 sends messages to the
+ * child-process CPMM1.
+ *
+ * For example: CPMM1 sends messages directly to PPMM1. The global GPPMM
+ * will also notify their message listeners when the message arrives.
+ *
+ * For example: messages sent through the global GPPMM will be
+ * dispatched to the listeners of the same-process, CIPPMM, CPMM1,
+ * CPMM2, etc.
+ *
+ * ***** PERFORMANCE AND SECURITY WARNING *****
+ * Messages broadcast through the GPPMM can result in messages
+ * being dispatched across many OS processes, and to many processes
+ * with different permissions. Great care should be taken when
+ * broadcasting.
+ *
+ * Requests sent to parent-process message listeners should usually
+ * have replies scoped to the requesting CPMM. The following pattern
+ * is common
+ *
+ * const ParentProcessListener = {
+ * receiveMessage: function(aMessage) {
+ * switch (aMessage.name) {
+ * case "Foo:Request":
+ * // service request
+ * aMessage.target.sendAsyncMessage("Foo:Response", { data });
+ * }
+ * }
+ * };
+ */
+
+dictionary ReceiveMessageArgument
+{
+ /**
+ * The target of the message. Either an element owning the message manager, or message
+ * manager itself if no element owns it.
+ */
+ required nsISupports target;
+
+ /**
+ * Message name.
+ */
+ required DOMString name;
+
+ required boolean sync;
+
+ /**
+ * Structured clone of the sent message data
+ */
+ any data = null;
+
+ /**
+ * Same as .data, deprecated.
+ */
+ any json = null;
+
+ sequence<MessagePort> ports;
+
+ FrameLoader targetFrameLoader;
+};
+
+[Exposed=Window]
+callback interface MessageListener
+{
+ /**
+ * Each listener is invoked with its own copy of the message
+ * parameter.
+ *
+ * When the listener is called, 'this' value is the target of the message.
+ *
+ * If the message is synchronous, the possible return value is
+ * returned as JSON (will be changed to use structured clones).
+ * When there are multiple listeners to sync messages, each
+ * listener's return value is sent back as an array. |undefined|
+ * return values show up as undefined values in the array.
+ */
+ any receiveMessage(ReceiveMessageArgument argument);
+};
+
+[ChromeOnly, Exposed=Window]
+interface MessageListenerManager
+{
+ // All the methods are pulled in via mixin.
+};
+MessageListenerManager includes MessageListenerManagerMixin;
+
+interface mixin MessageListenerManagerMixin
+{
+ /**
+ * Register |listener| to receive |messageName|. All listener
+ * callbacks for a particular message are invoked when that message
+ * is received.
+ *
+ * The message manager holds a strong ref to |listener|.
+ *
+ * If the same listener registers twice for the same message, the
+ * second registration is ignored.
+ *
+ * Pass true for listenWhenClosed if you want to receive messages
+ * during the short period after a frame has been removed from the
+ * DOM and before its frame script has finished unloading. This
+ * parameter only has an effect for frame message managers in
+ * the main process. Default is false.
+ */
+ [Throws]
+ undefined addMessageListener(DOMString messageName,
+ MessageListener listener,
+ optional boolean listenWhenClosed = false);
+
+ /**
+ * Undo an |addMessageListener| call -- that is, calling this causes us to no
+ * longer invoke |listener| when |messageName| is received.
+ *
+ * removeMessageListener does not remove a message listener added via
+ * addWeakMessageListener; use removeWeakMessageListener for that.
+ */
+ [Throws]
+ undefined removeMessageListener(DOMString messageName,
+ MessageListener listener);
+
+ /**
+ * This is just like addMessageListener, except the message manager holds a
+ * weak ref to |listener|.
+ *
+ * If you have two weak message listeners for the same message, they may be
+ * called in any order.
+ */
+ [Throws]
+ undefined addWeakMessageListener(DOMString messageName,
+ MessageListener listener);
+
+ /**
+ * This undoes an |addWeakMessageListener| call.
+ */
+ [Throws]
+ undefined removeWeakMessageListener(DOMString messageName,
+ MessageListener listener);
+};
+
+/**
+ * Message "senders" have a single "other side" to which messages are
+ * sent. For example, a child-process message manager will send
+ * messages that are only delivered to its one parent-process message
+ * manager.
+ */
+[ChromeOnly, Exposed=Window]
+interface MessageSender : MessageListenerManager
+{
+ // All the methods are pulled in via mixin.
+};
+MessageSender includes MessageSenderMixin;
+
+/**
+ * Anyone including this MUST also incude MessageListenerManagerMixin.
+ */
+interface mixin MessageSenderMixin {
+ /**
+ * Send |messageName| and |obj| to the "other side" of this message
+ * manager. This invokes listeners who registered for
+ * |messageName|.
+ *
+ * See ReceiveMessageArgument for the format of the data delivered to listeners.
+ * @throws NS_ERROR_NOT_INITIALIZED if the sender is not initialized. For
+ * example, we will throw NS_ERROR_NOT_INITIALIZED if we try to send
+ * a message to a cross-process frame but the other process has not
+ * yet been set up.
+ * @throws NS_ERROR_FAILURE when the message receiver cannot be found. For
+ * example, we will throw NS_ERROR_FAILURE if we try to send a message
+ * to a cross-process frame whose process has crashed.
+ */
+ [Throws]
+ undefined sendAsyncMessage(optional DOMString? messageName = null,
+ optional any obj,
+ optional any transfers);
+
+ /**
+ * For remote browsers there is always a corresponding process message
+ * manager. The intention of this attribute is to link leaf level frame
+ * message managers on the parent side with the corresponding process
+ * message managers (if there is one). For any other cases this property
+ * is null.
+ */
+ [Throws]
+ readonly attribute MessageSender? processMessageManager;
+
+ /**
+ * For remote browsers, this contains the remoteType of the content child.
+ * Otherwise, it is empty.
+ */
+ [Throws]
+ readonly attribute UTF8String remoteType;
+};
+
+[ChromeOnly, Exposed=Window]
+interface SyncMessageSender : MessageSender
+{
+ // All the methods are pulled in via mixin.
+};
+SyncMessageSender includes SyncMessageSenderMixin;
+
+/**
+ * Anyone including this MUST also incude MessageSenderMixin.
+ */
+interface mixin SyncMessageSenderMixin
+{
+ /**
+ * Like |sendAsyncMessage()|, except blocks the sender until all
+ * listeners of the message have been invoked. Returns an array
+ * containing return values from each listener invoked.
+ */
+ [Throws]
+ sequence<any> sendSyncMessage(optional DOMString? messageName = null,
+ optional any obj);
+};
+
+/**
+ * ChildProcessMessageManager is used in a child process to communicate with the parent
+ * process.
+ */
+[ChromeOnly, Exposed=Window]
+interface ChildProcessMessageManager : SyncMessageSender
+{
+};
+
+/**
+ * Mixin for message manager globals. Anyone including this MUST also
+ * include SyncMessageSenderMixin.
+ */
+interface mixin MessageManagerGlobal
+{
+ /**
+ * Print a string to stdout.
+ */
+ undefined dump(DOMString str);
+
+ /**
+ * Ascii base64 data to binary data and vice versa
+ */
+ [Throws]
+ DOMString atob(DOMString asciiString);
+ [Throws]
+ DOMString btoa(DOMString base64Data);
+};
+
+interface mixin FrameScriptLoader
+{
+ /**
+ * Load a script in the (remote) frame. |url| must be the absolute URL.
+ * data: URLs are also supported. For example data:,dump("foo\n");
+ * If allowDelayedLoad is true, script will be loaded when the
+ * remote frame becomes available. Otherwise the script will be loaded
+ * only if the frame is already available.
+ */
+ [Throws]
+ undefined loadFrameScript(DOMString url, boolean allowDelayedLoad,
+ optional boolean runInGlobalScope = false);
+
+ /**
+ * Removes |url| from the list of scripts which support delayed load.
+ */
+ undefined removeDelayedFrameScript(DOMString url);
+
+ /**
+ * Returns all delayed scripts that will be loaded once a (remote)
+ * frame becomes available. The return value is a list of pairs
+ * [<URL>, <WasLoadedInGlobalScope>].
+ */
+ [Throws]
+ sequence<sequence<any>> getDelayedFrameScripts();
+};
+
+interface mixin ProcessScriptLoader
+{
+ /**
+ * Load a script in the (possibly remote) process. |url| must be the absolute
+ * URL. data: URLs are also supported. For example data:,dump("foo\n");
+ * If allowDelayedLoad is true, script will be loaded when the
+ * remote frame becomes available. Otherwise the script will be loaded
+ * only if the frame is already available.
+ */
+ [Throws]
+ undefined loadProcessScript(DOMString url, boolean allowDelayedLoad);
+
+ /**
+ * Removes |url| from the list of scripts which support delayed load.
+ */
+ undefined removeDelayedProcessScript(DOMString url);
+
+ /**
+ * Returns all delayed scripts that will be loaded once a (remote)
+ * frame becomes available. The return value is a list of pairs
+ * [<URL>, <WasLoadedInGlobalScope>].
+ */
+ [Throws]
+ sequence<sequence<any>> getDelayedProcessScripts();
+};
+
+/**
+ * Anyone including GlobalProcessScriptLoader MUST also include ProcessScriptLoader.
+ */
+interface mixin GlobalProcessScriptLoader
+{
+ /**
+ * Allows the parent process to set the initial process data for
+ * new, not-yet-created child processes. This attribute should only
+ * be used by the global parent process message manager. When a new
+ * process is created, it gets a copy of this data (via structured
+ * cloning). It can access the data via the initialProcessData
+ * attribute of its childprocessmessagemanager.
+ *
+ * This value will always be a JS object if it's not null or undefined. Different
+ * users are expected to set properties on this object. The property name should be
+ * unique enough that other Gecko consumers won't accidentally choose it.
+ */
+ [Throws]
+ readonly attribute any initialProcessData;
+
+ readonly attribute MozWritableSharedMap sharedData;
+};
+
+[ChromeOnly, Exposed=Window]
+interface ContentFrameMessageManager : EventTarget
+{
+ /**
+ * The current top level window in the frame or null.
+ */
+ [Throws]
+ readonly attribute WindowProxy? content;
+
+ /**
+ * The top level docshell or null.
+ */
+ [Throws]
+ readonly attribute nsIDocShell? docShell;
+
+ /**
+ * Returns the SchedulerEventTarget corresponding to the TabGroup
+ * for this frame.
+ */
+ readonly attribute nsIEventTarget? tabEventTarget;
+
+};
+ContentFrameMessageManager includes MessageManagerGlobal;
+ContentFrameMessageManager includes SyncMessageSenderMixin;
+ContentFrameMessageManager includes MessageSenderMixin;
+ContentFrameMessageManager includes MessageListenerManagerMixin;
+
+[ChromeOnly, Exposed=Window]
+interface ContentProcessMessageManager
+{
+ /**
+ * Read out a copy of the object that was initialized in the parent
+ * process via ProcessScriptLoader.initialProcessData.
+ */
+ [Throws]
+ readonly attribute any initialProcessData;
+
+ readonly attribute MozSharedMap? sharedData;
+};
+ContentProcessMessageManager includes MessageManagerGlobal;
+ContentProcessMessageManager includes SyncMessageSenderMixin;
+ContentProcessMessageManager includes MessageSenderMixin;
+ContentProcessMessageManager includes MessageListenerManagerMixin;
+
+/**
+ * Message "broadcasters" don't have a single "other side" that they send messages to, but
+ * rather a set of subordinate message managers. For example, broadcasting a message
+ * through a window message manager will broadcast the message to all frame message
+ * managers within its window.
+ */
+[ChromeOnly, Exposed=Window]
+interface MessageBroadcaster : MessageListenerManager
+{
+ /**
+ * Like |sendAsyncMessage()|, but also broadcasts this message to
+ * all "child" message managers of this message manager. See long
+ * comment above for details.
+ *
+ * WARNING: broadcasting messages can be very expensive and leak
+ * sensitive data. Use with extreme caution.
+ */
+ [Throws]
+ undefined broadcastAsyncMessage(optional DOMString? messageName = null,
+ optional any obj);
+
+ /**
+ * Number of subordinate message managers.
+ */
+ readonly attribute unsigned long childCount;
+
+ /**
+ * Return a single subordinate message manager.
+ */
+ MessageListenerManager? getChildAt(unsigned long aIndex);
+
+ /**
+ * Some processes are kept alive after their last tab/window are closed for testing
+ * (see dom.ipc.keepProcessesAlive). This function releases those.
+ */
+ undefined releaseCachedProcesses();
+};
+
+/**
+ * ChromeMessageBroadcaster is used for window and group message managers.
+ */
+[ChromeOnly, Exposed=Window]
+interface ChromeMessageBroadcaster : MessageBroadcaster
+{
+};
+ChromeMessageBroadcaster includes FrameScriptLoader;
+
+/**
+ * ParentProcessMessageManager is used in a parent process to communicate with all the
+ * child processes.
+ */
+[ChromeOnly, Exposed=Window]
+interface ParentProcessMessageManager : MessageBroadcaster
+{
+};
+ParentProcessMessageManager includes ProcessScriptLoader;
+ParentProcessMessageManager includes GlobalProcessScriptLoader;
+
+[ChromeOnly, Exposed=Window]
+interface ChromeMessageSender : MessageSender
+{
+};
+ChromeMessageSender includes FrameScriptLoader;
+
+/**
+ * ProcessMessageManager is used in a parent process to communicate with a child process
+ * (or with the process itself in a single-process scenario).
+ */
+[ChromeOnly, Exposed=Window]
+interface ProcessMessageManager : MessageSender
+{
+ // PID of the process being communicated with.
+ readonly attribute long osPid;
+
+ // Whether this is message manager for the current process.
+ readonly attribute boolean isInProcess;
+};
+ProcessMessageManager includes ProcessScriptLoader;
diff --git a/dom/chrome-webidl/MozDocumentObserver.webidl b/dom/chrome-webidl/MozDocumentObserver.webidl
new file mode 100644
index 0000000000..06abd37eeb
--- /dev/null
+++ b/dom/chrome-webidl/MozDocumentObserver.webidl
@@ -0,0 +1,20 @@
+/* -*- Mode: IDL; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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/.
+ */
+
+[Exposed=Window]
+callback interface MozDocumentCallback {
+ undefined onNewDocument(MozDocumentMatcher matcher, WindowProxy window);
+ undefined onPreloadDocument(MozDocumentMatcher matcher, LoadInfo loadInfo);
+};
+
+[ChromeOnly, Exposed=Window]
+interface MozDocumentObserver {
+ constructor(MozDocumentCallback callbacks);
+
+ [Throws]
+ undefined observe(sequence<MozDocumentMatcher> matchers);
+ undefined disconnect();
+};
diff --git a/dom/chrome-webidl/MozSharedMap.webidl b/dom/chrome-webidl/MozSharedMap.webidl
new file mode 100644
index 0000000000..ef262fc48e
--- /dev/null
+++ b/dom/chrome-webidl/MozSharedMap.webidl
@@ -0,0 +1,54 @@
+/* -*- Mode: IDL; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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/.
+ */
+
+typedef any StructuredClonable;
+
+[ChromeOnly, Exposed=Window]
+interface MozSharedMapChangeEvent : Event {
+ [Cached, Constant]
+ readonly attribute sequence<DOMString> changedKeys;
+};
+
+dictionary MozSharedMapChangeEventInit : EventInit {
+ required sequence<DOMString> changedKeys;
+};
+
+[ChromeOnly, Exposed=Window]
+interface MozSharedMap : EventTarget {
+ boolean has(DOMString name);
+
+ [Throws]
+ StructuredClonable get(DOMString name);
+
+ iterable<DOMString, StructuredClonable>;
+};
+
+[ChromeOnly, Exposed=Window]
+interface MozWritableSharedMap : MozSharedMap {
+ /**
+ * Sets the given key to the given structured-clonable value. The value is
+ * synchronously structured cloned, and the serialized value is saved in the
+ * map.
+ *
+ * Unless flush() is called, the new value will be broadcast to content
+ * processes after a short delay.
+ */
+ [Throws]
+ undefined set(DOMString name, StructuredClonable value);
+
+ /**
+ * Removes the given key from the map.
+ *
+ * Unless flush() is called, the removal will be broadcast to content
+ * processes after a short delay.
+ */
+ undefined delete(DOMString name);
+
+ /**
+ * Broadcasts any pending changes to all content processes.
+ */
+ undefined flush();
+};
diff --git a/dom/chrome-webidl/MozStorageAsyncStatementParams.webidl b/dom/chrome-webidl/MozStorageAsyncStatementParams.webidl
new file mode 100644
index 0000000000..853d86581a
--- /dev/null
+++ b/dom/chrome-webidl/MozStorageAsyncStatementParams.webidl
@@ -0,0 +1,22 @@
+/* -*- Mode: IDL; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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/. */
+
+[ChromeOnly, Exposed=Window]
+interface MozStorageAsyncStatementParams
+{
+ readonly attribute unsigned long length;
+
+ [Throws]
+ getter any(unsigned long index);
+
+ [Throws]
+ getter any(DOMString name);
+
+ [Throws]
+ setter undefined(unsigned long index, any arg);
+
+ [Throws]
+ setter undefined(DOMString name, any arg);
+};
diff --git a/dom/chrome-webidl/MozStorageStatementParams.webidl b/dom/chrome-webidl/MozStorageStatementParams.webidl
new file mode 100644
index 0000000000..1c4eb4cbf7
--- /dev/null
+++ b/dom/chrome-webidl/MozStorageStatementParams.webidl
@@ -0,0 +1,22 @@
+/* -*- Mode: IDL; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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/. */
+
+[ChromeOnly, Exposed=Window]
+interface MozStorageStatementParams
+{
+ readonly attribute unsigned long length;
+
+ [Throws]
+ getter any(unsigned long index);
+
+ [Throws]
+ getter any(DOMString name);
+
+ [Throws]
+ setter undefined(unsigned long index, any arg);
+
+ [Throws]
+ setter undefined(DOMString name, any arg);
+};
diff --git a/dom/chrome-webidl/MozStorageStatementRow.webidl b/dom/chrome-webidl/MozStorageStatementRow.webidl
new file mode 100644
index 0000000000..2ba31f5810
--- /dev/null
+++ b/dom/chrome-webidl/MozStorageStatementRow.webidl
@@ -0,0 +1,11 @@
+/* -*- Mode: IDL; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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/. */
+
+[ChromeOnly, Exposed=Window]
+interface MozStorageStatementRow
+{
+ [Throws]
+ getter any(DOMString name);
+};
diff --git a/dom/chrome-webidl/NetDashboard.webidl b/dom/chrome-webidl/NetDashboard.webidl
new file mode 100644
index 0000000000..937ffc11d8
--- /dev/null
+++ b/dom/chrome-webidl/NetDashboard.webidl
@@ -0,0 +1,155 @@
+/* -*- Mode: IDL; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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/. */
+
+// This file defines dictionaries used by about:networking page.
+
+dictionary SocketElement {
+ DOMString host = "";
+ unsigned long port = 0;
+ boolean active = false;
+ DOMString type = "";
+ double sent = 0;
+ double received = 0;
+};
+
+[GenerateConversionToJS]
+dictionary SocketsDict {
+ sequence<SocketElement> sockets;
+ double sent = 0;
+ double received = 0;
+};
+
+dictionary HttpConnInfo {
+ unsigned long rtt = 0;
+ unsigned long ttl = 0;
+ DOMString protocolVersion = "";
+};
+
+dictionary DnsAndSockInfoDict {
+ boolean speculative = false;
+};
+
+dictionary HttpConnectionElement {
+ DOMString host = "";
+ unsigned long port = 0;
+ DOMString httpVersion = "";
+ boolean ssl = false;
+ sequence<HttpConnInfo> active;
+ sequence<HttpConnInfo> idle;
+ sequence<DnsAndSockInfoDict> dnsAndSocks;
+};
+
+[GenerateConversionToJS]
+dictionary HttpConnDict {
+ sequence<HttpConnectionElement> connections;
+};
+
+dictionary WebSocketElement {
+ DOMString hostport = "";
+ unsigned long msgsent = 0;
+ unsigned long msgreceived = 0;
+ double sentsize = 0;
+ double receivedsize = 0;
+ boolean encrypted = false;
+};
+
+[GenerateConversionToJS]
+dictionary WebSocketDict {
+ sequence<WebSocketElement> websockets;
+};
+
+dictionary DnsCacheEntry {
+ DOMString hostname = "";
+ sequence<DOMString> hostaddr;
+ DOMString family = "";
+ double expiration = 0;
+ boolean trr = false;
+ DOMString originAttributesSuffix = "";
+ DOMString flags = "";
+};
+
+[GenerateConversionToJS]
+dictionary DNSCacheDict {
+ sequence<DnsCacheEntry> entries;
+};
+
+[GenerateConversionToJS]
+dictionary DNSLookupDict {
+ sequence<DOMString> address;
+ DOMString error = "";
+ boolean answer = false;
+};
+
+dictionary SVCParam {
+ unsigned short type = 0;
+};
+
+dictionary SVCParamAlpn : SVCParam {
+ DOMString alpn = "";
+};
+
+dictionary SVCParamNoDefaultAlpn : SVCParam {
+};
+
+dictionary SVCParamPort : SVCParam {
+ unsigned short port = 0;
+};
+
+dictionary SVCParamIPv4Hint : SVCParam {
+ sequence<DOMString> address;
+};
+
+dictionary SVCParamIPv6Hint : SVCParam {
+ sequence<DOMString> address;
+};
+
+dictionary SVCParamEchConfig : SVCParam {
+ DOMString echConfig = "";
+};
+
+dictionary SVCParamODoHConfig : SVCParam {
+ DOMString ODoHConfig = "";
+};
+
+dictionary HTTPSRecord {
+ unsigned short priority = 0;
+ DOMString targetName = "";
+ SVCParamAlpn alpn;
+ SVCParamNoDefaultAlpn noDefaultAlpn;
+ SVCParamPort port;
+ SVCParamIPv4Hint ipv4Hint;
+ SVCParamIPv6Hint ipv6Hint;
+ SVCParamEchConfig echConfig;
+ SVCParamODoHConfig ODoHConfig;
+};
+
+[GenerateConversionToJS]
+dictionary HTTPSRRLookupDict {
+ DOMString error = "";
+ boolean answer = false;
+ sequence<HTTPSRecord> records;
+};
+
+[GenerateConversionToJS]
+dictionary ConnStatusDict {
+ DOMString status = "";
+};
+
+dictionary RcwnPerfStats {
+ unsigned long avgShort = 0;
+ unsigned long avgLong = 0;
+ unsigned long stddevLong = 0;
+};
+
+[GenerateConversionToJS]
+dictionary RcwnStatus {
+ unsigned long totalNetworkRequests = 0;
+ unsigned long rcwnCacheWonCount = 0;
+ unsigned long rcwnNetWonCount = 0;
+ unsigned long cacheSlowCount = 0;
+ unsigned long cacheNotSlowCount = 0;
+ // Sequence is indexed by CachePerfStats::EDataType
+ sequence<RcwnPerfStats> perfStats;
+};
diff --git a/dom/chrome-webidl/PathUtils.webidl b/dom/chrome-webidl/PathUtils.webidl
new file mode 100644
index 0000000000..eb51a79819
--- /dev/null
+++ b/dom/chrome-webidl/PathUtils.webidl
@@ -0,0 +1,175 @@
+/* -*- Mode: IDL; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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/.
+ */
+
+/**
+ * PathUtils is a set of utilities for operating on absolute paths.
+ */
+[ChromeOnly, Exposed=(Window, Worker)]
+namespace PathUtils {
+ /**
+ * Return the last path component.
+ *
+ * @param path An absolute path.
+ *
+ * @returns The last path component.
+ */
+ [Throws]
+ DOMString filename(DOMString path);
+
+ /**
+ * Return an ancestor directory of the given path.
+ *
+ * @param path An absolute path.
+ * @param depth The number of ancestors to remove, defaulting to 1 (i.e., the
+ * parent).
+ *
+ * @return The ancestor directory.
+ *
+ * If the path provided is a root path (e.g., `C:` on Windows or `/`
+ * on *NIX), then null is returned.
+ */
+ [Throws]
+ DOMString? parent(DOMString path, optional long depth = 1);
+
+ /**
+ * Join the given components into a full path.
+ *
+ * @param components The path components. The first component must be an
+ * absolute path. There must be at least one component.
+ */
+ [Throws]
+ DOMString join(DOMString... components);
+
+ /**
+ * Join the given relative path to the base path.
+ *
+ * @param base The base path. This must be an absolute path.
+ * @param relativePath A relative path to join to the base path.
+ */
+ [Throws]
+ DOMString joinRelative(DOMString base, DOMString relativePath);
+
+ /**
+ * Creates an adjusted path using a path whose length is already close
+ * to MAX_PATH. For windows only.
+ *
+ * @param path An absolute path.
+ */
+ [Throws]
+ DOMString toExtendedWindowsPath(DOMString path);
+
+ /**
+ * Normalize a path by removing multiple separators and `..` and `.`
+ * directories.
+ *
+ * On UNIX platforms, the path must exist as symbolic links will be resolved.
+ *
+ * @param path The absolute path to normalize.
+ *
+ */
+ [Throws]
+ DOMString normalize(DOMString path);
+
+ /**
+ * Split a path into its components.
+ *
+ * @param path An absolute path.
+ */
+ [Throws]
+ sequence<DOMString> split(DOMString path);
+
+ /**
+ * Split a relative path into its components.
+ *
+ * @param path A relative path.
+ */
+ [Throws]
+ sequence<DOMString> splitRelative(DOMString path, optional SplitRelativeOptions options = {});
+
+ /**
+ * Transform a file path into a file: URI
+ *
+ * @param path An absolute path.
+ *
+ * @return The file: URI as a string.
+ */
+ [Throws]
+ UTF8String toFileURI(DOMString path);
+
+ /**
+ * Determine if the given path is an absolute or relative path.
+ *
+ * @param path A file path that is either relative or absolute.
+ *
+ * @return Whether or not the path is absolute.
+ */
+ boolean isAbsolute(DOMString path);
+};
+
+[Exposed=Window]
+partial namespace PathUtils {
+ /**
+ * The profile directory.
+ */
+ [Throws, BinaryName="ProfileDirSync"]
+ readonly attribute DOMString profileDir;
+
+ /**
+ * The local-specific profile directory.
+ */
+ [Throws, BinaryName="LocalProfileDirSync"]
+ readonly attribute DOMString localProfileDir;
+
+ /**
+ * The OS temporary directory.
+ */
+ [Throws, BinaryName="TempDirSync"]
+ readonly attribute DOMString tempDir;
+
+ /**
+ * The libxul path.
+ */
+ [Throws, BinaryName="XulLibraryPathSync"]
+ readonly attribute DOMString xulLibraryPath;
+};
+
+[Exposed=Worker]
+partial namespace PathUtils {
+ /**
+ * The profile directory.
+ */
+ [NewObject, BinaryName="GetProfileDirAsync"]
+ Promise<DOMString> getProfileDir();
+
+ /**
+ * The local-specific profile directory.
+ */
+ [NewObject, BinaryName="GetLocalProfileDirAsync"]
+ Promise<DOMString> getLocalProfileDir();
+
+ /**
+ * The OS temporary directory.
+ */
+ [NewObject, BinaryName="GetTempDirAsync"]
+ Promise<DOMString> getTempDir();
+
+ /**
+ * The libxul path.
+ */
+ [NewObject, BinaryName="GetXulLibraryPathAsync"]
+ Promise<DOMString> getXulLibraryPath();
+};
+
+dictionary SplitRelativeOptions {
+ /** Allow for a path that contains empty components. */
+ boolean allowEmpty = false;
+
+ /** Allow for a path that contains ".." components. */
+ boolean allowParentDir = false;
+
+ /** Allow for a path that contains "." components. */
+ boolean allowCurrentDir = false;
+};
diff --git a/dom/chrome-webidl/PlacesEvent.webidl b/dom/chrome-webidl/PlacesEvent.webidl
new file mode 100644
index 0000000000..6507931890
--- /dev/null
+++ b/dom/chrome-webidl/PlacesEvent.webidl
@@ -0,0 +1,547 @@
+enum PlacesEventType {
+ "none",
+
+ /**
+ * data: PlacesVisit. Fired whenever a page is visited.
+ */
+ "page-visited",
+ /**
+ * data: PlacesBookmarkAddition. Fired whenever a bookmark
+ * (or a bookmark folder/separator) is created.
+ */
+ "bookmark-added",
+ /**
+ * data: PlacesBookmarkRemoved. Fired whenever a bookmark
+ * (or a bookmark folder/separator) is removed.
+ */
+ "bookmark-removed",
+ /**
+ * data: PlacesBookmarkMoved. Fired whenever a bookmark
+ * (or a bookmark folder/separator) is moved.
+ */
+ "bookmark-moved",
+ /**
+ * data: PlacesBookmarkGuid. Fired whenever a bookmark guid changes.
+ */
+ "bookmark-guid-changed",
+ /**
+ * data: PlacesBookmarkKeyword. Fired whenever a bookmark keyword changes.
+ */
+ "bookmark-keyword-changed",
+ /**
+ * data: PlacesBookmarkTags. Fired whenever tags of bookmark changes.
+ */
+ "bookmark-tags-changed",
+ /**
+ * data: PlacesBookmarkTime.
+ * Fired whenever dateAdded or lastModified of a bookmark is explicitly changed
+ * through the Bookmarks API. This notification doesn't fire when a bookmark is
+ * created, or when a property of a bookmark (e.g. title) is changed, even if
+ * lastModified will be updated as a consequence of that change.
+ */
+ "bookmark-time-changed",
+ /**
+ * data: PlacesBookmarkTitle. Fired whenever a bookmark title changes.
+ */
+ "bookmark-title-changed",
+ /**
+ * data: PlacesBookmarkUrl. Fired whenever a bookmark url changes.
+ */
+ "bookmark-url-changed",
+ /**
+ * data: PlacesFavicon. Fired whenever a favicon changes.
+ */
+ "favicon-changed",
+ /**
+ * data: PlacesVisitTitle. Fired whenever a page title changes.
+ */
+ "page-title-changed",
+ /**
+ * data: PlacesHistoryCleared. Fired whenever history is cleared.
+ */
+ "history-cleared",
+ /**
+ * data: PlacesRanking. Fired whenever pages ranking is changed.
+ */
+ "pages-rank-changed",
+ /**
+ * data: PlacesVisitRemoved. Fired whenever a page or its visits are removed.
+ * This may be invoked when a page is removed from the store because it has no more
+ * visits, nor bookmarks. It may also be invoked when all or some of the page visits are
+ * removed, but the page itself is not removed from the store, because it may be
+ * bookmarked.
+ */
+ "page-removed",
+ /**
+ * data: PlacesPurgeCaches. Fired whenever changes happened that could not be observed
+ * through other notifications, for example a database fixup. When received, observers,
+ * especially data views, should drop any caches and reload from scratch.
+ */
+ "purge-caches",
+};
+
+[ChromeOnly, Exposed=Window]
+interface PlacesEvent {
+ readonly attribute PlacesEventType type;
+};
+
+[ChromeOnly, Exposed=Window]
+interface PlacesVisit : PlacesEvent {
+ /**
+ * URL of the visit.
+ */
+ readonly attribute DOMString url;
+
+ /**
+ * Id of the visit.
+ */
+ readonly attribute unsigned long long visitId;
+
+ /**
+ * Time of the visit, in milliseconds since epoch.
+ */
+ readonly attribute unsigned long long visitTime;
+
+ /**
+ * The id of the visit the user came from, defaults to 0 for no referrer.
+ */
+ readonly attribute unsigned long long referringVisitId;
+
+ /**
+ * One of nsINavHistory.TRANSITION_*
+ */
+ readonly attribute unsigned long transitionType;
+
+ /**
+ * The unique id associated with the page.
+ */
+ readonly attribute ByteString pageGuid;
+
+ /**
+ * Whether the visited page is marked as hidden.
+ */
+ readonly attribute boolean hidden;
+
+ /**
+ * Number of visits (including this one) for this URL.
+ */
+ readonly attribute unsigned long visitCount;
+
+ /**
+ * Whether the URL has been typed or not.
+ * TODO (Bug 1271801): This will become a count, rather than a boolean.
+ * For future compatibility, always compare it with "> 0".
+ */
+ readonly attribute unsigned long typedCount;
+
+ /**
+ * The last known title of the page. Might not be from the current visit,
+ * and might be null if it is not known.
+ */
+ readonly attribute DOMString? lastKnownTitle;
+};
+
+/**
+ * Base class for properties that are common to all bookmark events.
+ */
+[ChromeOnly, Exposed=Window]
+interface PlacesBookmark : PlacesEvent {
+ /**
+ * The id of the item.
+ */
+ readonly attribute long long id;
+
+ /**
+ * The id of the folder to which the item belongs.
+ */
+ readonly attribute long long parentId;
+
+ /**
+ * The type of the added item (see TYPE_* constants in nsINavBooksService.idl).
+ */
+ readonly attribute unsigned short itemType;
+
+ /**
+ * The URI of the added item if it was TYPE_BOOKMARK, "" otherwise.
+ */
+ readonly attribute DOMString url;
+
+ /**
+ * The unique ID associated with the item.
+ */
+ readonly attribute ByteString guid;
+
+ /**
+ * The unique ID associated with the item's parent.
+ */
+ readonly attribute ByteString parentGuid;
+
+ /**
+ * A change source constant from nsINavBookmarksService::SOURCE_*,
+ * passed to the method that notifies the observer.
+ */
+ readonly attribute unsigned short source;
+
+ /**
+ * True if the item is a tag or a tag folder.
+ * NOTE: this will go away with bug 424160.
+ */
+ readonly attribute boolean isTagging;
+};
+
+dictionary PlacesBookmarkAdditionInit {
+ required long long id;
+ required long long parentId;
+ required unsigned short itemType;
+ required DOMString url;
+ required ByteString guid;
+ required ByteString parentGuid;
+ required unsigned short source;
+ required long index;
+ required DOMString title;
+ required unsigned long long dateAdded;
+ required boolean isTagging;
+};
+
+[ChromeOnly, Exposed=Window]
+interface PlacesBookmarkAddition : PlacesBookmark {
+ constructor(PlacesBookmarkAdditionInit initDict);
+
+ /**
+ * The item's index in the folder.
+ */
+ readonly attribute long index;
+
+ /**
+ * The title of the added item.
+ */
+ readonly attribute DOMString title;
+
+ /**
+ * The time that the item was added, in milliseconds from the epoch.
+ */
+ readonly attribute unsigned long long dateAdded;
+};
+
+dictionary PlacesBookmarkRemovedInit {
+ required long long id;
+ required long long parentId;
+ required unsigned short itemType;
+ required DOMString url;
+ required DOMString title;
+ required ByteString guid;
+ required ByteString parentGuid;
+ required unsigned short source;
+ required long index;
+ required boolean isTagging;
+ boolean isDescendantRemoval = false;
+};
+
+[ChromeOnly, Exposed=Window]
+interface PlacesBookmarkRemoved : PlacesBookmark {
+ constructor(PlacesBookmarkRemovedInit initDict);
+ /**
+ * The item's index in the folder.
+ */
+ readonly attribute long index;
+
+ /**
+ * The title of the the removed item.
+ */
+ readonly attribute DOMString title;
+
+ /**
+ * The item is a descendant of an item whose notification has been sent out.
+ */
+ readonly attribute boolean isDescendantRemoval;
+};
+
+dictionary PlacesBookmarkMovedInit {
+ required long long id;
+ required unsigned short itemType;
+ DOMString? url = null;
+ required ByteString guid;
+ required ByteString parentGuid;
+ required long index;
+ required ByteString oldParentGuid;
+ required long oldIndex;
+ required unsigned short source;
+ required boolean isTagging;
+};
+
+[ChromeOnly, Exposed=Window]
+/**
+ * NOTE: Though PlacesBookmarkMoved extends PlacesBookmark,
+ * parentId will not be set. Use parentGuid instead.
+ */
+interface PlacesBookmarkMoved : PlacesBookmark {
+ constructor(PlacesBookmarkMovedInit initDict);
+ /**
+ * The item's index in the folder.
+ */
+ readonly attribute long index;
+
+ /**
+ * The unique ID associated with the item's old parent.
+ */
+ readonly attribute ByteString oldParentGuid;
+
+ /**
+ * The item's old index in the folder.
+ */
+ readonly attribute long oldIndex;
+};
+
+[ChromeOnly, Exposed=Window]
+interface PlacesBookmarkChanged : PlacesBookmark {
+ /**
+ * The updated last modified value in milliseconds.
+ */
+ readonly attribute long long lastModified;
+};
+
+dictionary PlacesBookmarkGuidInit {
+ required long long id;
+ required unsigned short itemType;
+ DOMString? url = null;
+ required ByteString guid;
+ required ByteString parentGuid;
+ required long long lastModified;
+ required unsigned short source;
+ required boolean isTagging;
+};
+
+[ChromeOnly, Exposed=Window]
+interface PlacesBookmarkGuid : PlacesBookmarkChanged {
+ constructor(PlacesBookmarkGuidInit initDict);
+};
+
+dictionary PlacesBookmarkKeywordInit {
+ required long long id;
+ required unsigned short itemType;
+ DOMString? url = null;
+ required ByteString guid;
+ required ByteString parentGuid;
+ required ByteString keyword;
+ required long long lastModified;
+ required unsigned short source;
+ required boolean isTagging;
+};
+
+[ChromeOnly, Exposed=Window]
+interface PlacesBookmarkKeyword : PlacesBookmarkChanged {
+ constructor(PlacesBookmarkKeywordInit initDict);
+
+ /**
+ * Keyword the bookmark has currently.
+ */
+ [Constant,Cached]
+ readonly attribute ByteString keyword;
+};
+
+dictionary PlacesBookmarkTagsInit {
+ required long long id;
+ required unsigned short itemType;
+ DOMString? url = null;
+ required ByteString guid;
+ required ByteString parentGuid;
+ required sequence<DOMString> tags;
+ required long long lastModified;
+ required unsigned short source;
+ required boolean isTagging;
+};
+
+[ChromeOnly, Exposed=Window]
+interface PlacesBookmarkTags : PlacesBookmarkChanged {
+ constructor(PlacesBookmarkTagsInit initDict);
+
+ /**
+ * Tags the bookmark has currently.
+ */
+ [Constant,Cached]
+ readonly attribute sequence<DOMString> tags;
+};
+
+dictionary PlacesBookmarkTimeInit {
+ required long long id;
+ required unsigned short itemType;
+ DOMString? url = null;
+ required ByteString guid;
+ required ByteString parentGuid;
+ required long long dateAdded;
+ required long long lastModified;
+ required unsigned short source;
+ required boolean isTagging;
+};
+
+[ChromeOnly, Exposed=Window]
+interface PlacesBookmarkTime : PlacesBookmarkChanged {
+ constructor(PlacesBookmarkTimeInit initDict);
+
+ /**
+ * The added date in milliseconds.
+ */
+ readonly attribute long long dateAdded;
+};
+
+dictionary PlacesBookmarkTitleInit {
+ required long long id;
+ required unsigned short itemType;
+ DOMString? url = null;
+ required ByteString guid;
+ required ByteString parentGuid;
+ required DOMString title;
+ required long long lastModified;
+ required unsigned short source;
+ required boolean isTagging;
+};
+
+[ChromeOnly, Exposed=Window]
+interface PlacesBookmarkTitle : PlacesBookmarkChanged {
+ constructor(PlacesBookmarkTitleInit initDict);
+
+ /**
+ * The title of the changed bookmark.
+ */
+ readonly attribute DOMString title;
+};
+
+dictionary PlacesBookmarkUrlInit {
+ required long long id;
+ required unsigned short itemType;
+ required DOMString url;
+ required ByteString guid;
+ required ByteString parentGuid;
+ required long long lastModified;
+ required unsigned short source;
+ required boolean isTagging;
+};
+
+[ChromeOnly, Exposed=Window]
+interface PlacesBookmarkUrl : PlacesBookmarkChanged {
+ constructor(PlacesBookmarkUrlInit initDict);
+};
+
+dictionary PlacesFaviconInit {
+ required DOMString url;
+ required ByteString pageGuid;
+ required DOMString faviconUrl;
+};
+
+[ChromeOnly, Exposed=Window]
+interface PlacesFavicon : PlacesEvent {
+ constructor(PlacesFaviconInit initDict);
+
+ /**
+ * The URI of the changed page.
+ */
+ readonly attribute DOMString url;
+
+ /**
+ * The unique id associated with the page.
+ */
+ readonly attribute ByteString pageGuid;
+
+ /**
+ * The URI of the new favicon.
+ */
+ readonly attribute DOMString faviconUrl;
+};
+
+dictionary PlacesVisitTitleInit {
+ required DOMString url;
+ required ByteString pageGuid;
+ required DOMString title;
+};
+
+[ChromeOnly, Exposed=Window]
+interface PlacesVisitTitle : PlacesEvent {
+ constructor(PlacesVisitTitleInit initDict);
+
+ /**
+ * The URI of the changed page.
+ */
+ readonly attribute DOMString url;
+
+ /**
+ * The unique id associated with the page.
+ */
+ readonly attribute ByteString pageGuid;
+
+ /**
+ * The title of the changed page.
+ */
+ readonly attribute DOMString title;
+};
+
+[ChromeOnly, Exposed=Window]
+interface PlacesHistoryCleared : PlacesEvent {
+ constructor();
+};
+
+[ChromeOnly, Exposed=Window]
+interface PlacesRanking : PlacesEvent {
+ constructor();
+};
+
+dictionary PlacesVisitRemovedInit {
+ required DOMString url;
+ required ByteString pageGuid;
+ required unsigned short reason;
+ unsigned long transitionType = 0;
+ boolean isRemovedFromStore = false;
+ boolean isPartialVisistsRemoval = false;
+};
+
+[ChromeOnly, Exposed=Window]
+interface PlacesVisitRemoved : PlacesEvent {
+ /**
+ * Removed by the user.
+ */
+ const unsigned short REASON_DELETED = 0;
+
+ /**
+ * Removed by periodic expiration.
+ */
+ const unsigned short REASON_EXPIRED = 1;
+
+ constructor(PlacesVisitRemovedInit initDict);
+
+ /**
+ * The URI of the page.
+ */
+ readonly attribute DOMString url;
+
+ /**
+ * The unique id associated with the page.
+ */
+ readonly attribute ByteString pageGuid;
+
+ /**
+ * The reason of removal.
+ */
+ readonly attribute unsigned short reason;
+
+ /**
+ * One of nsINavHistoryService.TRANSITION_*
+ * NOTE: Please refer this attribute only when isRemovedFromStore is false.
+ * Otherwise this will be 0.
+ */
+ readonly attribute unsigned long transitionType;
+
+ /**
+ * This will be true if the page is removed from store.
+ * If false, only visits were removed, but not the page.
+ */
+ readonly attribute boolean isRemovedFromStore;
+
+ /**
+ * This will be true if remains at least one visit to the page.
+ */
+ readonly attribute boolean isPartialVisistsRemoval;
+};
+
+[ChromeOnly, Exposed=Window]
+interface PlacesPurgeCaches : PlacesEvent {
+ constructor();
+};
diff --git a/dom/chrome-webidl/PlacesObservers.webidl b/dom/chrome-webidl/PlacesObservers.webidl
new file mode 100644
index 0000000000..662d8558ff
--- /dev/null
+++ b/dom/chrome-webidl/PlacesObservers.webidl
@@ -0,0 +1,31 @@
+/* -*- Mode: IDL; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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/.
+ */
+
+callback PlacesEventCallback = undefined (sequence<PlacesEvent> events);
+
+[ChromeOnly, Exposed=Window]
+interface PlacesWeakCallbackWrapper {
+ constructor(PlacesEventCallback callback);
+};
+
+// Global singleton which should handle all events for places.
+[ChromeOnly, Exposed=Window]
+namespace PlacesObservers {
+ [Throws]
+ undefined addListener(sequence<PlacesEventType> eventTypes,
+ PlacesEventCallback listener);
+ [Throws]
+ undefined addListener(sequence<PlacesEventType> eventTypes,
+ PlacesWeakCallbackWrapper listener);
+ [Throws]
+ undefined removeListener(sequence<PlacesEventType> eventTypes,
+ PlacesEventCallback listener);
+ [Throws]
+ undefined removeListener(sequence<PlacesEventType> eventTypes,
+ PlacesWeakCallbackWrapper listener);
+ [Throws]
+ undefined notifyListeners(sequence<PlacesEvent> events);
+};
diff --git a/dom/chrome-webidl/PrecompiledScript.webidl b/dom/chrome-webidl/PrecompiledScript.webidl
new file mode 100644
index 0000000000..4a71f67fc8
--- /dev/null
+++ b/dom/chrome-webidl/PrecompiledScript.webidl
@@ -0,0 +1,43 @@
+/* -*- Mode: IDL; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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/.
+ */
+
+dictionary ExecuteInGlobalOptions {
+ /**
+ * If `reportExceptions` is set to true and any exception happens
+ * while executing the script, the exceptions will automatically be logged
+ * in the console. This helps log the exception with the right global innerWindowID
+ * and make it display in the right DevTools console.
+ */
+ boolean reportExceptions = false;
+};
+
+/**
+ * Represents a pre-compiled JS script, which can be repeatedly executed in
+ * different globals without being re-parsed.
+ */
+[ChromeOnly, Exposed=Window]
+interface PrecompiledScript {
+ /**
+ * Executes the script in the context of, and with the security principal
+ * of, the given object's global. If compiled with a return value, returns
+ * the value of the script's last expression. Otherwise returns undefined.
+ */
+ [Throws]
+ any executeInGlobal(object global, optional ExecuteInGlobalOptions options = {});
+
+ /**
+ * The URL that the script was loaded from.
+ */
+ [Pure]
+ readonly attribute DOMString url;
+
+ /**
+ * True if the script was compiled with a return value, and will return the
+ * value of its last expression when executed.
+ */
+ [Pure]
+ readonly attribute boolean hasReturnValue;
+};
diff --git a/dom/chrome-webidl/PromiseDebugging.webidl b/dom/chrome-webidl/PromiseDebugging.webidl
new file mode 100644
index 0000000000..c4c4e8ec96
--- /dev/null
+++ b/dom/chrome-webidl/PromiseDebugging.webidl
@@ -0,0 +1,110 @@
+/* -*- Mode: IDL; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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/.
+ */
+
+/* This is a utility namespace for promise-debugging functionality */
+
+
+dictionary PromiseDebuggingStateHolder {
+ PromiseDebuggingState state = "pending";
+ any value;
+ any reason;
+};
+enum PromiseDebuggingState { "pending", "fulfilled", "rejected" };
+
+/**
+ * An observer for Promise that _may_ be leaking uncaught rejections.
+ *
+ * It is generally a programming error to leave a Promise rejected and
+ * not consume its rejection. The information exposed by this
+ * interface is designed to allow clients to track down such Promise,
+ * i.e. Promise that are currently
+ * - in `rejected` state;
+ * - last of their chain.
+ *
+ * Note, however, that a promise in such a state at the end of a tick
+ * may eventually be consumed in some ulterior tick. Implementers of
+ * this interface are responsible for presenting the information
+ * in a meaningful manner.
+ */
+[Exposed=Window]
+callback interface UncaughtRejectionObserver {
+ /**
+ * A Promise has been left in `rejected` state and is the
+ * last in its chain. If this callback returns true, the rejection
+ * will not be reported.
+ *
+ * @param p A currently uncaught Promise. If `p` is is eventually
+ * caught, i.e. if its `then` callback is called, `onConsumed` will
+ * be called.
+ */
+ boolean onLeftUncaught(object p);
+
+ /**
+ * A Promise previously left uncaught is not the last in its
+ * chain anymore.
+ *
+ * @param p A Promise that was previously left in uncaught state is
+ * now caught, i.e. it is not the last in its chain anymore.
+ */
+ undefined onConsumed(object p);
+};
+
+[ChromeOnly, Exposed=Window]
+namespace PromiseDebugging {
+ /**
+ * The various functions on this interface all expect to take promises but
+ * don't want the WebIDL behavior of assimilating random passed-in objects
+ * into promises. They also want to treat Promise subclass instances as
+ * promises instead of wrapping them in a vanilla Promise, which is what the
+ * IDL spec says to do. So we list all our arguments as "object" instead of
+ * "Promise" and check for them being a Promise internally.
+ */
+
+ /**
+ * Get the current state of the given promise.
+ */
+ [Throws]
+ PromiseDebuggingStateHolder getState(object p);
+
+ /**
+ * Return an identifier for a promise. This identifier is guaranteed
+ * to be unique to the current process.
+ */
+ [Throws]
+ DOMString getPromiseID(object p);
+
+ /**
+ * Return the stack to the promise's allocation point. This can
+ * return null if the promise was not created from script.
+ */
+ [Throws]
+ object? getAllocationStack(object p);
+
+ /**
+ * Return the stack to the promise's rejection point, if the
+ * rejection happened from script. This can return null if the
+ * promise has not been rejected or was not rejected from script.
+ */
+ [Throws]
+ object? getRejectionStack(object p);
+
+ /**
+ * Return the stack to the promise's fulfillment point, if the
+ * fulfillment happened from script. This can return null if the
+ * promise has not been fulfilled or was not fulfilled from script.
+ */
+ [Throws]
+ object? getFullfillmentStack(object p);
+
+ /**
+ * Watching uncaught rejections on the current thread.
+ *
+ * Adding an observer twice will cause it to be notified twice
+ * of events.
+ */
+ undefined addUncaughtRejectionObserver(UncaughtRejectionObserver o);
+ boolean removeUncaughtRejectionObserver(UncaughtRejectionObserver o);
+};
diff --git a/dom/chrome-webidl/SessionStoreUtils.webidl b/dom/chrome-webidl/SessionStoreUtils.webidl
new file mode 100644
index 0000000000..9032c784c4
--- /dev/null
+++ b/dom/chrome-webidl/SessionStoreUtils.webidl
@@ -0,0 +1,169 @@
+/* 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/. */
+
+interface nsIDocShell;
+interface nsISupports;
+interface nsISessionStoreRestoreData;
+
+/**
+ * A callback passed to SessionStoreUtils.forEachNonDynamicChildFrame().
+ */
+callback SessionStoreUtilsFrameCallback = undefined (WindowProxy frame, unsigned long index);
+
+/**
+ * SessionStore utility functions implemented in C++ for performance reasons.
+ */
+[ChromeOnly, Exposed=Window]
+namespace SessionStoreUtils {
+ /**
+ * Calls the given |callback| once for each non-dynamic child frame of the
+ * given |window|.
+ */
+ [Throws]
+ undefined forEachNonDynamicChildFrame(WindowProxy window,
+ SessionStoreUtilsFrameCallback callback);
+
+ /**
+ * Takes the given listener, wraps it in a filter that filters out events from
+ * dynamic docShells, and adds that filter as a listener for the given event
+ * type on the given event target. The listener that was added is returned
+ * (as nsISupports) so that it can later be removed via
+ * removeDynamicFrameFilteredListener.
+ *
+ * This is implemented as a native filter, rather than a JS-based one, for
+ * performance reasons.
+ */
+ [Throws]
+ nsISupports? addDynamicFrameFilteredListener(EventTarget target,
+ DOMString type,
+ any listener,
+ boolean useCapture,
+ optional boolean mozSystemGroup = false);
+
+ /**
+ * Remove the passed-in filtered listener from the given event target, if it's
+ * currently a listener for the given event type there. The 'listener'
+ * argument must be something that was returned by
+ * addDynamicFrameFilteredListener.
+ *
+ * This is needed, instead of the normal removeEventListener, because the
+ * caller doesn't actually have something that WebIDL considers an
+ * EventListener.
+ */
+ [Throws]
+ undefined removeDynamicFrameFilteredListener(EventTarget target,
+ DOMString type,
+ nsISupports listener,
+ boolean useCapture,
+ optional boolean mozSystemGroup = false);
+
+ /*
+ * Save the docShell.allow* properties
+ */
+ ByteString collectDocShellCapabilities(nsIDocShell docShell);
+
+ /*
+ * Restore the docShell.allow* properties
+ */
+ undefined restoreDocShellCapabilities(nsIDocShell docShell,
+ ByteString disallowCapabilities);
+
+ /**
+ * Collects scroll position data for any given |frame| in the frame hierarchy.
+ *
+ * @param document (DOMDocument)
+ *
+ * @return {scroll: "x,y"} e.g. {scroll: "100,200"}
+ * Returns null when there is no scroll data we want to store for the
+ * given |frame|.
+ */
+ CollectedData? collectScrollPosition(WindowProxy window);
+
+ /**
+ * Restores scroll position data for any given |frame| in the frame hierarchy.
+ *
+ * @param frame (DOMWindow)
+ * @param value (object, see collectScrollPosition())
+ */
+ undefined restoreScrollPosition(Window frame, optional CollectedData data = {});
+
+ /**
+ * Collect form data for a given |frame| *not* including any subframes.
+ *
+ * The returned object may have an "id", "xpath", or "innerHTML" key or a
+ * combination of those three. Form data stored under "id" is for input
+ * fields with id attributes. Data stored under "xpath" is used for input
+ * fields that don't have a unique id and need to be queried using XPath.
+ * The "innerHTML" key is used for editable documents (designMode=on).
+ *
+ * Example:
+ * {
+ * id: {input1: "value1", input3: "value3"},
+ * xpath: {
+ * "/xhtml:html/xhtml:body/xhtml:input[@name='input2']" : "value2",
+ * "/xhtml:html/xhtml:body/xhtml:input[@name='input4']" : "value4"
+ * }
+ * }
+ *
+ * @return object
+ * Returns null when there is no scroll data
+ */
+ CollectedData? collectFormData(WindowProxy window);
+
+ boolean restoreFormData(Document document, optional CollectedData data = {});
+
+ nsISessionStoreRestoreData constructSessionStoreRestoreData();
+
+ [Throws]
+ Promise<undefined> initializeRestore(CanonicalBrowsingContext browsingContext,
+ nsISessionStoreRestoreData? data);
+
+ [NewObject]
+ Promise<undefined> restoreDocShellState(
+ CanonicalBrowsingContext browsingContext,
+ UTF8String? url,
+ ByteString? docShellCaps);
+
+ undefined restoreSessionStorageFromParent(
+ CanonicalBrowsingContext browsingContext,
+ record<UTF8String, record<DOMString, DOMString>> sessionStorage);
+};
+
+[GenerateConversionToJS, GenerateInit]
+dictionary CollectedFileListValue
+{
+ DOMString type = "file";
+ required sequence<DOMString> fileList;
+};
+
+[GenerateConversionToJS, GenerateInit]
+dictionary CollectedNonMultipleSelectValue
+{
+ required long selectedIndex;
+ required DOMString value;
+};
+
+// object contains either a CollectedFileListValue or a CollectedNonMultipleSelectValue or Sequence<DOMString>
+typedef (DOMString or boolean or object) CollectedFormDataValue;
+
+dictionary CollectedData
+{
+ ByteString scroll;
+ record<DOMString, CollectedFormDataValue> id;
+ record<DOMString, CollectedFormDataValue> xpath;
+ DOMString innerHTML;
+ ByteString url;
+ // mChildren contains CollectedData instances
+ sequence<object?> children;
+};
+
+dictionary InputElementData {
+ sequence<DOMString> id;
+ sequence<DOMString> type;
+ sequence<long> valueIdx;
+ sequence<long> selectedIndex;
+ sequence<DOMString> selectVal;
+ sequence<DOMString> strVal;
+ sequence<boolean> boolVal;
+};
diff --git a/dom/chrome-webidl/StructuredCloneHolder.webidl b/dom/chrome-webidl/StructuredCloneHolder.webidl
new file mode 100644
index 0000000000..6bfa34958c
--- /dev/null
+++ b/dom/chrome-webidl/StructuredCloneHolder.webidl
@@ -0,0 +1,40 @@
+/* -*- Mode: IDL; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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/.
+ */
+
+/**
+ * A holder for structured-clonable data which can itself be cloned with
+ * little overhead, and deserialized into an arbitrary global.
+ */
+[ChromeOnly, Exposed=(Window,Worker)]
+interface StructuredCloneHolder {
+ /**
+ * Serializes the given value to an opaque structured clone blob, and
+ * returns the result.
+ *
+ * The serialization happens in the compartment of the given global or, if no
+ * global is provided, the compartment of the data value.
+ *
+ * The name argument is added to the path of the object in
+ * memory reports, to make it easier to determine the source of leaks. In
+ * anonymized memory reports, the anonymized name is used instead. If
+ * anonymizedName is null, name is used in anonymized reports as well.
+ * Anonymized names should not contain any potentially private information,
+ * such as web URLs or user-provided data.
+ */
+ [Throws]
+ constructor(UTF8String name, UTF8String? anonymizedName,
+ any data, optional object? global = null);
+
+ /**
+ * Deserializes the structured clone data in the scope of the given global,
+ * and returns the result.
+ *
+ * If `keepData` is true, the structured clone data is preserved, and can be
+ * deserialized repeatedly. Otherwise, it is immediately discarded.
+ */
+ [Throws]
+ any deserialize(object global, optional boolean keepData = false);
+};
diff --git a/dom/chrome-webidl/TelemetryStopwatch.webidl b/dom/chrome-webidl/TelemetryStopwatch.webidl
new file mode 100644
index 0000000000..92f8a0d630
--- /dev/null
+++ b/dom/chrome-webidl/TelemetryStopwatch.webidl
@@ -0,0 +1,238 @@
+/* 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/.
+ */
+
+typedef DOMString HistogramID;
+typedef DOMString HistogramKey;
+
+[ChromeOnly, Exposed=Window]
+namespace TelemetryStopwatch {
+ /**
+ * Starts a timer associated with a telemetry histogram. The timer can be
+ * directly associated with a histogram, or with a pair of a histogram and
+ * an object.
+ *
+ * @param histogram - a string which must be a valid histogram name.
+ *
+ * @param obj - Optional parameter. If specified, the timer is
+ * associated with this object, meaning that multiple
+ * timers for the same histogram may be run
+ * concurrently, as long as they are associated with
+ * different objects.
+ * @param [options.inSeconds=false] - record elapsed time for this
+ * histogram in seconds instead of milliseconds. Defaults to
+ * false.
+ *
+ * @returns True if the timer was successfully started, false
+ * otherwise. If a timer already exists, it can't be
+ * started again, and the existing one will be cleared in
+ * order to avoid measurements errors.
+ */
+ boolean start(HistogramID histogram, optional object? obj = null,
+ optional TelemetryStopwatchOptions options = {});
+
+ /**
+ * Returns whether a timer associated with a telemetry histogram is currently
+ * running. The timer can be directly associated with a histogram, or with a
+ * pair of a histogram and an object.
+ *
+ * @param histogram - a string which must be a valid histogram name.
+ *
+ * @param obj - Optional parameter. If specified, the timer is
+ * associated with this object, meaning that multiple
+ * timers for the same histogram may be run
+ * concurrently, as long as they are associated with
+ * different objects.
+ *
+ * @returns True if the timer exists and is currently running.
+ */
+ boolean running(HistogramID histogram, optional object? obj = null);
+
+ /**
+ * Deletes the timer associated with a telemetry histogram. The timer can be
+ * directly associated with a histogram, or with a pair of a histogram and
+ * an object. Important: Only use this method when a legitimate cancellation
+ * should be done.
+ *
+ * @param histogram - a string which must be a valid histogram name.
+ *
+ * @param obj - Optional parameter. If specified, the timer is
+ * associated with this object, meaning that multiple
+ * timers or a same histogram may be run concurrently,
+ * as long as they are associated with different
+ * objects.
+ *
+ * @returns True if the timer exist and it was cleared, False
+ * otherwise.
+ */
+ boolean cancel(HistogramID histogram, optional object? obj = null);
+
+ /**
+ * Returns the elapsed time for a particular stopwatch. Primarily for
+ * debugging purposes. Must be called prior to finish.
+ *
+ * @param histogram - a string which must be a valid histogram name.
+ * if an invalid name is given, the function will
+ * throw.
+ *
+ * @param obj - Optional parameter which associates the histogram
+ * timer with the given object.
+ *
+ * @param canceledOkay - Optional parameter which will suppress any
+ * warnings that normally fire when a stopwatch
+ * is finished after being cancelled. Defaults
+ * to false.
+ *
+ * @returns Time in milliseconds or -1 if the stopwatch was not
+ * found.
+ */
+ long timeElapsed(HistogramID histogram,
+ optional object? obj = null,
+ optional boolean canceledOkay = false);
+
+ /**
+ * Stops the timer associated with the given histogram (and object),
+ * calculates the time delta between start and finish, and adds the value
+ * to the histogram.
+ *
+ * @param histogram - a string which must be a valid histogram name.
+ *
+ * @param obj - Optional parameter which associates the histogram
+ * timer with the given object.
+ *
+ * @param canceledOkay - Optional parameter which will suppress any
+ * warnings that normally fire when a stopwatch
+ * is finished after being cancelled. Defaults
+ * to false.
+ *
+ * @returns True if the timer was succesfully stopped and the data
+ * was added to the histogram, false otherwise.
+ */
+ boolean finish(HistogramID histogram,
+ optional object? obj = null,
+ optional boolean canceledOkay = false);
+
+ /**
+ * Starts a timer associated with a keyed telemetry histogram. The timer can
+ * be directly associated with a histogram and its key. Similarly to
+ * @see{TelemetryStopwatch.start} the histogram and its key can be associated
+ * with an object. Each key may have multiple associated objects and each
+ * object can be associated with multiple keys.
+ *
+ * @param histogram - a string which must be a valid histogram name.
+ *
+ * @param key - a string which must be a valid histgram key.
+ *
+ * @param obj - Optional parameter. If specified, the timer is
+ * associated with this object, meaning that multiple
+ * timers for the same histogram may be run
+ * concurrently,as long as they are associated with
+ * different objects.
+ * @param [options.inSeconds=false] - record elapsed time for this
+ * histogram in seconds instead of milliseconds. Defaults to
+ * false.
+ *
+ * @returns True if the timer was successfully started, false
+ * otherwise. If a timer already exists, it can't be
+ * started again, and the existing one will be cleared in
+ * order to avoid measurements errors.
+ */
+ boolean startKeyed(HistogramID histogram, HistogramKey key,
+ optional object? obj = null,
+ optional TelemetryStopwatchOptions options = {});
+
+ /**
+ * Returns whether a timer associated with a telemetry histogram is currently
+ * running. Similarly to @see{TelemetryStopwatch.running} the timer and its
+ * key can be associated with an object. Each key may have multiple associated
+ * objects and each object can be associated with multiple keys.
+ *
+ * @param histogram - a string which must be a valid histogram name.
+ *
+ * @param key - a string which must be a valid histgram key.
+ *
+ * @param obj - Optional parameter. If specified, the timer is
+ * associated with this object, meaning that multiple
+ * timers for the same histogram may be run
+ * concurrently, as long as they are associated with
+ * different objects.
+ *
+ * @returns True if the timer exists and is currently running.
+ */
+ boolean runningKeyed(HistogramID histogram, HistogramKey key,
+ optional object? obj = null);
+
+ /**
+ * Deletes the timer associated with a keyed histogram. Important: Only use
+ * this method when a legitimate cancellation should be done.
+ *
+ * @param histogram - a string which must be a valid histogram name.
+ *
+ * @param key - a string which must be a valid histgram key.
+ *
+ * @param obj - Optional parameter. If specified, the timer
+ * associated with this object is deleted.
+ *
+ * @returns True if the timer exist and it was cleared, False
+ * otherwise.
+ */
+ boolean cancelKeyed(HistogramID histogram, HistogramKey key,
+ optional object? obj = null);
+
+ /**
+ * Returns the elapsed time for a particular stopwatch. Primarily for
+ * debugging purposes. Cannot be called after finish().
+ *
+ * @param histogram - a string which must be a valid histogram name.
+ *
+ * @param key - a string which must be a valid histgram key.
+ *
+ * @param obj - Optional parameter. If specified, the timer
+ * associated with this object is used to calculate
+ * the elapsed time.
+ *
+ * @returns Time in milliseconds or -1 if the stopwatch was not
+ * found.
+ */
+ long timeElapsedKeyed(HistogramID histogram, HistogramKey key,
+ optional object? obj = null,
+ optional boolean canceledOkay = false);
+
+ /**
+ * Stops the timer associated with the given keyed histogram (and object),
+ * calculates the time delta between start and finish, and adds the value
+ * to the keyed histogram.
+ *
+ * @param histogram - a string which must be a valid histogram name.
+ *
+ * @param key - a string which must be a valid histgram key.
+ *
+ * @param obj - optional parameter which associates the histogram
+ * timer with the given object.
+ *
+ * @param canceledOkay - Optional parameter which will suppress any
+ * warnings that normally fire when a stopwatch
+ * is finished after being cancelled. Defaults
+ * to false.
+ *
+ * @returns True if the timer was succesfully stopped and the data
+ * was added to the histogram, false otherwise.
+ */
+ boolean finishKeyed(HistogramID histogram, HistogramKey key,
+ optional object? obj = null,
+ optional boolean canceledOkay = false);
+
+ /**
+ * Set the testing mode. Used by tests.
+ */
+ undefined setTestModeEnabled(optional boolean testing = true);
+};
+
+dictionary TelemetryStopwatchOptions {
+ /**
+ * If true, record elapsed time for this histogram in seconds instead of
+ * milliseconds.
+ */
+ boolean inSeconds = false;
+};
diff --git a/dom/chrome-webidl/UniFFI.webidl b/dom/chrome-webidl/UniFFI.webidl
new file mode 100644
index 0000000000..7a3f68fbbd
--- /dev/null
+++ b/dom/chrome-webidl/UniFFI.webidl
@@ -0,0 +1,107 @@
+/* -*- Mode: IDL; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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/. */
+
+// Interface for making UniFFI scaffolding calls
+//
+// Gecko uses UniFFI to generate privileged JS bindings for Rust components.
+// UniFFI defines a C-ABI FFI layer for calling into Rust, called the
+// scaffolding. This interface is a bridge that allows the JS code to make
+// scaffolding calls
+//
+// See https://mozilla.github.io/uniffi-rs/ for details.
+
+// Define some ID types to identify various parts of the UDL interfaces. Using
+// these IDs, allow this .webidl file to remain static, but support new
+// interfaces. Using IDs is that the C++ and JS code need to agree on their
+// meaning, which is handled by
+// toolkit/components/uniffi-bindgen-gecko-js/src/ci_list.rs.
+
+// Identifies a scaffolding function.
+typedef unsigned long long UniFFIFunctionId;
+
+// Identifies a pointer type
+typedef unsigned long long UniFFIPointerId;
+
+// Identifies a callback interface
+typedef unsigned long UniFFICallbackInterfaceId;
+
+// Identifies a method of a callback interface
+typedef unsigned long UniFFICallbackMethodId;
+
+// Handle for a callback interface instance
+typedef unsigned long long UniFFICallbackObjectHandle;
+
+// Opaque type used to represent a pointer from Rust
+[ChromeOnly, Exposed=Window]
+interface UniFFIPointer {};
+
+// Types that can be passed or returned from scaffolding functions
+//
+// - double is used for all numeric types and types which the JS code coerces
+// to an int including Boolean and CallbackInterface.
+// - ArrayBuffer is used for RustBuffer
+// - UniFFIPointer is used for Arc pointers
+typedef (double or ArrayBuffer or UniFFIPointer) UniFFIScaffoldingType;
+
+// The result of a call into UniFFI scaffolding call
+enum UniFFIScaffoldingCallCode {
+ "success", // Successful return
+ "error", // Rust Err return
+ "internal-error", // Internal/unexpected error
+};
+
+dictionary UniFFIScaffoldingCallResult {
+ required UniFFIScaffoldingCallCode code;
+ // For success, this will be the return value for non-void returns
+ // For error, this will be an ArrayBuffer storing the serialized error value
+ UniFFIScaffoldingType data;
+ // For internal-error, this will be a utf-8 string describing the error
+ ByteString internalErrorMessage;
+};
+
+// JS handler for calling a CallbackInterface method.
+// The arguments and return value are always packed into an ArrayBuffer
+callback UniFFICallbackHandler = undefined (UniFFICallbackObjectHandle objectId, UniFFICallbackMethodId methodId, ArrayBuffer aArgs);
+
+// Functions to facilitate UniFFI scaffolding calls
+[ChromeOnly, Exposed=Window]
+namespace UniFFIScaffolding {
+ // Call a scaffolding function on the worker thread.
+ //
+ // id is a unique identifier for the function, known to both the C++ and JS code
+ [Throws]
+ Promise<UniFFIScaffoldingCallResult> callAsync(UniFFIFunctionId id, UniFFIScaffoldingType... args);
+
+ // Call a scaffolding function on the main thread
+ //
+ // id is a unique identifier for the function, known to both the C++ and JS code
+ [Throws]
+ UniFFIScaffoldingCallResult callSync(UniFFIFunctionId id, UniFFIScaffoldingType... args);
+
+ // Read a UniFFIPointer from an ArrayBuffer
+ //
+ // id is a unique identifier for the pointer type, known to both the C++ and JS code
+ [Throws]
+ UniFFIPointer readPointer(UniFFIPointerId id, ArrayBuffer buff, long position);
+
+ // Write a UniFFIPointer to an ArrayBuffer
+ //
+ // id is a unique identifier for the pointer type, known to both the C++ and JS code
+ [Throws]
+ undefined writePointer(UniFFIPointerId id, UniFFIPointer ptr, ArrayBuffer buff, long position);
+
+ // Register the global calblack handler
+ //
+ // This will be used to invoke all calls for a CallbackInterface.
+ // interfaceId is a unique identifier for the callback interface, known to both the C++ and JS code
+ [Throws]
+ undefined registerCallbackHandler(UniFFICallbackInterfaceId interfaceId, UniFFICallbackHandler handler);
+
+ // Deregister the global calblack handler
+ //
+ // This is called at shutdown to clear out the reference to the JS function.
+ [Throws]
+ undefined deregisterCallbackHandler(UniFFICallbackInterfaceId interfaceId);
+};
diff --git a/dom/chrome-webidl/UserInteraction.webidl b/dom/chrome-webidl/UserInteraction.webidl
new file mode 100644
index 0000000000..ccde57dcac
--- /dev/null
+++ b/dom/chrome-webidl/UserInteraction.webidl
@@ -0,0 +1,113 @@
+/* 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/.
+ */
+
+[ChromeOnly, Exposed=Window]
+namespace UserInteraction {
+ /**
+ * Starts a timer associated with a UserInteraction ID. The timer can be
+ * directly associated with a UserInteraction ID, or with a pair of a
+ * UserInteraction ID and an object.
+ *
+ * @param id - the interaction being recorded, as
+ * declared in UserInteractions.yaml. This is also the annotation
+ * key that will be set in the BHR hang report if a hang occurs
+ * before the UserInteraction is finished.
+ *
+ * @param value - a value to be set on the key in the event
+ * that a hang occurs when the timer is running. This value is limited
+ * to 50 characters to avoid abuse, and if the value exceeds that limit
+ * then no timer is started, an error is printed, and this function returns
+ * false.
+ *
+ * @param obj - Optional parameter. If specified, the timer is
+ * associated with this object, meaning that multiple timers for the
+ * same annotation key may be run concurrently, as long as they are
+ * associated with different objects.
+ *
+ * @returns True if the timer was successfully started, false otherwise.
+ * If a timer already exists, it will be overwritten, and the new timer
+ * will include a "(clobbered)" suffix in any BHR annotations that get
+ * created.
+ */
+ boolean start(DOMString id,
+ UTF8String value,
+ optional object? obj = null);
+
+ /**
+ * Updates an already-running timer associated with a UserInteraction ID
+ * (and object) with a new value string.
+ *
+ * @param id - the interaction being recorded, as
+ * declared in UserInteractions.yaml. This is also the annotation
+ * key that will be set in the BHR hang report if a hang occurs
+ * before the UserInteraction is finished.
+ *
+ * @param value - a new value to be set on the key in the event
+ * that a hang occurs when the timer is running. This value is limited
+ * to 50 characters to avoid abuse.
+ *
+ * @param obj - Optional parameter. If specified, the timer is
+ * associated with this object, meaning that multiple timers for the
+ * same annotation key may be run concurrently, as long as they are
+ * associated with different objects.
+ *
+ * @returns True if the timer was successfully updated, false
+ * otherwise.
+ */
+ boolean update(DOMString id,
+ UTF8String value,
+ optional object? obj = null);
+
+ /**
+ * Cancels the timer associated with the given UserInteraction ID
+ * (and object) and does not add the profiler marker for it.
+ *
+ * @param id - the interaction being recorded, as
+ * declared in UserInteractions.yaml.
+ *
+ * @param obj - Optional parameter which associates the
+ * timer with the given object.
+ *
+ * @returns True if the timer was successfully stopped.
+ */
+ boolean cancel(DOMString id, optional object? obj = null);
+
+ /**
+ * Returns whether a UserInteraction timer is currently running.
+ *
+ * @param id - the ID of the interaction to check, as declared in
+ * UserInteractions.yaml.
+ *
+ * @param obj - Optional parameter which checks for a timer associated
+ * with this particular object. If you're checking for a running timer
+ * that was started with an object, you'll need to pass in that same
+ * object here to check its running state.
+ *
+ * @returns True if the timer exists and is currently running.
+ */
+ boolean running(DOMString id, optional object? obj = null);
+
+ /**
+ * Stops the timer associated with the given UserInteraction ID
+ * (and object), calculates the time delta between start and finish,
+ * and adds a profiler marker with that time range.
+ *
+ * @param id - the interaction being recorded, as
+ * declared in UserInteractions.yaml.
+ *
+ * @param obj - Optional parameter which associates the
+ * timer with the given object.
+ *
+ * @param additionalText - Optional parameter with includes additional
+ * text in the profiler marker. This text is not included in the hang
+ * annotation.
+ *
+ * @returns True if the timer was successfully stopped and the data
+ * was added to the profile.
+ */
+ boolean finish(DOMString id,
+ optional object? obj = null,
+ optional UTF8String additionalText);
+};
diff --git a/dom/chrome-webidl/WebExtensionContentScript.webidl b/dom/chrome-webidl/WebExtensionContentScript.webidl
new file mode 100644
index 0000000000..4eadfbcb09
--- /dev/null
+++ b/dom/chrome-webidl/WebExtensionContentScript.webidl
@@ -0,0 +1,174 @@
+/* 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/. */
+
+interface LoadInfo;
+interface URI;
+interface WindowProxy;
+
+typedef (MatchPatternSet or sequence<DOMString>) MatchPatternSetOrStringSequence;
+typedef (MatchGlob or UTF8String) MatchGlobOrString;
+
+[ChromeOnly, Exposed=Window]
+interface MozDocumentMatcher {
+ [Throws]
+ constructor(MozDocumentMatcherInit options);
+
+ /**
+ * Returns true if the script's match and exclude patterns match the given
+ * URI, without reference to attributes such as `allFrames`.
+ */
+ boolean matchesURI(URI uri);
+
+ /**
+ * Returns true if the given window matches. This should be used to
+ * determine whether to run a script in a window at load time. Use
+ * ignorePermissions to match without origin permissions in MV3.
+ */
+ boolean matchesWindowGlobal(WindowGlobalChild windowGlobal,
+ optional boolean ignorePermissions = false);
+
+ /**
+ * If true, match all frames. If false, match only top-level frames.
+ */
+ [Constant]
+ readonly attribute boolean allFrames;
+
+ /**
+ * If we can't check extension has permissions to access the URI upfront,
+ * set the flag to perform the origin check at runtime, upon matching.
+ * This is always true in MV3, where host permissions are optional.
+ */
+ [Constant]
+ readonly attribute boolean checkPermissions;
+
+ /**
+ * If true, this (misleadingly-named, but inherited from Chrome) attribute
+ * causes us to match frames with URLs which inherit a principal that
+ * matches one of the match patterns, such as about:blank or about:srcdoc.
+ * If false, we only match frames with an explicit matching URL.
+ */
+ [Constant]
+ readonly attribute boolean matchAboutBlank;
+
+ /**
+ * The outer window ID of the frame in which to run the script, or 0 if it
+ * should run in the top-level frame. Should only be used for
+ * dynamically-injected scripts.
+ */
+ [Constant]
+ readonly attribute unsigned long long? frameID;
+
+ /**
+ * The set of match patterns for URIs of pages in which this script should
+ * run. This attribute is mandatory, and is a prerequisite for all other
+ * match patterns.
+ */
+ [Constant]
+ readonly attribute MatchPatternSet matches;
+
+ /**
+ * A set of match patterns for URLs in which this script should not run,
+ * even if they match other include patterns or globs.
+ */
+ [Constant]
+ readonly attribute MatchPatternSet? excludeMatches;
+
+ /**
+ * The originAttributesPattern for which this script should be enabled for.
+ */
+ [Constant, Throws]
+ readonly attribute any originAttributesPatterns;
+
+ /**
+ * The policy object for the extension that this matcher belongs to.
+ */
+ [Constant]
+ readonly attribute WebExtensionPolicy? extension;
+};
+
+dictionary MozDocumentMatcherInit {
+ boolean allFrames = false;
+
+ boolean checkPermissions = false;
+
+ sequence<OriginAttributesPatternDictionary>? originAttributesPatterns = null;
+
+ boolean matchAboutBlank = false;
+
+ unsigned long long? frameID = null;
+
+ required MatchPatternSetOrStringSequence matches;
+
+ MatchPatternSetOrStringSequence? excludeMatches = null;
+
+ sequence<MatchGlobOrString>? includeGlobs = null;
+
+ sequence<MatchGlobOrString>? excludeGlobs = null;
+
+ boolean hasActiveTabPermission = false;
+};
+
+/**
+ * Describes the earliest point in the load cycle at which a script should
+ * run.
+ */
+enum ContentScriptRunAt {
+ /**
+ * The point in the load cycle just after the document element has been
+ * inserted, before any page scripts have been allowed to run.
+ */
+ "document_start",
+ /**
+ * The point after which the page DOM has fully loaded, but before all page
+ * resources have necessarily been loaded. Corresponds approximately to the
+ * DOMContentLoaded event.
+ */
+ "document_end",
+ /**
+ * The first point after the page and all of its resources has fully loaded
+ * when the event loop is idle, and can run scripts without delaying a paint
+ * event.
+ */
+ "document_idle",
+};
+
+[ChromeOnly, Exposed=Window]
+interface WebExtensionContentScript : MozDocumentMatcher {
+ [Throws]
+ constructor(WebExtensionPolicy extension,
+ WebExtensionContentScriptInit options);
+
+ /**
+ * The earliest point in the load cycle at which this script should run. For
+ * static content scripts, in extensions which were present at browser
+ * startup, the browser makes every effort to make sure that the script runs
+ * no later than this point in the load cycle. For dynamic content scripts,
+ * and scripts from extensions installed during this session, the scripts
+ * may run at a later point.
+ */
+ [Constant]
+ readonly attribute ContentScriptRunAt runAt;
+
+ /**
+ * A set of paths, relative to the extension root, of CSS sheets to inject
+ * into matching pages.
+ */
+ [Cached, Constant, Frozen]
+ readonly attribute sequence<DOMString> cssPaths;
+
+ /**
+ * A set of paths, relative to the extension root, of JavaScript scripts to
+ * execute in matching pages.
+ */
+ [Cached, Constant, Frozen]
+ readonly attribute sequence<DOMString> jsPaths;
+};
+
+dictionary WebExtensionContentScriptInit : MozDocumentMatcherInit {
+ ContentScriptRunAt runAt = "document_idle";
+
+ sequence<DOMString> cssPaths = [];
+
+ sequence<DOMString> jsPaths = [];
+};
diff --git a/dom/chrome-webidl/WebExtensionPolicy.webidl b/dom/chrome-webidl/WebExtensionPolicy.webidl
new file mode 100644
index 0000000000..669e262621
--- /dev/null
+++ b/dom/chrome-webidl/WebExtensionPolicy.webidl
@@ -0,0 +1,342 @@
+/* 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/. */
+
+interface URI;
+interface WindowProxy;
+
+callback WebExtensionLocalizeCallback = DOMString (DOMString unlocalizedText);
+
+/**
+ * Defines the platform-level policies for a WebExtension, including its
+ * permissions and the characteristics of its moz-extension: URLs.
+ */
+[ChromeOnly, Exposed=Window]
+interface WebExtensionPolicy {
+ [Throws]
+ constructor(WebExtensionInit options);
+
+ /**
+ * The add-on's internal ID, as specified in its manifest.json file or its
+ * XPI signature.
+ */
+ [Constant, StoreInSlot]
+ readonly attribute DOMString id;
+
+ /**
+ * The hostname part of the extension's moz-extension: URLs. This value is
+ * generated randomly at install time.
+ */
+ [Constant, StoreInSlot]
+ readonly attribute ByteString mozExtensionHostname;
+
+ /**
+ * The file: or jar: URL to use for the base of the extension's
+ * moz-extension: URL root.
+ */
+ [Constant]
+ readonly attribute ByteString baseURL;
+
+ /**
+ * The extension's user-visible name.
+ */
+ [Constant]
+ readonly attribute DOMString name;
+
+ /**
+ * The add-on's internal type as determined by parsing the manifest.json file.
+ */
+ [Constant]
+ readonly attribute DOMString type;
+
+ /**
+ * Whether the extension has access to privileged features
+ */
+ [Constant]
+ readonly attribute boolean isPrivileged;
+
+ /**
+ * Whether the extension is installed temporarily
+ */
+ [Constant]
+ readonly attribute boolean temporarilyInstalled;
+
+ /**
+ * The manifest version in use by the extension.
+ */
+ [Constant]
+ readonly attribute unsigned long manifestVersion;
+
+ /**
+ * The base content security policy string to apply on extension
+ * pages for this extension. The baseCSP is specific to the
+ * manifest version. If the manifest version is 3 or higher it
+ * is also applied to content scripts.
+ */
+ [Constant]
+ readonly attribute DOMString baseCSP;
+
+ /**
+ * The content security policy string to apply to all pages loaded from the
+ * extension's moz-extension: protocol. If one is not provided by the
+ * extension the default value from preferences is used.
+ * See extensions.webextensions.default-content-security-policy.
+ */
+ [Constant]
+ readonly attribute DOMString extensionPageCSP;
+
+ /**
+ * The list of currently-active permissions for the extension, as specified
+ * in its manifest.json file. May be updated to reflect changes in the
+ * extension's optional permissions.
+ */
+ [Cached, Frozen, Pure]
+ attribute sequence<DOMString> permissions;
+
+ /**
+ * Match patterns for the set of web origins to which the extension is
+ * currently allowed access. May be updated to reflect changes in the
+ * extension's optional permissions.
+ */
+ [Pure]
+ attribute MatchPatternSet allowedOrigins;
+
+ /**
+ * The set of content scripts active for this extension.
+ */
+ [Cached, Frozen, Pure]
+ readonly attribute sequence<WebExtensionContentScript> contentScripts;
+
+ /**
+ * True if the extension is currently active, false otherwise. When active,
+ * the extension's moz-extension: protocol will point to the given baseURI,
+ * and the set of policies for this object will be active for its ID.
+ *
+ * Only one extension policy with a given ID or hostname may be active at a
+ * time. Attempting to activate a policy while a conflicting policy is
+ * active will raise an error.
+ */
+ [Affects=Everything, SetterThrows]
+ attribute boolean active;
+
+ /**
+ * True if both e10s and webextensions.remote are enabled. This must be
+ * used instead of checking the remote pref directly since remote extensions
+ * require both to be enabled.
+ */
+ static readonly attribute boolean useRemoteWebExtensions;
+
+ /**
+ * True if the calling process is an extension process.
+ */
+ static readonly attribute boolean isExtensionProcess;
+
+ /**
+ * Whether the background.service_worker in the extension manifest.json file
+ * is enabled.
+ *
+ * NOTE: **do not use Services.prefs to retrieve the value of the undelying pref**
+ *
+ * It is defined in StaticPrefs.yaml as `mirror: once` and so checking
+ * its current value using Services.prefs doesn't guarantee that it does
+ * match the value as accessible from the C++ layers, and unexpected issue
+ * may be possible if different code has a different idea of its value.
+ */
+ static readonly attribute boolean backgroundServiceWorkerEnabled;
+
+ /**
+ * Whether the Quarantined Domains feature is enabled. Use this as a single
+ * source of truth instead of checking extensions.QuarantinedDomains.enabled
+ * pref directly because the logic might change.
+ */
+ static readonly attribute boolean quarantinedDomainsEnabled;
+
+ /**
+ * Set based on the manifest.incognito value:
+ * If "spanning" or "split" will be true.
+ * If "not_allowed" will be false.
+ */
+ [Pure]
+ readonly attribute boolean privateBrowsingAllowed;
+
+ /**
+ * Returns true if the extension can access a window. Access is
+ * determined by matching the windows private browsing context
+ * with privateBrowsingMode. This does not, and is not meant to
+ * handle specific differences between spanning and split mode.
+ */
+ [Affects=Nothing]
+ boolean canAccessWindow(WindowProxy window);
+
+ /**
+ * Returns true if the extension has cross-origin access to the given URI.
+ */
+ boolean canAccessURI(URI uri, optional boolean explicit = false);
+
+ /**
+ * Returns true if the extension currently has the given permission.
+ */
+ boolean hasPermission(DOMString permission);
+
+ /**
+ * Returns true if the domain is on the Quarantined Domains list.
+ */
+ static boolean isQuarantinedURI(URI uri);
+
+ /**
+ * Returns true if this extension is quarantined from the URI.
+ */
+ boolean quarantinedFromURI(URI uri);
+
+ /**
+ * Returns true if the given path relative to the extension's moz-extension:
+ * URL root is listed as a web accessible path. Access checks on a path, such
+ * as performed in nsScriptSecurityManager, use sourceMayAccessPath below.
+ */
+ boolean isWebAccessiblePath(UTF8String pathname);
+
+ /**
+ * Returns true if the given path relative to the extension's moz-extension:
+ * URL root may be accessed by web content at sourceURI. For Manifest V2,
+ * sourceURI is ignored and the path must merely be listed as web accessible.
+ */
+ boolean sourceMayAccessPath(URI sourceURI, UTF8String pathname);
+
+ /**
+ * Replaces localization placeholders in the given string with localized
+ * text from the extension's currently active locale.
+ */
+ DOMString localize(DOMString unlocalizedText);
+
+ /**
+ * Returns the moz-extension: URL for the given path.
+ */
+ [Throws]
+ DOMString getURL(optional DOMString path = "");
+
+ /**
+ * Register a new content script programmatically.
+ */
+ [Throws]
+ undefined registerContentScript(WebExtensionContentScript script);
+
+ /**
+ * Unregister a content script.
+ */
+ [Throws]
+ undefined unregisterContentScript(WebExtensionContentScript script);
+
+ /**
+ * Injects the extension's content script into all existing matching windows.
+ */
+ [Throws]
+ undefined injectContentScripts();
+
+ /**
+ * Returns the list of currently active extension policies.
+ */
+ static sequence<WebExtensionPolicy> getActiveExtensions();
+
+ /**
+ * Returns the currently-active policy for the extension with the given ID,
+ * or null if no policy is active for that ID.
+ */
+ static WebExtensionPolicy? getByID(DOMString id);
+
+ /**
+ * Returns the currently-active policy for the extension with the given
+ * moz-extension: hostname, or null if no policy is active for that
+ * hostname.
+ */
+ static WebExtensionPolicy? getByHostname(ByteString hostname);
+
+ /**
+ * Returns the currently-active policy for the extension extension URI, or
+ * null if the URI is not an extension URI, or no policy is currently active
+ * for it.
+ */
+ static WebExtensionPolicy? getByURI(URI uri);
+
+ /**
+ * Returns true if the URI is restricted for any extension.
+ */
+ static boolean isRestrictedURI(URI uri);
+
+ /**
+ * When present, the extension is not yet ready to load URLs. In that case,
+ * this policy object is a stub, and the attribute contains a promise which
+ * resolves to a new, non-stub policy object when the extension is ready.
+ *
+ * This may be used to delay operations, such as loading extension pages,
+ * which depend on extensions being fully initialized.
+ *
+ * Note: This will always be either a Promise<WebExtensionPolicy?> or null,
+ * but the WebIDL grammar does not allow us to specify a nullable Promise
+ * type.
+ *
+ * Note: This could resolve to null when the startup was interrupted.
+ */
+ readonly attribute object? readyPromise;
+
+ /**
+ * Returns true if the given worker script URL matches the background
+ * service worker url declared in the extension manifest.json file.
+ */
+ boolean isManifestBackgroundWorker(DOMString workerURL);
+
+ /**
+ * Get the unique BrowsingContextGroup ID which will be used for toplevel
+ * page loads from this extension.
+ *
+ * This method will raise an exception if called from outside of the parent
+ * process, or if the extension is inactive.
+ */
+ [Throws]
+ readonly attribute unsigned long long browsingContextGroupId;
+};
+
+dictionary WebAccessibleResourceInit {
+ required sequence<MatchGlobOrString> resources;
+ MatchPatternSetOrStringSequence? matches = null;
+ sequence<DOMString>? extension_ids = null;
+};
+
+dictionary WebExtensionInit {
+ required DOMString id;
+
+ required ByteString mozExtensionHostname;
+
+ required DOMString baseURL;
+
+ DOMString name = "";
+
+ DOMString type = "";
+
+ boolean isPrivileged = false;
+
+ boolean ignoreQuarantine = false;
+
+ boolean temporarilyInstalled = false;
+
+ required WebExtensionLocalizeCallback localizeCallback;
+
+ required MatchPatternSetOrStringSequence allowedOrigins;
+
+ sequence<DOMString> permissions = [];
+
+ sequence<WebAccessibleResourceInit> webAccessibleResources = [];
+
+ sequence<WebExtensionContentScriptInit> contentScripts = [];
+
+ // The use of a content script csp is determined by the manifest version.
+ unsigned long manifestVersion = 2;
+ DOMString? extensionPageCSP = null;
+
+ sequence<DOMString>? backgroundScripts = null;
+ DOMString? backgroundWorkerScript = null;
+
+ // Whether the background scripts should be loaded as ES modules.
+ boolean backgroundTypeModule = false;
+
+ Promise<WebExtensionPolicy?> readyPromise;
+};
diff --git a/dom/chrome-webidl/WindowGlobalActors.webidl b/dom/chrome-webidl/WindowGlobalActors.webidl
new file mode 100644
index 0000000000..281f73f47b
--- /dev/null
+++ b/dom/chrome-webidl/WindowGlobalActors.webidl
@@ -0,0 +1,198 @@
+/* -*- Mode: IDL; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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/. */
+
+interface Principal;
+interface URI;
+interface nsIDocShell;
+interface RemoteTab;
+interface nsIDOMProcessParent;
+
+[Exposed=Window, ChromeOnly]
+interface WindowContext {
+ readonly attribute BrowsingContext? browsingContext;
+
+ readonly attribute WindowGlobalChild? windowGlobalChild; // in-process only
+
+ readonly attribute unsigned long long innerWindowId;
+
+ readonly attribute WindowContext? parentWindowContext;
+
+ readonly attribute WindowContext topWindowContext;
+
+ readonly attribute boolean isInProcess;
+
+ // True if this WindowContext is currently frozen in the BFCache.
+ readonly attribute boolean isInBFCache;
+
+ // True if this window has registered a "beforeunload" event handler.
+ readonly attribute boolean hasBeforeUnload;
+
+ // True if the principal of this window is for a local ip address.
+ readonly attribute boolean isLocalIP;
+
+ readonly attribute boolean shouldResistFingerprinting;
+
+ /**
+ * Partially determines whether script execution is allowed in this
+ * BrowsingContext. Script execution will be permitted only if this
+ * attribute is true and script execution is allowed in the owner
+ * BrowsingContext.
+ *
+ * May only be set in the context's owning process.
+ */
+ [SetterThrows] attribute boolean allowJavascript;
+};
+
+// Keep this in sync with nsIContentViewer::PermitUnloadAction.
+enum PermitUnloadAction {
+ "prompt",
+ "dontUnload",
+ "unload",
+};
+
+[Exposed=Window, ChromeOnly]
+interface WindowGlobalParent : WindowContext {
+ readonly attribute boolean isClosed;
+
+ readonly attribute boolean isCurrentGlobal;
+
+ // This should return true if the window is currently visible in its tab.
+ // (A more technically accurate name would be something like
+ // "isActiveInRootNavigable".)
+ readonly attribute boolean isActiveInTab;
+
+ readonly attribute unsigned long long outerWindowId;
+ readonly attribute unsigned long long contentParentId;
+
+ readonly attribute long osPid;
+
+ // A WindowGlobalParent is the root in its process if it has no parent, or its
+ // embedder is in a different process.
+ readonly attribute boolean isProcessRoot;
+
+ // Is the document loaded in this WindowGlobalParent the initial document
+ // implicitly created while "creating a new browsing context".
+ // https://html.spec.whatwg.org/multipage/browsers.html#creating-a-new-browsing-context
+ readonly attribute boolean isInitialDocument;
+
+ readonly attribute FrameLoader? rootFrameLoader; // Embedded (browser) only
+
+ readonly attribute WindowGlobalChild? childActor; // in-process only
+
+ // Checks for any WindowContexts with "beforeunload" listeners in this
+ // WindowGlobal's subtree. If any exist, a "beforeunload" event is
+ // dispatched to them. If any of those request to block the navigation,
+ // displays a prompt to the user. Returns a boolean which resolves to true
+ // if the navigation should be allowed.
+ //
+ // If `timeout` is greater than 0, it is the maximum time (in milliseconds)
+ // we will wait for a child process to respond with a request to block
+ // navigation before proceeding. If the user needs to be prompted, however,
+ // the promise will not resolve until the user has responded, regardless of
+ // the timeout.
+ [NewObject]
+ Promise<boolean> permitUnload(optional PermitUnloadAction action = "prompt",
+ optional unsigned long timeout = 0);
+
+ // Information about the currently loaded document.
+ readonly attribute Principal documentPrincipal;
+ readonly attribute Principal documentStoragePrincipal;
+ readonly attribute Principal? contentBlockingAllowListPrincipal;
+ readonly attribute URI? documentURI;
+ readonly attribute DOMString documentTitle;
+ readonly attribute nsICookieJarSettings? cookieJarSettings;
+
+ // True if the the currently loaded document is in fullscreen.
+ attribute boolean fullscreen;
+
+ // Bit mask containing content blocking events that are recorded in
+ // the document's content blocking log.
+ readonly attribute unsigned long contentBlockingEvents;
+
+ // String containing serialized content blocking log.
+ readonly attribute DOMString contentBlockingLog;
+
+ // DOM Process which this window was loaded in. Will be either InProcessParent
+ // for windows loaded in the parent process, or ContentParent for windows
+ // loaded in the content process.
+ readonly attribute nsIDOMProcessParent? domProcess;
+
+ static WindowGlobalParent? getByInnerWindowId(unsigned long long innerWindowId);
+
+ /**
+ * Get or create the JSWindowActor with the given name.
+ *
+ * See WindowActorOptions from JSWindowActor.webidl for details on how to
+ * customize actor creation.
+ */
+ [Throws]
+ JSWindowActorParent getActor(UTF8String name);
+ JSWindowActorParent? getExistingActor(UTF8String name);
+
+ /**
+ * Renders a region of the frame into an image bitmap.
+ *
+ * @param rect Specify the area of the document to render, in CSS pixels,
+ * relative to the page. If null, the currently visible viewport is rendered.
+ * @param scale The scale to render the window at. Use devicePixelRatio
+ * to have comparable rendering to the OS.
+ * @param backgroundColor The background color to use.
+ * @param resetScrollPosition If true, temporarily resets the scroll position
+ * of the root scroll frame to 0, such that position:fixed elements are drawn
+ * at their initial position. This parameter only takes effect when passing a
+ * non-null rect.
+ *
+ * This API can only be used in the parent process, as content processes
+ * cannot access the rendering of out of process iframes. This API works
+ * with remote and local frames.
+ */
+ [NewObject]
+ Promise<ImageBitmap> drawSnapshot(DOMRect? rect,
+ double scale,
+ UTF8String backgroundColor,
+ optional boolean resetScrollPosition = false);
+
+ // True if any of the windows in the subtree rooted at this window
+ // has active peer connections. If this is called for a non-top-level
+ // context, it always returns false.
+ boolean hasActivePeerConnections();
+};
+
+[Exposed=Window, ChromeOnly]
+interface WindowGlobalChild {
+ readonly attribute boolean isClosed;
+ readonly attribute boolean isInProcess;
+ readonly attribute BrowsingContext browsingContext;
+ readonly attribute WindowContext windowContext;
+
+ readonly attribute boolean isCurrentGlobal;
+
+ readonly attribute unsigned long long innerWindowId;
+ readonly attribute unsigned long long outerWindowId;
+ readonly attribute unsigned long long contentParentId;
+
+ // A WindowGlobalChild is the root in its process if it has no parent, or its
+ // embedder is in a different process.
+ readonly attribute boolean isProcessRoot;
+
+ // Is this WindowGlobalChild same-origin with `window.top`?
+ readonly attribute boolean sameOriginWithTop;
+
+ readonly attribute WindowGlobalParent? parentActor; // in-process only
+
+ static WindowGlobalChild? getByInnerWindowId(unsigned long long innerWIndowId);
+
+ BrowsingContext? findBrowsingContextWithName(DOMString name);
+
+ /**
+ * Get or create the JSWindowActor with the given name.
+ *
+ * See WindowActorOptions from JSWindowActor.webidl for details on how to
+ * customize actor creation.
+ */
+ [Throws]
+ JSWindowActorChild getActor(UTF8String name);
+ JSWindowActorChild? getExistingActor(UTF8String name);
+};
diff --git a/dom/chrome-webidl/XULFrameElement.webidl b/dom/chrome-webidl/XULFrameElement.webidl
new file mode 100644
index 0000000000..53be81a04a
--- /dev/null
+++ b/dom/chrome-webidl/XULFrameElement.webidl
@@ -0,0 +1,31 @@
+/* -*- Mode: IDL; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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/. */
+
+interface nsIDocShell;
+interface nsIWebNavigation;
+interface nsIOpenWindowInfo;
+
+[ChromeOnly,
+ Exposed=Window]
+interface XULFrameElement : XULElement
+{
+ [HTMLConstructor] constructor();
+
+ readonly attribute nsIDocShell? docShell;
+ readonly attribute nsIWebNavigation? webNavigation;
+
+ readonly attribute WindowProxy? contentWindow;
+ readonly attribute Document? contentDocument;
+
+ readonly attribute unsigned long long browserId;
+
+ /**
+ * The optional open window information provided by the window creation code
+ * and used to initialize a new browser.
+ */
+ attribute nsIOpenWindowInfo? openWindowInfo;
+};
+
+XULFrameElement includes MozFrameLoaderOwner;
diff --git a/dom/chrome-webidl/XULMenuElement.webidl b/dom/chrome-webidl/XULMenuElement.webidl
new file mode 100644
index 0000000000..3959c810ba
--- /dev/null
+++ b/dom/chrome-webidl/XULMenuElement.webidl
@@ -0,0 +1,19 @@
+/* -*- Mode: IDL; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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/.
+ */
+
+[ChromeOnly,
+ Exposed=Window]
+interface XULMenuElement : XULElement {
+ [HTMLConstructor] constructor();
+
+ [BinaryName="activeMenuChild"]
+ attribute Element? activeChild;
+
+ boolean handleKeyPress(KeyboardEvent keyEvent);
+
+ readonly attribute boolean openedWithKey;
+
+};
diff --git a/dom/chrome-webidl/XULTextElement.webidl b/dom/chrome-webidl/XULTextElement.webidl
new file mode 100644
index 0000000000..6d75ca8602
--- /dev/null
+++ b/dom/chrome-webidl/XULTextElement.webidl
@@ -0,0 +1,15 @@
+/* -*- Mode: IDL; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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/.
+ */
+
+[ChromeOnly,
+ Exposed=Window]
+interface XULTextElement : XULElement {
+ [HTMLConstructor] constructor();
+
+ attribute boolean disabled;
+ attribute DOMString value;
+ attribute DOMString accessKey;
+};
diff --git a/dom/chrome-webidl/XULTreeElement.webidl b/dom/chrome-webidl/XULTreeElement.webidl
new file mode 100644
index 0000000000..df9dc6a0f9
--- /dev/null
+++ b/dom/chrome-webidl/XULTreeElement.webidl
@@ -0,0 +1,180 @@
+
+/* -*- Mode: IDL; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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/.
+ */
+
+interface MozTreeView;
+
+dictionary TreeCellInfo {
+ long row = 0;
+ TreeColumn? col = null;
+ DOMString childElt = "";
+};
+
+[ChromeOnly,
+ Exposed=Window]
+interface XULTreeElement : XULElement
+{
+ [HTMLConstructor] constructor();
+
+ /**
+ * Obtain the columns.
+ */
+ readonly attribute TreeColumns? columns;
+
+ /**
+ * The view that backs the tree and that supplies it with its data.
+ * It is dynamically settable, either using a view attribute on the
+ * tree tag or by setting this attribute to a new value.
+ */
+ [SetterThrows, NeedsCallerType]
+ attribute MozTreeView? view;
+
+ /**
+ * Whether or not we are currently focused.
+ */
+ attribute boolean focused;
+
+ /**
+ * Obtain the treebody content node
+ */
+ readonly attribute Element? treeBody;
+
+ /**
+ * Obtain the height of a row.
+ */
+ readonly attribute long rowHeight;
+
+ /**
+ * Obtain the width of a row.
+ */
+ readonly attribute long rowWidth;
+
+ /**
+ * Get the pixel position of the horizontal scrollbar.
+ */
+ readonly attribute long horizontalPosition;
+
+ /**
+ * Get the index of the first visible row.
+ */
+ long getFirstVisibleRow();
+
+ /**
+ * Get the index of the last visible row.
+ */
+ long getLastVisibleRow();
+
+ /**
+ * Gets the number of possible visible rows.
+ */
+ long getPageLength();
+
+ /**
+ * Ensures that a row at a given index is visible.
+ */
+ undefined ensureRowIsVisible(long index);
+
+ /**
+ * Ensures that a given cell in the tree is visible.
+ */
+ [Throws]
+ undefined ensureCellIsVisible(long row, TreeColumn? col);
+
+ /**
+ * Scrolls such that the row at index is at the top of the visible view.
+ */
+ undefined scrollToRow(long index);
+
+ /**
+ * Scroll the tree up or down by numLines lines. Positive
+ * values move down in the tree. Prevents scrolling off the
+ * end of the tree.
+ */
+ undefined scrollByLines(long numLines);
+
+ /**
+ * Scroll the tree up or down by numPages pages. A page
+ * is considered to be the amount displayed by the tree.
+ * Positive values move down in the tree. Prevents scrolling
+ * off the end of the tree.
+ */
+ undefined scrollByPages(long numPages);
+
+ /**
+ * Invalidation methods for fine-grained painting control.
+ */
+ undefined invalidate();
+ undefined invalidateColumn(TreeColumn? col);
+ undefined invalidateRow(long index);
+ undefined invalidateCell(long row, TreeColumn? col);
+ undefined invalidateRange(long startIndex, long endIndex);
+
+ /**
+ * A hit test that can tell you what row the mouse is over.
+ * returns -1 for invalid mouse coordinates.
+ *
+ * The coordinate system is the client coordinate system for the
+ * document this tree lives in, and the units are CSS pixels.
+ */
+ long getRowAt(long x, long y);
+
+ /**
+ * A hit test that can tell you what cell the mouse is over.
+ * TreeCellInfo.row is the row index hit, returns -1 for invalid mouse
+ * coordinates. TreeCellInfo.col is the column hit.
+ * TreeCellInfo.childElt is the pseudoelement hit: this can have values of
+ * "cell", "twisty", "image", and "text".
+ *
+ * The coordinate system is the client coordinate system for the
+ * document this tree lives in, and the units are CSS pixels.
+ */
+ [Throws]
+ TreeCellInfo getCellAt(long x, long y);
+
+ /**
+ * Find the coordinates of an element within a specific cell.
+ */
+ [Throws]
+ DOMRect? getCoordsForCellItem(long row, TreeColumn col, DOMString element);
+
+ /**
+ * Determine if the text of a cell is being cropped or not.
+ */
+ [Throws]
+ boolean isCellCropped(long row, TreeColumn? col);
+
+ /**
+ * The view is responsible for calling these notification methods when
+ * rows are added or removed. Index is the position at which the new
+ * rows were added or at which rows were removed. For
+ * non-contiguous additions/removals, this method should be called multiple times.
+ */
+ undefined rowCountChanged(long index, long count);
+
+ /**
+ * Notify the tree that the view is about to perform a batch
+ * update, that is, add, remove or invalidate several rows at once.
+ * This must be followed by calling endUpdateBatch(), otherwise the tree
+ * will get out of sync.
+ */
+ undefined beginUpdateBatch();
+
+ /**
+ * Notify the tree that the view has completed a batch update.
+ */
+ undefined endUpdateBatch();
+
+ /**
+ * Called on a theme switch to flush out the tree's style and image caches.
+ */
+ undefined clearStyleAndImageCaches();
+
+ /**
+ * Remove an image source from the image cache to allow its invalidation.
+ */
+ [Throws]
+ undefined removeImageCacheEntry(long row, TreeColumn col);
+};
diff --git a/dom/chrome-webidl/moz.build b/dom/chrome-webidl/moz.build
new file mode 100644
index 0000000000..d65c496b03
--- /dev/null
+++ b/dom/chrome-webidl/moz.build
@@ -0,0 +1,108 @@
+# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*-
+# vim: set filetype=python:
+# 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/.
+
+with Files("**"):
+ BUG_COMPONENT = ("Core", "DOM: Core & HTML")
+
+with Files("ChannelWrapper.webidl"):
+ BUG_COMPONENT = ("WebExtensions", "Request Handling")
+
+with Files("Flex.webidl"):
+ BUG_COMPONENT = ("Core", "CSS Parsing and Computation")
+
+with Files("HeapSnapshot.webidl"):
+ BUG_COMPONENT = ("DevTools", "Memory")
+
+with Files("InspectorUtils.webidl"):
+ BUG_COMPONENT = ("DevTools", "Inspector")
+
+with Files("MatchGlob.webidl"):
+ BUG_COMPONENT = ("WebExtensions", "General")
+
+with Files("MatchPattern.webidl"):
+ BUG_COMPONENT = ("WebExtensions", "General")
+
+with Files("WebExtension*.webidl"):
+ BUG_COMPONENT = ("WebExtensions", "General")
+
+with Files("Glean*.webidl"):
+ BUG_COMPONENT = ("Toolkit", "Telemetry")
+
+with Files("IOUtils.webidl"):
+ BUG_COMPONENT = ("Toolkit", "IOUtils and PathUtils")
+
+with Files("PathUtils.webidl"):
+ BUG_COMPONENT = ("Toolkit", "IOUtils and PathUtils")
+
+PREPROCESSED_WEBIDL_FILES = [
+ "ChromeUtils.webidl",
+ "IOUtils.webidl",
+]
+
+WEBIDL_FILES = [
+ "BrowserSessionStore.webidl",
+ "BrowsingContext.webidl",
+ "ChannelWrapper.webidl",
+ "ClonedErrorHolder.webidl",
+ "DebuggerNotification.webidl",
+ "DebuggerNotificationObserver.webidl",
+ "DebuggerUtils.webidl",
+ "DocumentL10n.webidl",
+ "DOMCollectedFrames.webidl",
+ "DominatorTree.webidl",
+ "Flex.webidl",
+ "Fluent.webidl",
+ "FrameLoader.webidl",
+ "HeapSnapshot.webidl",
+ "ImageText.webidl",
+ "InspectorUtils.webidl",
+ "IteratorResult.webidl",
+ "JSActor.webidl",
+ "JSProcessActor.webidl",
+ "JSWindowActor.webidl",
+ "L10nOverlays.webidl",
+ "L10nRegistry.webidl",
+ "MatchGlob.webidl",
+ "MatchPattern.webidl",
+ "MediaController.webidl",
+ "MessageManager.webidl",
+ "MozDocumentObserver.webidl",
+ "MozSharedMap.webidl",
+ "MozStorageAsyncStatementParams.webidl",
+ "MozStorageStatementParams.webidl",
+ "MozStorageStatementRow.webidl",
+ "NetDashboard.webidl",
+ "PathUtils.webidl",
+ "PrecompiledScript.webidl",
+ "PromiseDebugging.webidl",
+ "SessionStoreUtils.webidl",
+ "StructuredCloneHolder.webidl",
+ "TelemetryStopwatch.webidl",
+ "UserInteraction.webidl",
+ "WebExtensionContentScript.webidl",
+ "WebExtensionPolicy.webidl",
+ "WindowGlobalActors.webidl",
+ "XULFrameElement.webidl",
+ "XULMenuElement.webidl",
+ "XULTextElement.webidl",
+ "XULTreeElement.webidl",
+]
+
+if CONFIG["MOZ_BUILD_APP"] != "mobile/android":
+ WEBIDL_FILES += [
+ "UniFFI.webidl",
+ ]
+
+if CONFIG["MOZ_PLACES"]:
+ WEBIDL_FILES += [
+ "PlacesEvent.webidl",
+ "PlacesObservers.webidl",
+ ]
+
+WEBIDL_FILES += [
+ "Glean.webidl",
+ "GleanPings.webidl",
+]