docshell/base/nsIDocShell.idl

   1 /* -*- Mode: IDL; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
   2  *
   3  * This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #include "domstubs.idl"
   8 #include "nsIDocShellTreeItem.idl"
   9 #include "nsIRequest.idl"
  10
  11 %{ C++
  12 #include "js/TypeDecls.h"
  13 #include "mozilla/Maybe.h"
  14 #include "mozilla/NotNull.h"
  15 #include "mozilla/UniquePtr.h"
  16 #include "nsCOMPtr.h"
  17 #include "nsIURI.h"
  18 class nsCommandManager;
  19 class nsPresContext;
  20 class nsDocShellLoadState;
  21 namespace mozilla {
  22 class Encoding;
  23 class HTMLEditor;
  24 class PresShell;
  25 namespace dom {
  26 class BrowsingContext;
  27 class ClientSource;
  28 } // namespace dom
  29 }
  30 %}
  31
  32 /**
  33  * The nsIDocShell interface.
  34  */
  35
  36 [ptr] native nsPresContext(nsPresContext);
  37 [ptr] native nsCommandManager(nsCommandManager);
  38 [ptr] native PresShell(mozilla::PresShell);
  39 [ref] native MaybeURI(mozilla::Maybe<nsCOMPtr<nsIURI>>);
  40 [ref] native Encoding(const mozilla::Encoding*);
  41       native UniqueClientSource(mozilla::UniquePtr<mozilla::dom::ClientSource>);
  42
  43 interface nsIURI;
  44 interface nsIChannel;
  45 interface nsIContentViewer;
  46 interface nsIContentSecurityPolicy;
  47 interface nsIEditor;
  48 interface nsIEditingSession;
  49 interface nsIInputStream;
  50 interface nsIRequest;
  51 interface nsISHEntry;
  52 interface nsILayoutHistoryState;
  53 interface nsISecureBrowserUI;
  54 interface nsIScriptGlobalObject;
  55 interface nsIStructuredCloneContainer;
  56 interface nsIDOMStorage;
  57 interface nsIPrincipal;
  58 interface nsIPrivacyTransitionObserver;
  59 interface nsIReflowObserver;
  60 interface nsIScrollObserver;
  61 interface nsIRemoteTab;
  62 interface nsIBrowserChild;
  63 interface nsICommandParams;
  64 interface nsILoadURIDelegate;
  65 native BrowserChildRef(already_AddRefed<nsIBrowserChild>);
  66 native nsDocShellLoadStatePtr(nsDocShellLoadState*);
  67
  68 webidl BrowsingContext;
  69 webidl ContentFrameMessageManager;
  70 webidl EventTarget;
  71 webidl Document;
  72
  73 [scriptable, builtinclass, uuid(049234fe-da10-478b-bc5d-bc6f9a1ba63d)]
  74 interface nsIDocShell : nsIDocShellTreeItem
  75 {
  76   void setCancelContentJSEpoch(in long aEpoch);
  77
  78   /**
  79    * Loads a given URI.  This will give priority to loading the requested URI
  80    * in the object implementing this interface.  If it can't be loaded here
  81    * however, the URL dispatcher will go through its normal process of content
  82    * loading.
  83    *
  84    * @param aLoadState This is the extended load info for this load.
  85    * @param aSetNavigating If we should set isNavigating to true while initiating
  86    *                       the load.
  87    */
  88   [noscript]void loadURI(in nsDocShellLoadStatePtr aLoadState, in boolean aSetNavigating);
  89
  90   /**
  91    * Do either a history.pushState() or history.replaceState() operation,
  92    * depending on the value of aReplace.
  93    */
  94   [implicit_jscontext]
  95   void addState(in jsval aData, in AString aTitle,
  96                 in AString aURL, in boolean aReplace);
  97
  98   /**
  99    * Reset state to a new content model within the current document and the document
 100    * viewer.  Called by the document before initiating an out of band document.write().
 101    */
 102   void prepareForNewContentModel();
 103
 104   /**
 105    * Helper for the session store to change the URI associated with the
 106    * document.
 107    */
 108   void setCurrentURIForSessionStore(in nsIURI aURI);
 109
 110   /**
 111    * Notify the associated content viewer and all child docshells that they are
 112    * about to be hidden.  If |isUnload| is true, then the document is being
 113    * unloaded and all dynamic subframe history entries are removed as well.
 114    *
 115    * @param isUnload
 116    *        True to fire the unload event in addition to the pagehide event,
 117    *        and remove all dynamic subframe history entries.
 118    */
 119   [noscript] void firePageHideNotification(in boolean isUnload);
 120
 121   /**
 122    * Presentation context for the currently loaded document.  This may be null.
 123    */
 124   [notxpcom,nostdcall] readonly attribute nsPresContext presContext;
 125
 126   /**
 127    * Presentation shell for the currently loaded document.  This may be null.
 128    */
 129   [notxpcom,nostdcall] readonly attribute PresShell presShell;
 130
 131   /**
 132    * Presentation shell for the oldest document, if this docshell is
 133    * currently transitioning between documents.
 134    */
 135   [notxpcom,nostdcall] readonly attribute PresShell eldestPresShell;
 136
 137   /**
 138    * Content Viewer that is currently loaded for this DocShell.  This may
 139    * change as the underlying content changes.
 140    */
 141   [infallible] readonly attribute nsIContentViewer contentViewer;
 142
 143   /**
 144    * Get the id of the outer window that is or will be in this docshell.
 145    */
 146   [infallible] readonly attribute unsigned long long outerWindowID;
 147
 148   /**
 149    * This attribute allows chrome to tie in to handle DOM events that may
 150    * be of interest to chrome.
 151    */
 152   attribute EventTarget chromeEventHandler;
 153
 154   /**
 155    * This allows chrome to set a custom User agent on a specific docshell
 156    */
 157   attribute AString customUserAgent;
 158
 159   /**
 160    * Whether CSS error reporting is enabled.
 161    */
 162   attribute boolean cssErrorReportingEnabled;
 163
 164   /**
 165    * Whether to allow plugin execution
 166    */
 167   attribute boolean allowPlugins;
 168
 169   /**
 170    * Attribute stating if refresh based redirects can be allowed
 171    */
 172   attribute boolean allowMetaRedirects;
 173
 174   /**
 175    * Attribute stating if it should allow subframes (framesets/iframes) or not
 176    */
 177   attribute boolean allowSubframes;
 178
 179   /**
 180    * Attribute stating whether or not images should be loaded.
 181    */
 182   attribute boolean allowImages;
 183
 184   /**
 185    * Attribute stating whether or not media (audio/video) should be loaded.
 186    */
 187   [infallible] attribute boolean allowMedia;
 188
 189   /**
 190    * Attribute that determines whether DNS prefetch is allowed for this subtree
 191    * of the docshell tree.  Defaults to true.  Setting this will make it take
 192    * effect starting with the next document loaded in the docshell.
 193    */
 194   attribute boolean allowDNSPrefetch;
 195
 196   /**
 197    * Attribute that determines whether window control (move/resize) is allowed.
 198    */
 199   attribute boolean allowWindowControl;
 200
 201   /**
 202    * True if the docshell allows its content to be handled by a content listener
 203    * other than the docshell itself, including the external helper app service,
 204    * and false otherwise.  Defaults to true.
 205    */
 206   [infallible] attribute boolean allowContentRetargeting;
 207
 208   /**
 209    * True if new child docshells should allow content retargeting.
 210    * Setting allowContentRetargeting also overwrites this value.
 211    */
 212   [infallible] attribute boolean allowContentRetargetingOnChildren;
 213
 214   /**
 215    * Get an array of this docShell and its children.
 216    *
 217    * @param aItemType  - Only include docShells of this type, or if typeAll,
 218    *                     include all child shells.
 219    *                     Uses types from nsIDocShellTreeItem.
 220    * @param aDirection - Whether to enumerate forwards or backwards.
 221    */
 222
 223   cenum DocShellEnumeratorDirection : 8 {
 224     ENUMERATE_FORWARDS  = 0,
 225     ENUMERATE_BACKWARDS = 1
 226   };
 227
 228   Array<nsIDocShell> getAllDocShellsInSubtree(in long aItemType,
 229                                               in nsIDocShell_DocShellEnumeratorDirection aDirection);
 230
 231   /**
 232    * The type of application that created this window.
 233    *
 234    * DO NOT DELETE, see bug 176166. For firefox, this value will always be
 235    * UNKNOWN. However, it is used heavily in Thunderbird/comm-central and we
 236    * don't really have a great replacement at the moment, so we'll just leave it
 237    * here.
 238    */
 239   cenum AppType : 8 {
 240     APP_TYPE_UNKNOWN = 0,
 241     APP_TYPE_MAIL    = 1,
 242     APP_TYPE_EDITOR  = 2
 243   };
 244
 245   [infallible] attribute nsIDocShell_AppType appType;
 246
 247   /**
 248    * certain docshells (like the message pane)
 249    * should not throw up auth dialogs
 250    * because it can act as a password trojan
 251    */
 252   attribute boolean allowAuth;
 253
 254   /**
 255    * Set/Get the document scale factor.  When setting this attribute, a
 256    * NS_ERROR_NOT_IMPLEMENTED error may be returned by implementations
 257    * not supporting zoom.  Implementations not supporting zoom should return
 258    * 1.0 all the time for the Get operation.  1.0 by the way is the default
 259    * of zoom.  This means 100% of normal scaling or in other words normal size
 260    * no zoom.
 261    */
 262   attribute float zoom;
 263
 264   /*
 265    * Tells the docshell to offer focus to its tree owner.
 266    * This is currently only necessary for embedding chrome.
 267    * If forDocumentNavigation is true, then document navigation should be
 268    * performed, where only the root of documents are selected. Otherwise, the
 269    * next element in the parent should be returned. Returns true if focus was
 270    * successfully taken by the tree owner.
 271    */
 272   bool tabToTreeOwner(in boolean forward, in boolean forDocumentNavigation);
 273
 274   /**
 275    * Current busy state for DocShell
 276    */
 277   cenum BusyFlags : 8 {
 278     BUSY_FLAGS_NONE             = 0,
 279     BUSY_FLAGS_BUSY             = 1,
 280     BUSY_FLAGS_BEFORE_PAGE_LOAD = 2,
 281     BUSY_FLAGS_PAGE_LOADING     = 4,
 282   };
 283
 284   [infallible] readonly attribute nsIDocShell_BusyFlags busyFlags;
 285
 286   /**
 287    * Load commands for the document
 288    */
 289   cenum LoadCommand : 8 {
 290     LOAD_CMD_NORMAL  = 0x1,   // Normal load
 291     LOAD_CMD_RELOAD  = 0x2,   // Reload
 292     LOAD_CMD_HISTORY = 0x4,   // Load from history
 293     LOAD_CMD_PUSHSTATE = 0x8, // History.pushState()
 294   };
 295
 296   /*
 297    * Attribute to access the loadtype for the document. LoadType Enum is
 298    * defined in nsDocShellLoadTypes.h
 299    */
 300   [infallible] attribute unsigned long loadType;
 301
 302   /*
 303    * Default load flags (as defined in nsIRequest) that will be set on all
 304    * requests made by this docShell and propagated to all child docShells and
 305    * to nsILoadGroup::defaultLoadFlags for the docShell's loadGroup.
 306    * Default is no flags.  Once set, only future requests initiated by the
 307    * docShell are affected, so in general, these flags should be set before
 308    * the docShell loads any content.
 309    */
 310   attribute nsLoadFlags defaultLoadFlags;
 311
 312   /*
 313    * returns true if the docshell is being destroyed, false otherwise
 314    */
 315   boolean isBeingDestroyed();
 316
 317   /*
 318    * Returns true if the docshell is currently executing the onLoad Handler
 319    */
 320   readonly attribute boolean isExecutingOnLoadHandler;
 321
 322   attribute nsILayoutHistoryState layoutHistoryState;
 323
 324   /**
 325    * Object used to delegate URI loading to an upper context.
 326    * Currently only set for GeckoView to allow handling of load requests
 327    * at the application level.
 328    */
 329   readonly attribute nsILoadURIDelegate loadURIDelegate;
 330
 331   /**
 332    * Cancel the XPCOM timers for each meta-refresh URI in this docshell,
 333    * and this docshell's children, recursively. The meta-refresh timers can be
 334    * restarted using resumeRefreshURIs().  If the timers are already suspended,
 335    * this has no effect.
 336    */
 337   void suspendRefreshURIs();
 338
 339   /**
 340    * Restart the XPCOM timers for each meta-refresh URI in this docshell,
 341    * and this docshell's children, recursively.  If the timers are already
 342    * running, this has no effect.
 343    */
 344   void resumeRefreshURIs();
 345
 346   /**
 347    * Begin firing WebProgressListener notifications for restoring a page
 348    * presentation. |viewer| is the content viewer whose document we are
 349    * starting to load.  If null, it defaults to the docshell's current content
 350    * viewer, creating one if necessary.  |top| should be true for the toplevel
 351    * docshell that is being restored; it will be set to false when this method
 352    * is called for child docshells.  This method will post an event to
 353    * complete the simulated load after returning to the event loop.
 354    */
 355   void beginRestore(in nsIContentViewer viewer, in boolean top);
 356
 357   /**
 358    * Finish firing WebProgressListener notifications and DOM events for
 359    * restoring a page presentation.  This should only be called via
 360    * beginRestore().
 361    */
 362   void finishRestore();
 363
 364   void clearCachedUserAgent();
 365
 366   void clearCachedPlatform();
 367
 368   /* Track whether we're currently restoring a document presentation. */
 369   readonly attribute boolean restoringDocument;
 370
 371   /* attribute to access whether error pages are enabled */
 372   attribute boolean useErrorPages;
 373
 374   /**
 375    * Display a load error in a frame while keeping that frame's currentURI
 376    * pointing correctly to the page where the error ocurred, rather than to
 377    * the error document page. You must provide either the aURI or aURL parameter.
 378    *
 379    * @param  aError         The error code to be displayed
 380    * @param  aURI           nsIURI of the page where the error happened
 381    * @param  aURL           wstring of the page where the error happened
 382    * @param  aFailedChannel The channel related to this error
 383    *
 384    * Returns whether or not we displayed an error page (note: will always
 385    * return false if in-content error pages are disabled!)
 386    */
 387   boolean displayLoadError(in nsresult aError,
 388                            in nsIURI aURI,
 389                            in wstring aURL,
 390                            [optional] in nsIChannel aFailedChannel);
 391
 392   /**
 393    * The channel that failed to load and resulted in an error page.
 394    * May be null. Relevant only to error pages.
 395    */
 396   readonly attribute nsIChannel failedChannel;
 397
 398   /**
 399    * Keeps track of the previous nsISHEntry index and the current
 400    * nsISHEntry index at the time that the doc shell begins to load.
 401    * Used for ContentViewer eviction.
 402    */
 403   readonly attribute long previousEntryIndex;
 404   readonly attribute long loadedEntryIndex;
 405
 406   /**
 407    * Notification that entries have been removed from the beginning of a
 408    * nsSHistory which has this as its rootDocShell.
 409    *
 410    * @param numEntries - The number of entries removed
 411    */
 412   void historyPurged(in long numEntries);
 413
 414   /**
 415    * Gets the channel for the currently loaded document, if any.
 416    * For a new document load, this will be the channel of the previous document
 417    * until after OnLocationChange fires.
 418    */
 419   readonly attribute nsIChannel currentDocumentChannel;
 420
 421   /**
 422    * Find out whether the docshell is currently in the middle of a page
 423    * transition. This is set just before the pagehide/unload events fire.
 424    */
 425   [infallible] readonly attribute boolean isInUnload;
 426
 427   /**
 428    * Disconnects this docshell's editor from its window, and stores the
 429    * editor data in the open document's session history entry.  This
 430    * should be called only during page transitions.
 431    */
 432   [noscript, notxpcom] void DetachEditorFromWindow();
 433
 434   /**
 435    * Propagated to the print preview document viewer.  Must only be called on
 436    * a document viewer that has been initialized for print preview.
 437    */
 438   void exitPrintPreview();
 439
 440   /**
 441    * The ID of the docshell in the session history.
 442    */
 443   readonly attribute nsIDRef historyID;
 444
 445   /**
 446    * Helper method for accessing this value from C++
 447    */
 448   [noscript, notxpcom] nsIDRef HistoryID();
 449
 450   /**
 451    * Create a new about:blank document and content viewer.
 452    * @param aPrincipal the principal to use for the new document.
 453    * @param aPartitionedPrincipal the partitioned principal to use for the new
 454    *        document.
 455    * @param aCsp the CSP to use for the new document.
 456    */
 457   void createAboutBlankContentViewer(in nsIPrincipal aPrincipal,
 458                                      in nsIPrincipal aPartitionedPrincipal,
 459                                      [optional] in nsIContentSecurityPolicy aCSP);
 460
 461   /**
 462    * Upon getting, returns the canonical encoding label of the document
 463    * currently loaded into this docshell.
 464    */
 465   readonly attribute ACString charset;
 466
 467   void forceEncodingDetection();
 468
 469   /**
 470    * In a child docshell, this is the charset of the parent docshell
 471    */
 472   [noscript, notxpcom, nostdcall] void setParentCharset(
 473     in Encoding parentCharset,
 474     in int32_t parentCharsetSource,
 475     in nsIPrincipal parentCharsetPrincipal);
 476   [noscript, notxpcom, nostdcall] void getParentCharset(
 477     out Encoding parentCharset,
 478     out int32_t parentCharsetSource,
 479     out nsIPrincipal parentCharsetPrincipal);
 480
 481   /**
 482    * Whether the docShell records profile timeline markers at the moment
 483    */
 484   [infallible] attribute boolean recordProfileTimelineMarkers;
 485
 486   /**
 487    * Return a DOMHighResTimeStamp representing the number of
 488    * milliseconds from an arbitrary point in time.  The reference
 489    * point is shared by all DocShells and is also used by timestamps
 490    * on markers.
 491    */
 492   DOMHighResTimeStamp now();
 493
 494   /**
 495    * Returns and flushes the profile timeline markers gathered by the docShell
 496    */
 497   [implicit_jscontext]
 498   jsval popProfileTimelineMarkers();
 499
 500   /**
 501    * Add an observer to the list of parties to be notified when this docshell's
 502    * private browsing status is changed. |obs| must support weak references.
 503    */
 504   void addWeakPrivacyTransitionObserver(in nsIPrivacyTransitionObserver obs);
 505
 506   /**
 507    * Add an observer to the list of parties to be notified when reflows are
 508    * occurring. |obs| must support weak references.
 509    */
 510   void addWeakReflowObserver(in nsIReflowObserver obs);
 511
 512   /**
 513    * Remove an observer from the list of parties to be notified about reflows.
 514    */
 515   void removeWeakReflowObserver(in nsIReflowObserver obs);
 516
 517   /**
 518    * Notify all attached observers that a reflow has just occurred.
 519    *
 520    * @param interruptible if true, the reflow was interruptible.
 521    * @param start         timestamp when reflow started, in milliseconds since
 522    *                      navigationStart (accurate to 1/1000 of a ms)
 523    * @param end           timestamp when reflow ended, in milliseconds since
 524    *                      navigationStart (accurate to 1/1000 of a ms)
 525    */
 526   [noscript] void notifyReflowObservers(in bool interruptible,
 527                                         in DOMHighResTimeStamp start,
 528                                         in DOMHighResTimeStamp end);
 529
 530   /**
 531    * Add an observer to the list of parties to be notified when scroll position
 532    * of some elements is changed.
 533    */
 534   [noscript] void addWeakScrollObserver(in nsIScrollObserver obs);
 535
 536   /**
 537    * Add an observer to the list of parties to be notified when scroll position
 538    * of some elements is changed.
 539    */
 540   [noscript] void removeWeakScrollObserver(in nsIScrollObserver obs);
 541
 542   /**
 543    * Notify all attached observers that the scroll position of some element
 544    * has changed.
 545    */
 546   [noscript] void notifyScrollObservers();
 547
 548   /**
 549    * Returns true if this docshell is the top level content docshell.
 550    */
 551   [infallible] readonly attribute boolean isTopLevelContentDocShell;
 552
 553   /**
 554    * Like nsIDocShellTreeItem::GetSameTypeParent, except this ignores <iframe
 555    * mozbrowser> boundaries. Which no longer exist.
 556    *
 557    * @deprecated: Use `BrowsingContext::GetParent()` in the future.
 558    */
 559   nsIDocShell getSameTypeInProcessParentIgnoreBrowserBoundaries();
 560
 561   /**
 562    * True iff asynchronous panning and zooming is enabled for this
 563    * docshell.
 564    */
 565   readonly attribute bool asyncPanZoomEnabled;
 566
 567   /**
 568    * Are plugins allowed in the current document loaded in this docshell ?
 569    * (if there is one). This depends on whether plugins are allowed by this
 570    * docshell itself or if the document is sandboxed and hence plugins should
 571    * not be allowed.
 572    */
 573   [noscript, notxpcom] bool pluginsAllowedInCurrentDoc();
 574
 575   /**
 576    * Indicates whether the UI may enable the character encoding menu. The UI
 577    * must disable the menu when this property is false.
 578    */
 579   [infallible] readonly attribute boolean mayEnableCharacterEncodingMenu;
 580
 581            attribute  nsIEditor editor;
 582   readonly attribute  boolean   editable;             /* this docShell is editable */
 583   readonly attribute  boolean   hasEditingSession;    /* this docShell has an editing session */
 584
 585   /**
 586    * Make this docShell editable, setting a flag that causes
 587    * an editor to get created, either immediately, or after
 588    * a url has been loaded.
 589    *      @param  inWaitForUriLoad    true to wait for a URI before
 590    *                                  creating the editor.
 591    */
 592   void makeEditable(in boolean inWaitForUriLoad);
 593
 594   /**
 595    * Returns false for mLSHE, true for mOSHE
 596    */
 597   boolean getCurrentSHEntry(out nsISHEntry aEntry);
 598
 599   /**
 600     * Cherry picked parts of nsIController.
 601     * They are here, because we want to call these functions
 602     * from JS.
 603     */
 604   boolean isCommandEnabled(in string command);
 605   [can_run_script]
 606   void doCommand(in string command);
 607   [can_run_script]
 608   void doCommandWithParams(in string command, in nsICommandParams aParams);
 609
 610   /**
 611    * Invisible DocShell are dummy construct to simulate DOM windows
 612    * without any actual visual representation. They have to be marked
 613    * at construction time, to avoid any painting activity.
 614    */
 615   [noscript, notxpcom] bool IsInvisible();
 616   [noscript, notxpcom] void SetInvisible(in bool aIsInvisibleDocshell);
 617
 618 /**
 619  * Get the script global for the document in this docshell.
 620 */
 621   [noscript,notxpcom,nostdcall] nsIScriptGlobalObject GetScriptGlobalObject();
 622
 623   [noscript,notxpcom,nostdcall] Document getExtantDocument();
 624
 625   /**
 626    * Notify DocShell when the browser is about to start executing JS, and after
 627    * that execution has stopped.  This only occurs when the Timeline devtool
 628    * is collecting information.
 629    */
 630   [noscript,notxpcom,nostdcall] void notifyJSRunToCompletionStart(in string aReason,
 631                                                                   in AString functionName,
 632                                                                   in AString fileName,
 633                                                                   in unsigned long lineNumber,
 634                                                                   in jsval asyncStack,
 635                                                                   in string asyncCause);
 636   [noscript,notxpcom,nostdcall] void notifyJSRunToCompletionStop();
 637
 638   /**
 639    * This attribute determines whether a document which is not about:blank has
 640    * already be loaded by this docShell.
 641    */
 642   [infallible] readonly attribute boolean hasLoadedNonBlankURI;
 643
 644   /**
 645    * Allow usage of -moz-window-dragging:drag for content docshells.
 646    * True for top level chrome docshells. Throws if set to false with
 647    * top level chrome docshell.
 648    */
 649   attribute boolean windowDraggingAllowed;
 650
 651   /**
 652    * Sets/gets the current scroll restoration mode.
 653    * @see https://html.spec.whatwg.org/#dom-history-scroll-restoration
 654    */
 655   attribute boolean currentScrollRestorationIsManual;
 656
 657   /**
 658    * Setter and getter for the origin attributes living on this docshell.
 659    */
 660   [implicit_jscontext]
 661   jsval getOriginAttributes();
 662
 663   [implicit_jscontext]
 664   void setOriginAttributes(in jsval aAttrs);
 665
 666   /**
 667    * The editing session for this docshell.
 668    */
 669   readonly attribute nsIEditingSession editingSession;
 670
 671   /**
 672    * The browser child for this docshell.
 673    */
 674   [binaryname(ScriptableBrowserChild)] readonly attribute nsIBrowserChild browserChild;
 675   [noscript,notxpcom,nostdcall] BrowserChildRef GetBrowserChild();
 676
 677   [noscript,nostdcall,notxpcom] nsCommandManager GetCommandManager();
 678
 679   cenum MetaViewportOverride: 8 {
 680     /**
 681      * Override platform/pref default behaviour and force-disable support for
 682      * <meta name="viewport">.
 683      */
 684     META_VIEWPORT_OVERRIDE_DISABLED = 0,
 685     /**
 686      * Override platform/pref default behaviour and force-enable support for
 687      * <meta name="viewport">.
 688      */
 689     META_VIEWPORT_OVERRIDE_ENABLED = 1,
 690     /**
 691      * Don't override the platform/pref default behaviour for support for
 692      * <meta name="viewport">.
 693      */
 694     META_VIEWPORT_OVERRIDE_NONE = 2,
 695   };
 696
 697   /**
 698    * This allows chrome to override the default choice of whether the
 699    * <meta name="viewport"> tag is respected in a specific docshell.
 700    * Possible values are listed above.
 701    */
 702   [infallible, setter_can_run_script] attribute nsIDocShell_MetaViewportOverride metaViewportOverride;
 703
 704   /**
 705    * Attribute that determines whether tracking protection is enabled.
 706    */
 707   attribute boolean useTrackingProtection;
 708
 709  /**
 710   * Fire a dummy location change event asynchronously.
 711   */
 712   [noscript] void dispatchLocationChangeEvent();
 713
 714
 715   /**
 716    * Start delayed autoplay media which are in the current document.
 717    */
 718   [noscript] void startDelayedAutoplayMediaComponents();
 719
 720   /**
 721    * Take ownership of the ClientSource representing an initial about:blank
 722    * document that was never needed.  As an optimization we avoid creating
 723    * this document if no code calls GetDocument(), but we still need a
 724    * ClientSource object to represent the about:blank window.  This may return
 725    * nullptr; for example if the docshell has created a real window and document
 726    * already.
 727    */
 728   [noscript, nostdcall, notxpcom]
 729   UniqueClientSource TakeInitialClientSource();
 730
 731   void setColorMatrix(in Array<float> aMatrix);
 732
 733   /**
 734    * Returns true if the current load is a forced reload,
 735    * e.g. started by holding shift whilst triggering reload.
 736    */
 737   readonly attribute bool isForceReloading;
 738
 739   Array<float> getColorMatrix();
 740
 741 %{C++
 742   /**
 743    * These methods call nsDocShell::GetHTMLEditorInternal() and
 744    * nsDocShell::SetHTMLEditorInternal() with static_cast.
 745    */
 746   mozilla::HTMLEditor* GetHTMLEditor();
 747   nsresult SetHTMLEditor(mozilla::HTMLEditor* aHTMLEditor);
 748 %}
 749
 750   /**
 751    * The message manager for this docshell.  This does not throw, but
 752    * can return null if the docshell has no message manager.
 753    */
 754   [infallible] readonly attribute ContentFrameMessageManager messageManager;
 755
 756    /**
 757    * This returns a Promise which resolves to a boolean. True when the
 758    * document has Tracking Content that has been blocked from loading, false
 759    * otherwise.
 760    */
 761   Promise getHasTrackingContentBlocked();
 762
 763   /**
 764    * Return whether this docshell is "attempting to navigate" in the
 765    * sense that's relevant to document.open.
 766    */
 767   [notxpcom, nostdcall] readonly attribute boolean isAttemptingToNavigate;
 768
 769   /*
 770    * Whether or not this docshell is executing a nsIWebNavigation navigation
 771    * method.
 772    *
 773    * This will be true when the following methods are executing:
 774    *   nsIWebNavigation.binaryLoadURI
 775    *   nsIWebNavigation.goBack
 776    *   nsIWebNavigation.goForward
 777    *   nsIWebNavigation.gotoIndex
 778    *   nsIWebNavigation.loadURI
 779    */
 780   [infallible] readonly attribute boolean isNavigating;
 781
 782   /**
 783    * @see nsISHEntry synchronizeLayoutHistoryState().
 784    */
 785   void synchronizeLayoutHistoryState();
 786
 787   /**
 788    * This attempts to save any applicable layout history state (like
 789    * scroll position) in the nsISHEntry. This is normally done
 790    * automatically when transitioning from page to page in the
 791    * same process. We expose this function to support transitioning
 792    * from page to page across processes as a workaround for bug 1630234
 793    * until session history state is moved into the parent process.
 794    */
 795   void persistLayoutHistoryState();
 796 };