diff options
Diffstat (limited to 'dom/chrome-webidl')
54 files changed, 8245 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..7e202ee445 --- /dev/null +++ b/dom/chrome-webidl/WindowGlobalActors.webidl @@ -0,0 +1,193 @@ +/* -*- 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; + + 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", +] |