diff options
Diffstat (limited to 'dom/webidl/Window.webidl')
| -rw-r--r-- | dom/webidl/Window.webidl | 845 |
1 files changed, 845 insertions, 0 deletions
diff --git a/dom/webidl/Window.webidl b/dom/webidl/Window.webidl new file mode 100644 index 0000000000..1bee8ab8de --- /dev/null +++ b/dom/webidl/Window.webidl @@ -0,0 +1,845 @@ +/* -*- 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/. + * + * The origin of this IDL file is: + * http://www.whatwg.org/specs/web-apps/current-work/ + * https://dvcs.w3.org/hg/editing/raw-file/tip/editing.html + * https://dvcs.w3.org/hg/IndexedDB/raw-file/tip/Overview.html + * http://dev.w3.org/csswg/cssom/ + * http://dev.w3.org/csswg/cssom-view/ + * https://dvcs.w3.org/hg/webperf/raw-file/tip/specs/RequestAnimationFrame/Overview.html + * https://dvcs.w3.org/hg/webperf/raw-file/tip/specs/NavigationTiming/Overview.html + * https://dvcs.w3.org/hg/webcrypto-api/raw-file/tip/spec/Overview.html + * http://dvcs.w3.org/hg/speech-api/raw-file/tip/speechapi.html + * https://w3c.github.io/webappsec-secure-contexts/#monkey-patching-global-object + * https://w3c.github.io/requestidlecallback/ + * https://drafts.css-houdini.org/css-paint-api-1/#dom-window-paintworklet + * https://wicg.github.io/visual-viewport/#the-visualviewport-interface + */ + +interface Principal; +interface nsIBrowserDOMWindow; +interface XULControllers; +interface nsIDOMWindowUtils; +interface nsIPrintSettings; + +// http://www.whatwg.org/specs/web-apps/current-work/ +[Global, LegacyUnenumerableNamedProperties, NeedResolve, + Exposed=Window, + InstrumentedProps=(AbsoluteOrientationSensor, + Accelerometer, + Atomics, + AudioParamMap, + AudioWorklet, + AudioWorkletNode, + BackgroundFetchManager, + BackgroundFetchRecord, + BackgroundFetchRegistration, + BeforeInstallPromptEvent, + Bluetooth, + BluetoothCharacteristicProperties, + BluetoothDevice, + BluetoothRemoteGATTCharacteristic, + BluetoothRemoteGATTDescriptor, + BluetoothRemoteGATTServer, + BluetoothRemoteGATTService, + BluetoothUUID, + CanvasCaptureMediaStreamTrack, + chrome, + clientInformation, + ClipboardItem, + CSSImageValue, + CSSKeywordValue, + CSSMathInvert, + CSSMathMax, + CSSMathMin, + CSSMathNegate, + CSSMathProduct, + CSSMathSum, + CSSMathValue, + CSSMatrixComponent, + CSSNumericArray, + CSSNumericValue, + CSSPerspective, + CSSPositionValue, + CSSRotate, + CSSScale, + CSSSkew, + CSSSkewX, + CSSSkewY, + CSSStyleValue, + CSSTransformComponent, + CSSTransformValue, + CSSTranslate, + CSSUnitValue, + CSSUnparsedValue, + CSSVariableReferenceValue, + defaultStatus, + // Unfortunately, our telemetry histogram name generator + // (the one that generates TelemetryHistogramEnums.h) can't + // handle two DOM methods with names that only differ in + // case, because it forces everything to uppercase. + //defaultstatus, + DeviceMotionEventAcceleration, + DeviceMotionEventRotationRate, + DOMError, + EnterPictureInPictureEvent, + External, + FederatedCredential, + Gyroscope, + HTMLContentElement, + HTMLDialogElement, + HTMLShadowElement, + ImageCapture, + InputDeviceCapabilities, + InputDeviceInfo, + Keyboard, + KeyboardLayoutMap, + LinearAccelerationSensor, + Lock, + LockManager, + MediaMetadata, + MediaSession, + MediaSettingsRange, + MIDIAccess, + MIDIConnectionEvent, + MIDIInput, + MIDIInputMap, + MIDIMessageEvent, + MIDIOutput, + MIDIOutputMap, + MIDIPort, + NavigationPreloadManager, + NetworkInformation, + offscreenBuffering, + OffscreenCanvas, + OffscreenCanvasRenderingContext2D, + onbeforeinstallprompt, + oncancel, + onmousewheel, + onsearch, + onselectionchange, + openDatabase, + OrientationSensor, + OverconstrainedError, + PasswordCredential, + PaymentAddress, + PaymentInstruments, + PaymentManager, + PaymentMethodChangeEvent, + PaymentRequest, + PaymentRequestUpdateEvent, + PaymentResponse, + PerformanceEventTiming, + PerformanceLongTaskTiming, + PerformancePaintTiming, + PhotoCapabilities, + PictureInPictureWindow, + Presentation, + PresentationAvailability, + PresentationConnection, + PresentationConnectionAvailableEvent, + PresentationConnectionCloseEvent, + PresentationConnectionList, + PresentationReceiver, + PresentationRequest, + RelativeOrientationSensor, + RemotePlayback, + ReportingObserver, + RTCDtlsTransport, + RTCError, + RTCErrorEvent, + RTCIceTransport, + RTCSctpTransport, + Sensor, + SensorErrorEvent, + SharedArrayBuffer, + styleMedia, + StylePropertyMap, + StylePropertyMapReadOnly, + SVGDiscardElement, + SyncManager, + TaskAttributionTiming, + TextDecoderStream, + TextEncoderStream, + TextEvent, + Touch, + TouchEvent, + TouchList, + TransformStream, + USB, + USBAlternateInterface, + USBConfiguration, + USBConnectionEvent, + USBDevice, + USBEndpoint, + USBInterface, + USBInTransferResult, + USBIsochronousInTransferPacket, + USBIsochronousInTransferResult, + USBIsochronousOutTransferPacket, + USBIsochronousOutTransferResult, + USBOutTransferResult, + UserActivation, + visualViewport, + webkitCancelAnimationFrame, + webkitMediaStream, + WebKitMutationObserver, + webkitRequestAnimationFrame, + webkitRequestFileSystem, + webkitResolveLocalFileSystemURL, + webkitRTCPeerConnection, + webkitSpeechGrammar, + webkitSpeechGrammarList, + webkitSpeechRecognition, + webkitSpeechRecognitionError, + webkitSpeechRecognitionEvent, + webkitStorageInfo, + Worklet, + WritableStream)] +/*sealed*/ interface Window : EventTarget { + // the current browsing context + [LegacyUnforgeable, Constant, StoreInSlot, + CrossOriginReadable] readonly attribute WindowProxy window; + [Replaceable, Constant, StoreInSlot, + CrossOriginReadable] readonly attribute WindowProxy self; + [LegacyUnforgeable, StoreInSlot, Pure] readonly attribute Document? document; + [Throws] attribute DOMString name; + [PutForwards=href, LegacyUnforgeable, CrossOriginReadable, + CrossOriginWritable] readonly attribute Location location; + [Throws] readonly attribute History history; + readonly attribute CustomElementRegistry customElements; + [Replaceable, Throws] readonly attribute BarProp locationbar; + [Replaceable, Throws] readonly attribute BarProp menubar; + [Replaceable, Throws] readonly attribute BarProp personalbar; + [Replaceable, Throws] readonly attribute BarProp scrollbars; + [Replaceable, Throws] readonly attribute BarProp statusbar; + [Replaceable, Throws] readonly attribute BarProp toolbar; + [Throws] attribute DOMString status; + [Throws, CrossOriginCallable, NeedsCallerType] undefined close(); + [Throws, CrossOriginReadable] readonly attribute boolean closed; + [Throws] undefined stop(); + [Throws, CrossOriginCallable, NeedsCallerType] undefined focus(); + [Throws, CrossOriginCallable, NeedsCallerType] undefined blur(); + [Replaceable, Pref="dom.window.event.enabled"] readonly attribute (Event or undefined) event; + + // other browsing contexts + [Replaceable, Throws, CrossOriginReadable] readonly attribute WindowProxy frames; + [Replaceable, CrossOriginReadable] readonly attribute unsigned long length; + //[Unforgeable, Throws, CrossOriginReadable] readonly attribute WindowProxy top; + [LegacyUnforgeable, Throws, CrossOriginReadable] readonly attribute WindowProxy? top; + [Throws, CrossOriginReadable] attribute any opener; + //[Throws] readonly attribute WindowProxy parent; + [Replaceable, Throws, CrossOriginReadable] readonly attribute WindowProxy? parent; + [Throws, NeedsSubjectPrincipal] readonly attribute Element? frameElement; + //[Throws] WindowProxy? open(optional USVString url = "about:blank", optional DOMString target = "_blank", [TreatNullAs=EmptyString] optional DOMString features = ""); + [Throws] WindowProxy? open(optional USVString url = "", optional DOMString target = "", optional [LegacyNullToEmptyString] DOMString features = ""); + getter object (DOMString name); + + // the user agent + readonly attribute Navigator navigator; + [Pref="dom.window.clientinformation.enabled", BinaryName="Navigator"] + readonly attribute Navigator clientInformation; + + [Replaceable] readonly attribute External external; + + // user prompts + [Throws, NeedsSubjectPrincipal] undefined alert(); + [Throws, NeedsSubjectPrincipal] undefined alert(DOMString message); + [Throws, NeedsSubjectPrincipal] boolean confirm(optional DOMString message = ""); + [Throws, NeedsSubjectPrincipal] DOMString? prompt(optional DOMString message = "", optional DOMString default = ""); + [Throws, Pref="dom.enable_window_print"] + undefined print(); + + // Returns a window that you can use for a print preview. + // + // This may reuse an existing window if this window is already a print + // preview document, or if you pass a docshell explicitly. + [Throws, Func="nsContentUtils::IsCallerChromeOrFuzzingEnabled"] + WindowProxy? printPreview(optional nsIPrintSettings? settings = null, + optional nsIWebProgressListener? listener = null, + optional nsIDocShell? docShellToPreviewInto = null); + + [Throws, CrossOriginCallable, NeedsSubjectPrincipal, + BinaryName="postMessageMoz"] + undefined postMessage(any message, DOMString targetOrigin, optional sequence<object> transfer = []); + [Throws, CrossOriginCallable, NeedsSubjectPrincipal, + BinaryName="postMessageMoz"] + undefined postMessage(any message, optional WindowPostMessageOptions options = {}); + + // also has obsolete members +}; +Window includes GlobalEventHandlers; +Window includes WindowEventHandlers; + +// http://www.whatwg.org/specs/web-apps/current-work/ +interface mixin WindowSessionStorage { + //[Throws] readonly attribute Storage sessionStorage; + [Throws] readonly attribute Storage? sessionStorage; +}; +Window includes WindowSessionStorage; + +// http://www.whatwg.org/specs/web-apps/current-work/ +interface mixin WindowLocalStorage { + [Throws] readonly attribute Storage? localStorage; +}; +Window includes WindowLocalStorage; + +// http://www.whatwg.org/specs/web-apps/current-work/ +partial interface Window { + undefined captureEvents(); + undefined releaseEvents(); +}; + +// https://dvcs.w3.org/hg/editing/raw-file/tip/editing.html +partial interface Window { + //[Throws] Selection getSelection(); + [Throws] Selection? getSelection(); +}; + +// https://drafts.csswg.org/cssom/#extensions-to-the-window-interface +partial interface Window { + //[NewObject, Throws] CSSStyleDeclaration getComputedStyle(Element elt, optional DOMString? pseudoElt = ""); + [NewObject, Throws] CSSStyleDeclaration? getComputedStyle(Element elt, optional DOMString? pseudoElt = ""); +}; + +// http://dev.w3.org/csswg/cssom-view/ +enum ScrollBehavior { "auto", "instant", "smooth" }; + +dictionary ScrollOptions { + ScrollBehavior behavior = "auto"; +}; + +dictionary ScrollToOptions : ScrollOptions { + unrestricted double left; + unrestricted double top; +}; + +partial interface Window { + //[Throws, NewObject, NeedsCallerType] MediaQueryList matchMedia(DOMString query); + [Throws, NewObject, NeedsCallerType] MediaQueryList? matchMedia(UTF8String query); + // Per spec, screen is SameObject, but we don't actually guarantee that given + // nsGlobalWindow::Cleanup. :( + //[SameObject, Replaceable, Throws] readonly attribute Screen screen; + [Replaceable, Throws] readonly attribute Screen screen; + + // browsing context + //[Throws] undefined moveTo(double x, double y); + //[Throws] undefined moveBy(double x, double y); + //[Throws] undefined resizeTo(double x, double y); + //[Throws] undefined resizeBy(double x, double y); + [Throws, NeedsCallerType] undefined moveTo(long x, long y); + [Throws, NeedsCallerType] undefined moveBy(long x, long y); + [Throws, NeedsCallerType] undefined resizeTo(long x, long y); + [Throws, NeedsCallerType] undefined resizeBy(long x, long y); + + // viewport + // These are writable because we allow chrome to write them. And they need + // to use 'any' as the type, because non-chrome writing them needs to act + // like a [Replaceable] attribute would, which needs the original JS value. + // TODO: These can be updated to follow the spec exactly a while after we + // enable dom.window_position_size_properties_replaceable.enabled=true + //[Replaceable, Throws] readonly attribute double innerWidth; + //[Replaceable, Throws] readonly attribute double innerHeight; + [Throws, NeedsCallerType] attribute any innerWidth; + [Throws, NeedsCallerType] attribute any innerHeight; + + // viewport scrolling + undefined scroll(unrestricted double x, unrestricted double y); + undefined scroll(optional ScrollToOptions options = {}); + undefined scrollTo(unrestricted double x, unrestricted double y); + undefined scrollTo(optional ScrollToOptions options = {}); + undefined scrollBy(unrestricted double x, unrestricted double y); + undefined scrollBy(optional ScrollToOptions options = {}); + // mozScrollSnap is used by chrome to perform scroll snapping after the + // user performs actions that may affect scroll position + // mozScrollSnap is deprecated, to be replaced by a web accessible API, such + // as an extension to the ScrollOptions dictionary. See bug 1137937. + [ChromeOnly] undefined mozScrollSnap(); + // The four properties below are double per spec at the moment, but whether + // that will continue is unclear. + [Replaceable, Throws] readonly attribute double scrollX; + [Replaceable, Throws] readonly attribute double pageXOffset; + [Replaceable, Throws] readonly attribute double scrollY; + [Replaceable, Throws] readonly attribute double pageYOffset; + + // Aliases for screenX / screenY. + [Replaceable, Throws, NeedsCallerType] readonly attribute double screenLeft; + [Replaceable, Throws, NeedsCallerType] readonly attribute double screenTop; + + // client + // These are writable because we allow chrome to write them. And they need + // to use 'any' as the type, because non-chrome writing them needs to act + // like a [Replaceable] attribute would, which needs the original JS value. + // TODO: These can be updated to follow the spec exactly a while after we + // enable dom.window_position_size_properties_replaceable.enabled=true + //[Replaceable, Throws] readonly attribute double screenX; + //[Replaceable, Throws] readonly attribute double screenY; + //[Replaceable, Throws] readonly attribute double outerWidth; + //[Replaceable, Throws] readonly attribute double outerHeight; + [Throws, NeedsCallerType] attribute any screenX; + [Throws, NeedsCallerType] attribute any screenY; + [Throws, NeedsCallerType] attribute any outerWidth; + [Throws, NeedsCallerType] attribute any outerHeight; +}; + +// https://html.spec.whatwg.org/multipage/imagebitmap-and-animations.html#animation-frames +Window includes AnimationFrameProvider; + +// https://dvcs.w3.org/hg/webperf/raw-file/tip/specs/NavigationTiming/Overview.html +partial interface Window { + [Replaceable, Pure, StoreInSlot] readonly attribute Performance? performance; +}; + +// https://dvcs.w3.org/hg/webcrypto-api/raw-file/tip/spec/Overview.html +Window includes GlobalCrypto; + +dictionary SizeToContentConstraints { + long maxWidth = 0; + long maxHeight = 0; + long prefWidth = 0; +}; + +#ifdef MOZ_WEBSPEECH +// http://dvcs.w3.org/hg/speech-api/raw-file/tip/speechapi.html +interface mixin SpeechSynthesisGetter { + [Throws, Pref="media.webspeech.synth.enabled"] readonly attribute SpeechSynthesis speechSynthesis; +}; + +Window includes SpeechSynthesisGetter; +#endif + +// Mozilla-specific stuff +partial interface Window { + //[NewObject, Throws] CSSStyleDeclaration getDefaultComputedStyle(Element elt, optional DOMString pseudoElt = ""); + [NewObject, Throws] CSSStyleDeclaration? getDefaultComputedStyle(Element elt, optional DOMString pseudoElt = ""); + + // Mozilla extensions + /** + * Method for scrolling this window by a number of lines. + */ + undefined scrollByLines(long numLines, optional ScrollOptions options = {}); + + /** + * Method for scrolling this window by a number of pages. + */ + undefined scrollByPages(long numPages, optional ScrollOptions options = {}); + + /** + * Method for sizing this window to the content in the window. + */ + [Throws, NeedsCallerType] undefined sizeToContent(); + /** + * Chrome-only method for sizing to content with a maximum-size constraint on + * either (or both) directions. + */ + [Throws, ChromeOnly] undefined sizeToContentConstrained(optional SizeToContentConstraints constraints = {}); + + // XXX Shouldn't this be in nsIDOMChromeWindow? + [ChromeOnly, Replaceable, Throws] readonly attribute XULControllers controllers; + + [ChromeOnly, Throws] readonly attribute Element? realFrameElement; + + [ChromeOnly] readonly attribute nsIDocShell? docShell; + + [ChromeOnly, Constant, CrossOriginReadable, BinaryName="getBrowsingContext"] + readonly attribute BrowsingContext browsingContext; + + [Throws, NeedsCallerType] + readonly attribute float mozInnerScreenX; + [Throws, NeedsCallerType] + readonly attribute float mozInnerScreenY; + [Replaceable, Throws, NeedsCallerType] + readonly attribute double devicePixelRatio; + + // Allows chrome code to convert desktop pixels to device pixels and vice + // versa. Useful for interacting with the screen manager. + [ChromeOnly, Throws] + readonly attribute double desktopToDeviceScale; + + // Returns the amount of CSS pixels relative to this window we're allowed to + // go out of the screen. This is needed so that SessionRestore is able to + // position windows that use client-side decorations correctly, but still + // pull mispositioned windows into the screen. + [ChromeOnly] + readonly attribute double screenEdgeSlopX; + [ChromeOnly] + readonly attribute double screenEdgeSlopY; + + + /* The maximum offset that the window can be scrolled to + (i.e., the document width/height minus the scrollport width/height) */ + [ChromeOnly, Throws] readonly attribute long scrollMinX; + [ChromeOnly, Throws] readonly attribute long scrollMinY; + [Replaceable, Throws] readonly attribute long scrollMaxX; + [Replaceable, Throws] readonly attribute long scrollMaxY; + + [Throws] attribute boolean fullScreen; + + // XXX Should this be in nsIDOMChromeWindow? + undefined updateCommands(DOMString action, + optional Selection? sel = null, + optional short reason = 0); + + /* Find in page. + * @param str: the search pattern + * @param caseSensitive: is the search caseSensitive + * @param backwards: should we search backwards + * @param wrapAround: should we wrap the search + * @param wholeWord: should we search only for whole words + * @param searchInFrames: should we search through all frames + * @param showDialog: should we show the Find dialog + */ + [Throws] boolean find(optional DOMString str = "", + optional boolean caseSensitive = false, + optional boolean backwards = false, + optional boolean wrapAround = false, + optional boolean wholeWord = false, + optional boolean searchInFrames = false, + optional boolean showDialog = false); + + attribute EventHandler ondevicemotion; + attribute EventHandler ondeviceorientation; + attribute EventHandler ondeviceorientationabsolute; + [Pref="device.sensors.proximity.enabled"] + attribute EventHandler onuserproximity; + [Pref="device.sensors.ambientLight.enabled"] + attribute EventHandler ondevicelight; + + undefined dump(DOMString str); + + /** + * This method is here for backwards compatibility with 4.x only, + * its implementation is a no-op + */ + undefined setResizable(boolean resizable); + + /** + * This is the scriptable version of + * nsPIDOMWindow::OpenDialog() that takes 3 optional + * arguments, plus any additional arguments are passed on as + * arguments on the dialog's window object (window.arguments). + */ + [Throws, ChromeOnly] WindowProxy? openDialog(optional DOMString url = "", + optional DOMString name = "", + optional DOMString options = "", + any... extraArguments); + + [Func="nsGlobalWindowInner::ContentPropertyEnabled", + NonEnumerable, Replaceable, Throws, NeedsCallerType] + readonly attribute object? content; + + [Throws, ChromeOnly] any getInterface(any iid); + + /** + * Same as nsIDOMWindow.windowRoot, useful for event listener targeting. + */ + [ChromeOnly, Throws] + readonly attribute WindowRoot? windowRoot; + + /** + * ChromeOnly method to determine if a particular window should see console + * reports from service workers of the given scope. + */ + [ChromeOnly] + boolean shouldReportForServiceWorkerScope(USVString aScope); + + /** + * InstallTrigger is used for extension installs. Ideally it would + * be something like a WebIDL namespace, but we don't support + * JS-implemented static things yet. See bug 863952. + */ + [Replaceable, Deprecated="InstallTriggerDeprecated", Pref="extensions.InstallTrigger.enabled"] + readonly attribute InstallTriggerImpl? InstallTrigger; + + /** + * Get the nsIDOMWindowUtils for this window. + */ + [Constant, Throws, ChromeOnly] + readonly attribute nsIDOMWindowUtils windowUtils; + + [Pure, ChromeOnly] + readonly attribute WindowGlobalChild? windowGlobalChild; + + /** + * The principal of the client source of the window. This is supposed to be + * used for the service worker. + * + * This is used for APIs like https://w3c.github.io/push-api/ that extend + * ServiceWorkerRegistration and therefore need to operate consistently with + * ServiceWorkers and its Clients API. The client principal is the appropriate + * principal to pass to all nsIServiceWorkerManager APIs. + * + * Note that the client principal will be different from the node principal of + * the window's document if the window is in a third-party context when dFPI + * is enabled. In this case, the client principal will be the partitioned + * principal to support the service worker partitioning. + */ + [ChromeOnly] + readonly attribute Principal? clientPrincipal; + + /** + * Whether the chrome window is currently in a full screen transition. This + * flag is updated from FullscreenTransitionTask. + * Always set to false for non-chrome windows. + */ + [ChromeOnly] + readonly attribute boolean isInFullScreenTransition; +}; + +Window includes TouchEventHandlers; + +Window includes OnErrorEventHandlerForWindow; + +#if defined(MOZ_WIDGET_ANDROID) +// https://compat.spec.whatwg.org/#windoworientation-interface +partial interface Window { + [NeedsCallerType] + readonly attribute short orientation; + attribute EventHandler onorientationchange; +}; +#endif + +// Mozilla extension +// Sidebar is deprecated and it will be removed in the next cycles. See bug 1640138. +partial interface Window { + [Replaceable, UseCounter, Pref="dom.window.sidebar.enabled"] + readonly attribute (External or WindowProxy) sidebar; +}; + +[MOZ_CAN_RUN_SCRIPT_BOUNDARY] +callback PromiseDocumentFlushedCallback = any (); + +// Mozilla extensions for Chrome windows. +partial interface Window { + // The STATE_* constants need to match the corresponding enum in nsGlobalWindow.cpp. + [Func="nsGlobalWindowInner::IsPrivilegedChromeWindow"] + const unsigned short STATE_MAXIMIZED = 1; + [Func="nsGlobalWindowInner::IsPrivilegedChromeWindow"] + const unsigned short STATE_MINIMIZED = 2; + [Func="nsGlobalWindowInner::IsPrivilegedChromeWindow"] + const unsigned short STATE_NORMAL = 3; + [Func="nsGlobalWindowInner::IsPrivilegedChromeWindow"] + const unsigned short STATE_FULLSCREEN = 4; + + [Func="nsGlobalWindowInner::IsPrivilegedChromeWindow"] + readonly attribute unsigned short windowState; + + [Func="nsGlobalWindowInner::IsPrivilegedChromeWindow"] + readonly attribute boolean isFullyOccluded; + + /** + * browserDOMWindow provides access to yet another layer of + * utility functions implemented by chrome script. It will be null + * for DOMWindows not corresponding to browsers. + */ + [Throws, Func="nsGlobalWindowInner::IsPrivilegedChromeWindow"] + attribute nsIBrowserDOMWindow? browserDOMWindow; + + [Throws, Func="nsGlobalWindowInner::IsPrivilegedChromeWindow"] + undefined getAttention(); + + [Throws, Func="nsGlobalWindowInner::IsPrivilegedChromeWindow"] + undefined getAttentionWithCycleCount(long aCycleCount); + + [Throws, Func="nsGlobalWindowInner::IsPrivilegedChromeWindow"] + undefined setCursor(UTF8String cursor); + + [Func="nsGlobalWindowInner::IsPrivilegedChromeWindow"] + undefined maximize(); + [Func="nsGlobalWindowInner::IsPrivilegedChromeWindow"] + undefined minimize(); + [Func="nsGlobalWindowInner::IsPrivilegedChromeWindow"] + undefined restore(); + [Func="nsGlobalWindowInner::IsPrivilegedChromeWindow"] + DOMString getWorkspaceID(); + [Func="nsGlobalWindowInner::IsPrivilegedChromeWindow"] + undefined moveToWorkspace(DOMString workspaceID); + + /** + * Notify a default button is loaded on a dialog or a wizard. + * defaultButton is the default button. + */ + [Throws, Func="nsGlobalWindowInner::IsPrivilegedChromeWindow"] + undefined notifyDefaultButtonLoaded(Element defaultButton); + + [Func="nsGlobalWindowInner::IsPrivilegedChromeWindow"] + readonly attribute ChromeMessageBroadcaster messageManager; + + /** + * Returns the message manager identified by the given group name that + * manages all frame loaders belonging to that group. + */ + [Func="nsGlobalWindowInner::IsPrivilegedChromeWindow"] + ChromeMessageBroadcaster getGroupMessageManager(DOMString aGroup); + + /** + * Calls the given function as soon as a style or layout flush for the + * top-level document is not necessary, and returns a Promise which + * resolves to the callback's return value after it executes. + * + * In the event that the window goes away before a flush can occur, the + * callback will still be called and the Promise resolved as the window + * tears itself down. + * + * The callback _must not modify the DOM for any window in any way_. If it + * does, after finishing executing, the Promise returned by + * promiseDocumentFlushed will reject with + * NS_ERROR_DOM_NO_MODIFICATION_ALLOWED_ERR. + * + * Note that the callback can be called either synchronously or asynchronously + * depending on whether or not flushes are pending: + * + * The callback will be called synchronously when calling + * promiseDocumentFlushed when NO flushes are already pending. This is + * to ensure that no script has a chance to dirty the DOM before the callback + * is called. + * + * The callback will be called asynchronously if a flush is pending. + * + * The expected execution order is that all pending callbacks will + * be fired first (and in the order that they were queued) and then the + * Promise resolution handlers will all be invoked later on during the + * next microtask checkpoint. + * + * Using window.top.promiseDocumentFlushed in combination with a callback + * that is querying items in a window that might be swapped out via + * nsFrameLoader::SwapWithOtherLoader is highly discouraged. For example: + * + * let result = await window.top.promiseDocumentFlushed(() => { + * return window.document.body.getBoundingClientRect(); + * }); + * + * If "window" might get swapped out via nsFrameLoader::SwapWithOtherLoader + * at any time, then the callback might get called when the new host window + * will still incur layout flushes, since it's only the original host window + * that's being monitored via window.top.promiseDocumentFlushed. + * + * See bug 1519407 for further details. + * + * promiseDocumentFlushed does not support re-entrancy - so calling it from + * within a promiseDocumentFlushed callback will result in the inner call + * throwing an NS_ERROR_FAILURE exception, and the outer Promise rejecting + * with that exception. + * + * The callback function *must not make any changes which would require + * a style or layout flush*. + * + * Also throws NS_ERROR_FAILURE if the window is not in a state where flushes + * can be waited for (for example, the PresShell has not yet been created). + * + * @param {function} callback + * @returns {Promise} + */ + [NewObject, Func="nsGlobalWindowInner::IsPrivilegedChromeWindow"] + Promise<any> promiseDocumentFlushed(PromiseDocumentFlushedCallback callback); + + [Func="IsChromeOrUAWidget"] + readonly attribute boolean isChromeWindow; + + [ChromeOnly] + readonly attribute GleanImpl Glean; + [ChromeOnly] + readonly attribute GleanPingsImpl GleanPings; +}; + +partial interface Window { + [Pref="dom.vr.enabled"] + attribute EventHandler onvrdisplayconnect; + [Pref="dom.vr.enabled"] + attribute EventHandler onvrdisplaydisconnect; + [Pref="dom.vr.enabled"] + attribute EventHandler onvrdisplayactivate; + [Pref="dom.vr.enabled"] + attribute EventHandler onvrdisplaydeactivate; + [Pref="dom.vr.enabled"] + attribute EventHandler onvrdisplaypresentchange; +}; + +#ifndef RELEASE_OR_BETA +// https://drafts.css-houdini.org/css-paint-api-1/#dom-window-paintworklet +partial interface Window { + [Pref="dom.paintWorklet.enabled", Throws] + readonly attribute Worklet paintWorklet; +}; +#endif + +Window includes WindowOrWorkerGlobalScope; + +partial interface Window { + [Throws, Func="nsGlobalWindowInner::IsRequestIdleCallbackEnabled"] + unsigned long requestIdleCallback(IdleRequestCallback callback, + optional IdleRequestOptions options = {}); + [Func="nsGlobalWindowInner::IsRequestIdleCallbackEnabled"] + undefined cancelIdleCallback(unsigned long handle); +}; + +dictionary IdleRequestOptions { + unsigned long timeout; +}; + +callback IdleRequestCallback = undefined (IdleDeadline deadline); + +partial interface Window { + /** + * Returns a list of locales that the internationalization components + * should be localized to. + * + * The function name refers to Regional Preferences which can be either + * fetched from the internal internationalization database (CLDR), or + * from the host environment. + * + * The result is a sorted list of valid locale IDs and it should be + * used for all APIs that accept list of locales, like ECMA402 and L10n APIs. + * + * This API always returns at least one locale. + * + * Example: ["en-US", "de", "pl", "sr-Cyrl", "zh-Hans-HK"] + */ + [Func="IsChromeOrUAWidget"] + sequence<DOMString> getRegionalPrefsLocales(); + + /** + * Returns a list of locales that the web content would know from the user. + * + * One of the fingerprinting technique is to recognize users from their locales + * exposed to web content. For those components that would be fingerprintable + * from the locale should call this API instead of |getRegionalPrefsLocales()|. + * + * If the pref is set to spoof locale setting, this function will return the + * spoofed locale, otherwise it returns what |getRegionalPrefsLocales()| returns. + * + * This API always returns at least one locale. + * + * Example: ["en-US"] + */ + [Func="IsChromeOrUAWidget"] + sequence<DOMString> getWebExposedLocales(); + + /** + * Getter funcion for IntlUtils, which provides helper functions for + * localization. + */ + [Throws, Func="IsChromeOrUAWidget"] + readonly attribute IntlUtils intlUtils; +}; + +partial interface Window { + [SameObject, Pref="dom.visualviewport.enabled", Replaceable] + readonly attribute VisualViewport visualViewport; +}; + +// Used to assign marks to appear on the scrollbar when +// finding on a page. +partial interface Window { + // The marks are values between 0 and scrollMax{X,Y} - scrollMin{X,Y}. + [ChromeOnly] + undefined setScrollMarks(sequence<unsigned long> marks, + optional boolean onHorizontalScrollbar = false); +}; + +dictionary WindowPostMessageOptions : StructuredSerializeOptions { + USVString targetOrigin = "/"; +}; |