dom/webidl/Document.webidl

   1 /* -*- Mode: IDL; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* This Source Code Form is subject to the terms of the Mozilla Public
   3  * License, v. 2.0. If a copy of the MPL was not distributed with this file,
   4  * You can obtain one at http://mozilla.org/MPL/2.0/.
   5  *
   6  * https://dom.spec.whatwg.org/#interface-document
   7  * https://html.spec.whatwg.org/multipage/dom.html#the-document-object
   8  * https://html.spec.whatwg.org/multipage/obsolete.html#other-elements%2C-attributes-and-apis
   9  * https://fullscreen.spec.whatwg.org/#api
  10  * https://w3c.github.io/pointerlock/#extensions-to-the-document-interface
  11  * https://w3c.github.io/pointerlock/#extensions-to-the-documentorshadowroot-mixin
  12  * https://w3c.github.io/page-visibility/#extensions-to-the-document-interface
  13  * https://drafts.csswg.org/cssom/#extensions-to-the-document-interface
  14  * https://drafts.csswg.org/cssom-view/#extensions-to-the-document-interface
  15  * https://wicg.github.io/feature-policy/#policy
  16  */
  17
  18 interface ContentSecurityPolicy;
  19 interface Principal;
  20 interface WindowProxy;
  21 interface nsISupports;
  22 interface URI;
  23 interface nsIDocShell;
  24 interface nsILoadGroup;
  25 interface nsIReferrerInfo;
  26 interface nsICookieJarSettings;
  27 interface nsIPermissionDelegateHandler;
  28 interface XULCommandDispatcher;
  29
  30 enum VisibilityState { "hidden", "visible" };
  31
  32 /* https://dom.spec.whatwg.org/#dictdef-elementcreationoptions */
  33 dictionary ElementCreationOptions {
  34   DOMString is;
  35
  36   [ChromeOnly]
  37   DOMString pseudo;
  38 };
  39
  40 /* https://dom.spec.whatwg.org/#interface-document */
  41 [Exposed=Window]
  42 interface Document : Node {
  43   [Throws]
  44   constructor();
  45
  46   [Throws]
  47   readonly attribute DOMImplementation implementation;
  48   [Pure, Throws, BinaryName="documentURIFromJS", NeedsCallerType]
  49   readonly attribute DOMString URL;
  50   [Pure, Throws, BinaryName="documentURIFromJS", NeedsCallerType]
  51   readonly attribute DOMString documentURI;
  52   [Pure]
  53   readonly attribute DOMString compatMode;
  54   [Pure]
  55   readonly attribute DOMString characterSet;
  56   [Pure,BinaryName="characterSet"]
  57   readonly attribute DOMString charset; // legacy alias of .characterSet
  58   [Pure,BinaryName="characterSet"]
  59   readonly attribute DOMString inputEncoding; // legacy alias of .characterSet
  60   [Pure]
  61   readonly attribute DOMString contentType;
  62
  63   [Pure]
  64   readonly attribute DocumentType? doctype;
  65   [Pure]
  66   readonly attribute Element? documentElement;
  67   [Pure]
  68   HTMLCollection getElementsByTagName(DOMString localName);
  69   [Pure, Throws]
  70   HTMLCollection getElementsByTagNameNS(DOMString? namespace, DOMString localName);
  71   [Pure]
  72   HTMLCollection getElementsByClassName(DOMString classNames);
  73   [Pure]
  74   Element? getElementById(DOMString elementId);
  75
  76   // These DOM methods cannot be accessed by UA Widget scripts
  77   // because the DOM element reflectors will be in the content scope,
  78   // instead of the desired UA Widget scope.
  79   [CEReactions, NewObject, Throws, Func="IsNotUAWidget"]
  80   Element createElement(DOMString localName, optional (ElementCreationOptions or DOMString) options = {});
  81   [CEReactions, NewObject, Throws, Func="IsNotUAWidget"]
  82   Element createElementNS(DOMString? namespace, DOMString qualifiedName, optional (ElementCreationOptions or DOMString) options = {});
  83   [NewObject]
  84   DocumentFragment createDocumentFragment();
  85   [NewObject, Func="IsNotUAWidget"]
  86   Text createTextNode(DOMString data);
  87   [NewObject, Func="IsNotUAWidget"]
  88   Comment createComment(DOMString data);
  89   [NewObject, Throws]
  90   ProcessingInstruction createProcessingInstruction(DOMString target, DOMString data);
  91
  92   [CEReactions, Throws, Func="IsNotUAWidget"]
  93   Node importNode(Node node, optional boolean deep = false);
  94   [CEReactions, Throws, Func="IsNotUAWidget"]
  95   Node adoptNode(Node node);
  96
  97   [NewObject, Throws, NeedsCallerType]
  98   Event createEvent(DOMString interface);
  99
 100   [NewObject, Throws]
 101   Range createRange();
 102
 103   // NodeFilter.SHOW_ALL = 0xFFFFFFFF
 104   [NewObject, Throws]
 105   NodeIterator createNodeIterator(Node root, optional unsigned long whatToShow = 0xFFFFFFFF, optional NodeFilter? filter = null);
 106   [NewObject, Throws]
 107   TreeWalker createTreeWalker(Node root, optional unsigned long whatToShow = 0xFFFFFFFF, optional NodeFilter? filter = null);
 108
 109   // NEW
 110   // No support for prepend/append yet
 111   // undefined prepend((Node or DOMString)... nodes);
 112   // undefined append((Node or DOMString)... nodes);
 113
 114   // These are not in the spec, but leave them for now for backwards compat.
 115   // So sort of like Gecko extensions
 116   [NewObject, Throws]
 117   CDATASection createCDATASection(DOMString data);
 118   [NewObject, Throws]
 119   Attr createAttribute(DOMString name);
 120   [NewObject, Throws]
 121   Attr createAttributeNS(DOMString? namespace, DOMString name);
 122 };
 123
 124 // https://html.spec.whatwg.org/multipage/dom.html#the-document-object
 125 partial interface Document {
 126   [PutForwards=href, LegacyUnforgeable] readonly attribute Location? location;
 127   [SetterThrows]                           attribute DOMString domain;
 128   readonly attribute DOMString referrer;
 129   [Throws] attribute DOMString cookie;
 130   readonly attribute DOMString lastModified;
 131   readonly attribute DOMString readyState;
 132
 133   // DOM tree accessors
 134   //(Not proxy yet)getter object (DOMString name);
 135   [CEReactions, SetterThrows, Pure]
 136            attribute DOMString title;
 137   [CEReactions, Pure]
 138            attribute DOMString dir;
 139   [CEReactions, Pure, SetterThrows]
 140            attribute HTMLElement? body;
 141   [Pure]
 142   readonly attribute HTMLHeadElement? head;
 143   [SameObject] readonly attribute HTMLCollection images;
 144   [SameObject] readonly attribute HTMLCollection embeds;
 145   [SameObject] readonly attribute HTMLCollection plugins;
 146   [SameObject] readonly attribute HTMLCollection links;
 147   [SameObject] readonly attribute HTMLCollection forms;
 148   [SameObject] readonly attribute HTMLCollection scripts;
 149   [Pure]
 150   NodeList getElementsByName(DOMString elementName);
 151   //(Not implemented)readonly attribute DOMElementMap cssElementMap;
 152
 153   // dynamic markup insertion
 154   [CEReactions, Throws]
 155   Document open(optional DOMString unused1, optional DOMString unused2); // both arguments are ignored
 156   [CEReactions, Throws]
 157   WindowProxy? open(USVString url, DOMString name, DOMString features);
 158   [CEReactions, Throws]
 159   undefined close();
 160   [CEReactions, Throws]
 161   undefined write(DOMString... text);
 162   [CEReactions, Throws]
 163   undefined writeln(DOMString... text);
 164
 165   // user interaction
 166   [Pure]
 167   readonly attribute WindowProxy? defaultView;
 168   [Throws]
 169   boolean hasFocus();
 170   [CEReactions, SetterThrows, SetterNeedsSubjectPrincipal]
 171            attribute DOMString designMode;
 172   [CEReactions, Throws, NeedsSubjectPrincipal]
 173   boolean execCommand(DOMString commandId, optional boolean showUI = false,
 174                       optional DOMString value = "");
 175   [Throws, NeedsSubjectPrincipal]
 176   boolean queryCommandEnabled(DOMString commandId);
 177   [Throws]
 178   boolean queryCommandIndeterm(DOMString commandId);
 179   [Throws]
 180   boolean queryCommandState(DOMString commandId);
 181   [Throws, NeedsCallerType]
 182   boolean queryCommandSupported(DOMString commandId);
 183   [Throws]
 184   DOMString queryCommandValue(DOMString commandId);
 185   //(Not implemented)readonly attribute HTMLCollection commands;
 186
 187   // special event handler IDL attributes that only apply to Document objects
 188   [LegacyLenientThis] attribute EventHandler onreadystatechange;
 189
 190   // Gecko extensions?
 191                 attribute EventHandler onbeforescriptexecute;
 192                 attribute EventHandler onafterscriptexecute;
 193
 194   /**
 195    * True if this document is synthetic : stand alone image, video, audio file,
 196    * etc.
 197    */
 198   [Func="IsChromeOrUAWidget"] readonly attribute boolean mozSyntheticDocument;
 199   /**
 200    * Returns the script element whose script is currently being processed.
 201    *
 202    * @see <https://developer.mozilla.org/en/DOM/document.currentScript>
 203    */
 204   [Pure]
 205   readonly attribute Element? currentScript;
 206   /**
 207    * Release the current mouse capture if it is on an element within this
 208    * document.
 209    *
 210    * @see <https://developer.mozilla.org/en/DOM/document.releaseCapture>
 211    */
 212   [Deprecated=DocumentReleaseCapture, Pref="dom.mouse_capture.enabled"]
 213   undefined releaseCapture();
 214   /**
 215    * Use the given DOM element as the source image of target |-moz-element()|.
 216    *
 217    * This function introduces a new special ID (called "image element ID"),
 218    * which is only used by |-moz-element()|, and associates it with the given
 219    * DOM element.  Image elements ID's have the higher precedence than general
 220    * HTML id's, so if |document.mozSetImageElement(<id>, <element>)| is called,
 221    * |-moz-element(#<id>)| uses |<element>| as the source image even if there
 222    * is another element with id attribute = |<id>|.  To unregister an image
 223    * element ID |<id>|, call |document.mozSetImageElement(<id>, null)|.
 224    *
 225    * Example:
 226    * <script>
 227    *   canvas = document.createElement("canvas");
 228    *   canvas.setAttribute("width", 100);
 229    *   canvas.setAttribute("height", 100);
 230    *   // draw to canvas
 231    *   document.mozSetImageElement("canvasbg", canvas);
 232    * </script>
 233    * <div style="background-image: -moz-element(#canvasbg);"></div>
 234    *
 235    * @param aImageElementId an image element ID to associate with
 236    * |aImageElement|
 237    * @param aImageElement a DOM element to be used as the source image of
 238    * |-moz-element(#aImageElementId)|. If this is null, the function will
 239    * unregister the image element ID |aImageElementId|.
 240    *
 241    * @see <https://developer.mozilla.org/en/DOM/document.mozSetImageElement>
 242    */
 243   [UseCounter]
 244   undefined mozSetImageElement(DOMString aImageElementId,
 245                                Element? aImageElement);
 246
 247   [ChromeOnly]
 248   readonly attribute URI? documentURIObject;
 249
 250   /**
 251    * Current referrer policy - one of the referrer policy value from
 252    * ReferrerPolicy.webidl.
 253    */
 254   [ChromeOnly]
 255   readonly attribute ReferrerPolicy referrerPolicy;
 256
 257     /**
 258    * Current referrer info, which holds all referrer related information
 259    * including referrer policy and raw referrer of document.
 260    */
 261   [ChromeOnly]
 262   readonly attribute nsIReferrerInfo referrerInfo;
 263
 264 };
 265
 266 // https://html.spec.whatwg.org/multipage/obsolete.html#other-elements%2C-attributes-and-apis
 267 partial interface Document {
 268   [CEReactions] attribute [LegacyNullToEmptyString] DOMString fgColor;
 269   [CEReactions] attribute [LegacyNullToEmptyString] DOMString linkColor;
 270   [CEReactions] attribute [LegacyNullToEmptyString] DOMString vlinkColor;
 271   [CEReactions] attribute [LegacyNullToEmptyString] DOMString alinkColor;
 272   [CEReactions] attribute [LegacyNullToEmptyString] DOMString bgColor;
 273
 274   [SameObject] readonly attribute HTMLCollection anchors;
 275   [SameObject] readonly attribute HTMLCollection applets;
 276
 277   undefined clear();
 278   // @deprecated These are old Netscape 4 methods. Do not use,
 279   //             the implementation is no-op.
 280   // XXXbz do we actually need these anymore?
 281   undefined captureEvents();
 282   undefined releaseEvents();
 283
 284   [SameObject] readonly attribute HTMLAllCollection all;
 285 };
 286
 287 // https://fullscreen.spec.whatwg.org/#api
 288 partial interface Document {
 289   // Note: Per spec the 'S' in these two is lowercase, but the "Moz"
 290   // versions have it uppercase.
 291   [LegacyLenientSetter, Unscopable]
 292   readonly attribute boolean fullscreen;
 293   [BinaryName="fullscreen"]
 294   readonly attribute boolean mozFullScreen;
 295   [LegacyLenientSetter, NeedsCallerType]
 296   readonly attribute boolean fullscreenEnabled;
 297   [BinaryName="fullscreenEnabled", NeedsCallerType]
 298   readonly attribute boolean mozFullScreenEnabled;
 299
 300   [NewObject]
 301   Promise<undefined> exitFullscreen();
 302   [NewObject, BinaryName="exitFullscreen"]
 303   Promise<undefined> mozCancelFullScreen();
 304
 305   // Events handlers
 306   attribute EventHandler onfullscreenchange;
 307   attribute EventHandler onfullscreenerror;
 308 };
 309
 310 // https://w3c.github.io/pointerlock/#extensions-to-the-document-interface
 311 // https://w3c.github.io/pointerlock/#extensions-to-the-documentorshadowroot-mixin
 312 partial interface Document {
 313   undefined exitPointerLock();
 314
 315   // Event handlers
 316   attribute EventHandler onpointerlockchange;
 317   attribute EventHandler onpointerlockerror;
 318 };
 319
 320 // Mozilla-internal document extensions specific to error pages.
 321 partial interface Document {
 322   [Func="Document::CallerIsTrustedAboutCertError", NewObject]
 323   Promise<any> addCertException(boolean isTemporary);
 324
 325   [Func="Document::CallerIsTrustedAboutHttpsOnlyError"]
 326   undefined reloadWithHttpsOnlyException();
 327
 328   [Func="Document::CallerIsTrustedAboutCertError", Throws]
 329   FailedCertSecurityInfo getFailedCertSecurityInfo();
 330
 331   [Func="Document::CallerIsTrustedAboutNetError", Throws]
 332   NetErrorInfo getNetErrorInfo();
 333 };
 334
 335 // https://w3c.github.io/page-visibility/#extensions-to-the-document-interface
 336 partial interface Document {
 337   readonly attribute boolean hidden;
 338   readonly attribute VisibilityState visibilityState;
 339            attribute EventHandler onvisibilitychange;
 340 };
 341
 342 // https://drafts.csswg.org/cssom/#extensions-to-the-document-interface
 343 partial interface Document {
 344     attribute DOMString? selectedStyleSheetSet;
 345     readonly attribute DOMString? lastStyleSheetSet;
 346     readonly attribute DOMString? preferredStyleSheetSet;
 347     [Constant]
 348     readonly attribute DOMStringList styleSheetSets;
 349     undefined enableStyleSheetsForSet (DOMString? name);
 350 };
 351
 352 // https://drafts.csswg.org/cssom-view/#extensions-to-the-document-interface
 353 partial interface Document {
 354     CaretPosition? caretPositionFromPoint (float x, float y);
 355
 356     readonly attribute Element? scrollingElement;
 357 };
 358
 359 // http://dev.w3.org/2006/webapi/selectors-api2/#interface-definitions
 360 partial interface Document {
 361   [Throws, Pure]
 362   Element?  querySelector(UTF8String selectors);
 363   [Throws, Pure]
 364   NodeList  querySelectorAll(UTF8String selectors);
 365
 366   //(Not implemented)Element?  find(DOMString selectors, optional (Element or sequence<Node>)? refNodes);
 367   //(Not implemented)NodeList  findAll(DOMString selectors, optional (Element or sequence<Node>)? refNodes);
 368 };
 369
 370 // https://drafts.csswg.org/web-animations/#extensions-to-the-document-interface
 371 partial interface Document {
 372   [Func="Document::AreWebAnimationsTimelinesEnabled"]
 373   readonly attribute DocumentTimeline timeline;
 374 };
 375
 376 // https://svgwg.org/svg2-draft/struct.html#InterfaceDocumentExtensions
 377 partial interface Document {
 378   [BinaryName="SVGRootElement"]
 379   readonly attribute SVGSVGElement? rootElement;
 380 };
 381
 382 //  Mozilla extensions of various sorts
 383 partial interface Document {
 384   // Creates a new XUL element regardless of the document's default type.
 385   [ChromeOnly, CEReactions, NewObject, Throws]
 386   Element createXULElement(DOMString localName, optional (ElementCreationOptions or DOMString) options = {});
 387   // Wether the document was loaded using a nsXULPrototypeDocument.
 388   [ChromeOnly]
 389   readonly attribute boolean loadedFromPrototype;
 390
 391   // The principal to use for the storage area of this document
 392   [ChromeOnly]
 393   readonly attribute Principal effectiveStoragePrincipal;
 394
 395   // You should probably not be using this principal getter since it performs
 396   // no checks to ensure that the partitioned principal should really be used
 397   // here.  It is only designed to be used in very specific circumstances, such
 398   // as when inheriting the document/storage principal.
 399   [ChromeOnly]
 400   readonly attribute Principal partitionedPrincipal;
 401
 402   // The cookieJarSettings of this document
 403   [ChromeOnly]
 404   readonly attribute nsICookieJarSettings cookieJarSettings;
 405
 406   // Touch bits
 407   // XXXbz I can't find the sane spec for this stuff, so just cribbing
 408   // from our xpidl for now.
 409   [NewObject, Func="nsGenericHTMLElement::LegacyTouchAPIEnabled"]
 410   Touch createTouch(optional Window? view = null,
 411                     optional EventTarget? target = null,
 412                     optional long identifier = 0,
 413                     optional long pageX = 0,
 414                     optional long pageY = 0,
 415                     optional long screenX = 0,
 416                     optional long screenY = 0,
 417                     optional long clientX = 0,
 418                     optional long clientY = 0,
 419                     optional long radiusX = 0,
 420                     optional long radiusY = 0,
 421                     optional float rotationAngle = 0,
 422                     optional float force = 0);
 423   // XXXbz a hack to get around the fact that we don't support variadics as
 424   // distinguishing arguments yet.  Once this hack is removed. we can also
 425   // remove the corresponding overload on Document, since Touch... and
 426   // sequence<Touch> look the same in the C++.
 427   [NewObject, Func="nsGenericHTMLElement::LegacyTouchAPIEnabled"]
 428   TouchList createTouchList(Touch touch, Touch... touches);
 429   // XXXbz and another hack for the fact that we can't usefully have optional
 430   // distinguishing arguments but need a working zero-arg form of
 431   // createTouchList().
 432   [NewObject, Func="nsGenericHTMLElement::LegacyTouchAPIEnabled"]
 433   TouchList createTouchList();
 434   [NewObject, Func="nsGenericHTMLElement::LegacyTouchAPIEnabled"]
 435   TouchList createTouchList(sequence<Touch> touches);
 436
 437   [ChromeOnly]
 438   attribute boolean styleSheetChangeEventsEnabled;
 439
 440   [ChromeOnly]
 441   attribute boolean devToolsAnonymousAndShadowEventsEnabled;
 442
 443   [ChromeOnly] readonly attribute DOMString contentLanguage;
 444
 445   [ChromeOnly] readonly attribute nsILoadGroup? documentLoadGroup;
 446
 447   // Blocks the initial document parser until the given promise is settled.
 448   [ChromeOnly, NewObject]
 449   Promise<any> blockParsing(Promise<any> promise,
 450                             optional BlockParsingOptions options = {});
 451
 452   [Func="nsContentUtils::IsSystemOrPDFJS", BinaryName="blockUnblockOnloadForSystemOrPDFJS"]
 453   undefined blockUnblockOnload(boolean block);
 454
 455   // like documentURI, except that for error pages, it returns the URI we were
 456   // trying to load when we hit an error, rather than the error page's own URI.
 457   [ChromeOnly] readonly attribute URI? mozDocumentURIIfNotForErrorPages;
 458
 459   // A promise that is resolved when we have both fired DOMContentLoaded and
 460   // are ready to start layout.
 461   // This is used for the  "document_idle" webextension script injection point.
 462   [ChromeOnly, Throws]
 463   readonly attribute Promise<undefined> documentReadyForIdle;
 464
 465   // Lazily created command dispatcher, returns null if the document is not
 466   // chrome privileged.
 467   [ChromeOnly]
 468   readonly attribute XULCommandDispatcher? commandDispatcher;
 469
 470   [ChromeOnly]
 471   attribute boolean devToolsWatchingDOMMutations;
 472
 473   /**
 474    * Returns all the shadow roots connected to the document, in no particular
 475    * order, and without regard to open/closed-ness. Also returns UA widgets
 476    * (like <video> controls), which can be checked using
 477    * ShadowRoot.isUAWidget().
 478    */
 479   [ChromeOnly]
 480   sequence<ShadowRoot> getConnectedShadowRoots();
 481 };
 482
 483 dictionary BlockParsingOptions {
 484   /**
 485    * If true, blocks script-created parsers (created via document.open()) in
 486    * addition to network-created parsers.
 487    */
 488   boolean blockScriptCreated = true;
 489 };
 490
 491 // Extension to give chrome JS the ability to determine when a document was
 492 // created to satisfy an iframe with srcdoc attribute.
 493 partial interface Document {
 494   [ChromeOnly] readonly attribute boolean isSrcdocDocument;
 495 };
 496
 497
 498 // Extension to give chrome JS the ability to get the underlying
 499 // sandbox flag attribute
 500 partial interface Document {
 501   [ChromeOnly] readonly attribute DOMString? sandboxFlagsAsString;
 502 };
 503
 504
 505 /**
 506  * Chrome document anonymous content management.
 507  * This is a Chrome-only API that allows inserting fixed positioned anonymous
 508  * content on top of the current page displayed in the document.
 509  */
 510 partial interface Document {
 511   /**
 512    * If aForce is true, tries to update layout to be able to insert the element
 513    * synchronously.
 514    */
 515   [ChromeOnly, NewObject, Throws]
 516   AnonymousContent insertAnonymousContent(optional boolean aForce = false);
 517
 518   /**
 519    * Removes the element inserted into the CanvasFrame given an AnonymousContent
 520    * instance.
 521    */
 522   [ChromeOnly]
 523   undefined removeAnonymousContent(AnonymousContent aContent);
 524 };
 525
 526 // http://w3c.github.io/selection-api/#extensions-to-document-interface
 527 partial interface Document {
 528   [Throws]
 529   Selection? getSelection();
 530 };
 531
 532 // https://github.com/whatwg/html/issues/3338
 533 partial interface Document {
 534   [Pref="dom.storage_access.enabled", NewObject]
 535   Promise<boolean> hasStorageAccess();
 536   [Pref="dom.storage_access.enabled", NewObject]
 537   Promise<undefined> requestStorageAccess();
 538   // https://github.com/privacycg/storage-access/pull/100
 539   [Pref="dom.storage_access.forward_declared.enabled", NewObject]
 540   Promise<undefined> requestStorageAccessUnderSite(DOMString serializedSite);
 541   [Pref="dom.storage_access.forward_declared.enabled", NewObject]
 542   Promise<undefined> completeStorageAccessRequestFromSite(DOMString serializedSite);
 543 };
 544
 545 // A privileged API to give chrome privileged code and the content script of the
 546 // webcompat extension the ability to request the storage access for a given
 547 // third party.
 548 partial interface Document {
 549   [Func="Document::CallerCanAccessPrivilegeSSA", NewObject]
 550   Promise<undefined> requestStorageAccessForOrigin(DOMString thirdPartyOrigin, optional boolean requireUserInteraction = true);
 551 };
 552
 553 // Extension to give chrome JS the ability to determine whether
 554 // the user has interacted with the document or not.
 555 partial interface Document {
 556   [ChromeOnly] readonly attribute boolean userHasInteracted;
 557 };
 558
 559 // Extension to give chrome JS the ability to simulate activate the document
 560 // by user gesture.
 561 partial interface Document {
 562   [ChromeOnly]
 563   undefined notifyUserGestureActivation();
 564   // For testing only.
 565   [ChromeOnly]
 566   undefined clearUserGestureActivation();
 567   [ChromeOnly]
 568   readonly attribute boolean hasBeenUserGestureActivated;
 569   [ChromeOnly]
 570   readonly attribute boolean hasValidTransientUserGestureActivation;
 571   [ChromeOnly]
 572   readonly attribute DOMHighResTimeStamp lastUserGestureTimeStamp;
 573   [ChromeOnly]
 574   boolean consumeTransientUserGestureActivation();
 575 };
 576
 577 // Extension to give chrome JS the ability to set an event handler which is
 578 // called with certain events that happened while events were suppressed in the
 579 // document or one of its subdocuments.
 580 partial interface Document {
 581   [ChromeOnly]
 582   undefined setSuppressedEventListener(EventListener? aListener);
 583 };
 584
 585 // Allows frontend code to query a CSP which needs to be passed for a
 586 // new load into docshell. Further, allows to query the CSP in JSON
 587 // format for testing purposes.
 588 partial interface Document {
 589   [ChromeOnly] readonly attribute ContentSecurityPolicy? csp;
 590   [ChromeOnly] readonly attribute DOMString cspJSON;
 591 };
 592
 593 partial interface Document {
 594   [Func="Document::DocumentSupportsL10n"] readonly attribute DocumentL10n? l10n;
 595   [Func="Document::DocumentSupportsL10n"] readonly attribute boolean hasPendingL10nMutations;
 596 };
 597
 598 Document includes XPathEvaluatorMixin;
 599 Document includes GlobalEventHandlers;
 600 Document includes TouchEventHandlers;
 601 Document includes ParentNode;
 602 Document includes OnErrorEventHandlerForNodes;
 603 Document includes GeometryUtils;
 604 Document includes FontFaceSource;
 605 Document includes DocumentOrShadowRoot;
 606
 607 // https://w3c.github.io/webappsec-feature-policy/#idl-index
 608 partial interface Document {
 609     [SameObject, Pref="dom.security.featurePolicy.webidl.enabled"]
 610     readonly attribute FeaturePolicy featurePolicy;
 611 };
 612
 613 // Extension to give chrome JS the ability to specify a non-default keypress
 614 // event model.
 615 partial interface Document {
 616   /**
 617    * setKeyPressEventModel() is called when we need to check whether the web
 618    * app requires specific keypress event model or not.
 619    *
 620    * @param aKeyPressEventModel  Proper keypress event model for the web app.
 621    *   KEYPRESS_EVENT_MODEL_DEFAULT:
 622    *     Use default keypress event model.  I.e., depending on
 623    *     "dom.keyboardevent.keypress.set_keycode_and_charcode_to_same_value"
 624    *     pref.
 625    *   KEYPRESS_EVENT_MODEL_SPLIT:
 626    *     Use split model.  I.e, if keypress event inputs a character,
 627    *     keyCode should be 0.  Otherwise, charCode should be 0.
 628    *   KEYPRESS_EVENT_MODEL_CONFLATED:
 629    *     Use conflated model.  I.e., keyCode and charCode values of each
 630    *     keypress event should be set to same value.
 631    */
 632   [ChromeOnly]
 633   const unsigned short KEYPRESS_EVENT_MODEL_DEFAULT = 0;
 634   [ChromeOnly]
 635   const unsigned short KEYPRESS_EVENT_MODEL_SPLIT = 1;
 636   [ChromeOnly]
 637   const unsigned short KEYPRESS_EVENT_MODEL_CONFLATED = 2;
 638   [ChromeOnly]
 639   undefined setKeyPressEventModel(unsigned short aKeyPressEventModel);
 640 };
 641
 642 // Extensions to return information about about the nodes blocked by the
 643 // Safebrowsing API inside a document.
 644 partial interface Document {
 645   /*
 646    * Number of nodes that have been blocked by the Safebrowsing API to prevent
 647    * tracking, cryptomining and so on. This method is for testing only.
 648    */
 649   [ChromeOnly, Pure]
 650   readonly attribute long blockedNodeByClassifierCount;
 651
 652   /*
 653    * List of nodes that have been blocked by the Safebrowsing API to prevent
 654    * tracking, fingerprinting, cryptomining and so on. This method is for
 655    * testing only.
 656    */
 657   [ChromeOnly, Pure]
 658   readonly attribute NodeList blockedNodesByClassifier;
 659 };
 660
 661 // Extension to programmatically simulate a user interaction on a document,
 662 // used for testing.
 663 partial interface Document {
 664   [ChromeOnly, BinaryName="setUserHasInteracted"]
 665   undefined userInteractionForTesting();
 666 };
 667
 668 // Extension for permission delegation.
 669 partial interface Document {
 670   [ChromeOnly, Pure]
 671   readonly attribute nsIPermissionDelegateHandler permDelegateHandler;
 672 };
 673
 674 // Extension used by the password manager to infer form submissions.
 675 partial interface Document {
 676   /*
 677    * Set whether the document notifies an event when a fetch or
 678    * XHR completes successfully.
 679    */
 680   [ChromeOnly]
 681   undefined setNotifyFetchSuccess(boolean aShouldNotify);
 682
 683   /*
 684    * Set whether a form and a password field notify an event when it is
 685    * removed from the DOM tree.
 686    */
 687   [ChromeOnly]
 688   undefined setNotifyFormOrPasswordRemoved(boolean aShouldNotify);
 689 };
 690
 691 // Extension to allow chrome code to detect initial about:blank documents.
 692 partial interface Document {
 693   [ChromeOnly]
 694   readonly attribute boolean isInitialDocument;
 695 };
 696
 697 // Extension to allow chrome code to get some wireframe-like structure.
 698 enum WireframeRectType {
 699   "image",
 700   "background",
 701   "text",
 702   "unknown",
 703 };
 704 dictionary WireframeTaggedRect {
 705   unrestricted double x = 0;
 706   unrestricted double y = 0;
 707   unrestricted double width = 0;
 708   unrestricted double height = 0;
 709   unsigned long color = 0; // in nscolor format
 710   WireframeRectType type;
 711   Node? node;
 712 };
 713 [GenerateInit]
 714 dictionary Wireframe {
 715   unsigned long canvasBackground = 0; // in nscolor format
 716   sequence<WireframeTaggedRect> rects;
 717   unsigned long version = 1; // Increment when the wireframe structure changes in backwards-incompatible ways
 718 };
 719 partial interface Document {
 720   [ChromeOnly]
 721   Wireframe? getWireframe(optional boolean aIncludeNodes = false);
 722 };
 723
 724 partial interface Document {
 725   // Returns true if the document is the current active document in a browsing
 726   // context which isn't in bfcache.
 727   [ChromeOnly]
 728   boolean isActive();
 729 };