The Tor Browser / file revision

 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */

 /* This Source Code Form is subject to the terms of the Mozilla Public

  * License, v. 2.0. If a copy of the MPL was not distributed with this

  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

 #ifndef nsIDocument_h___

 #define nsIDocument_h___

 #include "mozFlushType.h"                // for enum

 #include "nsAutoPtr.h"                   // for member

 #include "nsCOMArray.h"                  // for member

 #include "nsCRT.h"                       // for NS_DECL_AND_IMPL_ZEROING_OPERATOR_NEW

 #include "nsCompatibility.h"             // for member

 #include "nsCOMPtr.h"                    // for member

 #include "nsGkAtoms.h"                   // for static class members

 #include "nsIDocumentObserver.h"         // for typedef (nsUpdateType)

 #include "nsILoadGroup.h"                // for member (in nsCOMPtr)

 #include "nsINode.h"                     // for base class

 #include "nsIScriptGlobalObject.h"       // for member (in nsCOMPtr)

 #include "nsPIDOMWindow.h"               // for use in inline functions

 #include "nsPropertyTable.h"             // for member

 #include "nsTHashtable.h"                // for member

 #include "nsWeakReference.h"

 #include "mozilla/dom/DocumentBinding.h"

 #include "mozilla/WeakPtr.h"

 #include "Units.h"

 #include "nsExpirationTracker.h"

 #include "nsClassHashtable.h"

 class imgIRequest;

 class nsAString;

 class nsBindingManager;

 class nsCSSStyleSheet;

 class nsIDocShell;

 class nsDocShell;

 class nsDOMNavigationTiming;

 class nsFrameLoader;

 class nsHTMLCSSStyleSheet;

 class nsHTMLDocument;

 class nsHTMLStyleSheet;

 class nsIAtom;

 class nsIBFCacheEntry;

 class nsIBoxObject;

 class nsIChannel;

 class nsIContent;

 class nsIContentSink;

 class nsIDocShell;

 class nsIDocumentEncoder;

 class nsIDocumentObserver;

 class nsIDOMDocument;

 class nsIDOMDocumentFragment;

 class nsIDOMDocumentType;

 class nsIDOMElement;

 class nsIDOMNodeFilter;

 class nsIDOMNodeList;

 class nsIDOMXPathExpression;

 class nsIDOMXPathNSResolver;

 class nsIHTMLCollection;

 class nsILayoutHistoryState;

 class nsILoadContext;

 class nsIObjectLoadingContent;

 class nsIObserver;

 class nsIPresShell;

 class nsIPrincipal;

 class nsIRequest;

 class nsIStreamListener;

 class nsIStructuredCloneContainer;

 class nsIStyleRule;

 class nsIStyleSheet;

 class nsIURI;

 class nsIVariant;

 class nsViewManager;

 class nsPresContext;

 class nsRange;

 class nsScriptLoader;

 class nsSMILAnimationController;

 class nsStyleSet;

 class nsTextNode;

 class nsWindowSizes;

 class nsSmallVoidArray;

 class nsDOMCaretPosition;

 class nsViewportInfo;

 class nsIGlobalObject;

 class nsCSSSelectorList;

 namespace mozilla {

 class ErrorResult;

 class EventStates;

 namespace css {

 class Loader;

 class ImageLoader;

 } // namespace css

 namespace dom {

 class Attr;

 class CDATASection;

 class Comment;

 struct CustomElementDefinition;

 class DocumentFragment;

 class DocumentType;

 class DOMImplementation;

 class DOMStringList;

 class Element;

 struct ElementRegistrationOptions;

 class Event;

 class EventTarget;

 class FrameRequestCallback;

 class HTMLBodyElement;

 struct LifecycleCallbackArgs;

 class Link;

 class GlobalObject;

 class NodeFilter;

 class NodeIterator;

 class ProcessingInstruction;

 class StyleSheetList;

 class Touch;

 class TouchList;

 class TreeWalker;

 class UndoManager;

 class XPathEvaluator;

 template<typename> class OwningNonNull;

 template<typename> class Sequence;

 template<typename, typename> class CallbackObjectHolder;

 typedef CallbackObjectHolder<NodeFilter, nsIDOMNodeFilter> NodeFilterHolder;

 } // namespace dom

 } // namespace mozilla

 #define NS_IDOCUMENT_IID \

 { 0x906d05e7, 0x39af, 0x4ff0, \

   { 0xbc, 0xcd, 0x30, 0x0c, 0x7f, 0xeb, 0x86, 0x21 } }

 // Flag for AddStyleSheet().

 #define NS_STYLESHEET_FROM_CATALOG                (1 << 0)

 // Enum for requesting a particular type of document when creating a doc

 enum DocumentFlavor {

   DocumentFlavorLegacyGuess, // compat with old code until made HTML5-compliant

   DocumentFlavorHTML, // HTMLDocument with HTMLness bit set to true

   DocumentFlavorSVG // SVGDocument

 };

 // Document states

 // RTL locale: specific to the XUL localedir attribute

 #define NS_DOCUMENT_STATE_RTL_LOCALE              NS_DEFINE_EVENT_STATE_MACRO(0)

 // Window activation status

 #define NS_DOCUMENT_STATE_WINDOW_INACTIVE         NS_DEFINE_EVENT_STATE_MACRO(1)

 // Some function forward-declarations

 class nsContentList;

 already_AddRefed<nsContentList>

 NS_GetContentList(nsINode* aRootNode,

                   int32_t aMatchNameSpaceId,

                   const nsAString& aTagname);

 //----------------------------------------------------------------------

 // Document interface.  This is implemented by all document objects in

 // Gecko.

 class nsIDocument : public nsINode

 {

   typedef mozilla::dom::GlobalObject GlobalObject;

 public:

   typedef mozilla::dom::Element Element;

   NS_DECLARE_STATIC_IID_ACCESSOR(NS_IDOCUMENT_IID)

   NS_DECL_AND_IMPL_ZEROING_OPERATOR_NEW

 #ifdef MOZILLA_INTERNAL_API

   nsIDocument();

 #endif

   /**

    * Let the document know that we're starting to load data into it.

    * @param aCommand The parser command. Must not be null.

    *                 XXXbz It's odd to have that here.

    * @param aChannel The channel the data will come from. The channel must be

    *                 able to report its Content-Type.

    * @param aLoadGroup The loadgroup this document should use from now on.

    *                   Note that the document might not be the only thing using

    *                   this loadgroup.

    * @param aContainer The container this document is in.  This may be null.

    *                   XXXbz maybe we should make it more explicit (eg make the

    *                   container an nsIWebNavigation or nsIDocShell or

    *                   something)?

    * @param [out] aDocListener the listener to pump data from the channel into.

    *                           Generally this will be the parser this document

    *                           sets up, or some sort of data-handler for media

    *                           documents.

    * @param aReset whether the document should call Reset() on itself.  If this

    *               is false, the document will NOT set its principal to the

    *               channel's owner, will not clear any event listeners that are

    *               already set on it, etc.

    * @param aSink The content sink to use for the data.  If this is null and

    *              the document needs a content sink, it will create one based

    *              on whatever it knows about the data it's going to load.

    *              This MUST be null if the underlying document is an HTML

    *              document. Even in the XML case, please don't add new calls

    *              with non-null sink.

    *

    * Once this has been called, the document will return false for

    * MayStartLayout() until SetMayStartLayout(true) is called on it.  Making

    * sure this happens is the responsibility of the caller of

    * StartDocumentLoad().

    */  

   virtual nsresult StartDocumentLoad(const char* aCommand,

                                      nsIChannel* aChannel,

                                      nsILoadGroup* aLoadGroup,

                                      nsISupports* aContainer,

                                      nsIStreamListener **aDocListener,

                                      bool aReset,

                                      nsIContentSink* aSink = nullptr) = 0;

   virtual void StopDocumentLoad() = 0;

   /**

    * Signal that the document title may have changed

    * (see nsDocument::GetTitle).

    * @param aBoundTitleElement true if an HTML or SVG <title> element

    * has just been bound to the document.

    */

   virtual void NotifyPossibleTitleChange(bool aBoundTitleElement) = 0;

   /**

    * Return the URI for the document. May return null.

    *

    * The value returned corresponds to the "document's current address" in

    * HTML5.  As such, it may change over the lifetime of the document, for

    * instance as a result of a call to pushState() or replaceState().

    */

   nsIURI* GetDocumentURI() const

   {

     return mDocumentURI;

   }

   /**

    * Return the original URI of the document.  This is the same as the

    * document's URI unless history.pushState() or replaceState() is invoked on

    * the document.

    *

    * This method corresponds to the "document's address" in HTML5 and, once

    * set, doesn't change over the lifetime of the document.

    */

   nsIURI* GetOriginalURI() const

   {

     return mOriginalURI;

   }

   /**

    * Set the URI for the document.  This also sets the document's original URI,

    * if it's null.

    */

   virtual void SetDocumentURI(nsIURI* aURI) = 0;

   /**

    * Set the URI for the document loaded via XHR, when accessed from

    * chrome privileged script.

    */

   virtual void SetChromeXHRDocURI(nsIURI* aURI) = 0;

   /**

    * Set the base URI for the document loaded via XHR, when accessed from

    * chrome privileged script.

    */

   virtual void SetChromeXHRDocBaseURI(nsIURI* aURI) = 0;

   /**

    * Set the principal responsible for this document.

    */

   virtual void SetPrincipal(nsIPrincipal *aPrincipal) = 0;

   /**

    * Return the LoadGroup for the document. May return null.

    */

   already_AddRefed<nsILoadGroup> GetDocumentLoadGroup() const

   {

     nsCOMPtr<nsILoadGroup> group = do_QueryReferent(mDocumentLoadGroup);

     return group.forget();

   }

   /**

    * Return the base URI for relative URIs in the document (the document uri

    * unless it's overridden by SetBaseURI, HTML <base> tags, etc.).  The

    * returned URI could be null if there is no document URI.  If the document

    * is a srcdoc document, return the parent document's base URL.

    */

   nsIURI* GetDocBaseURI() const

   {

     if (mIsSrcdocDocument && mParentDocument) {

       return mParentDocument->GetDocBaseURI();

     }

     return mDocumentBaseURI ? mDocumentBaseURI : mDocumentURI;

   }

   virtual already_AddRefed<nsIURI> GetBaseURI(bool aTryUseXHRDocBaseURI = false) const MOZ_OVERRIDE;

   virtual nsresult SetBaseURI(nsIURI* aURI) = 0;

   /**

    * Get/Set the base target of a link in a document.

    */

   virtual void GetBaseTarget(nsAString &aBaseTarget) = 0;

   void SetBaseTarget(const nsString& aBaseTarget) {

     mBaseTarget = aBaseTarget;

   }

   /**

    * Return a standard name for the document's character set.

    */

   const nsCString& GetDocumentCharacterSet() const

   {

     return mCharacterSet;

   }

   /**

    * Set the document's character encoding. |aCharSetID| should be canonical. 

    * That is, callers are responsible for the charset alias resolution. 

    */

   virtual void SetDocumentCharacterSet(const nsACString& aCharSetID) = 0;

   int32_t GetDocumentCharacterSetSource() const

   {

     return mCharacterSetSource;

   }

   // This method MUST be called before SetDocumentCharacterSet if

   // you're planning to call both.

   void SetDocumentCharacterSetSource(int32_t aCharsetSource)

   {

     mCharacterSetSource = aCharsetSource;

   }

   /**

    * Add an observer that gets notified whenever the charset changes.

    */

   virtual nsresult AddCharSetObserver(nsIObserver* aObserver) = 0;

   /**

    * Remove a charset observer.

    */

   virtual void RemoveCharSetObserver(nsIObserver* aObserver) = 0;

   /**

    * This gets fired when the element that an id refers to changes.

    * This fires at difficult times. It is generally not safe to do anything

    * which could modify the DOM in any way. Use

    * nsContentUtils::AddScriptRunner.

    * @return true to keep the callback in the callback set, false

    * to remove it.

    */

   typedef bool (* IDTargetObserver)(Element* aOldElement,

                                       Element* aNewelement, void* aData);

   /**

    * Add an IDTargetObserver for a specific ID. The IDTargetObserver

    * will be fired whenever the content associated with the ID changes

    * in the future. If aForImage is true, mozSetImageElement can override

    * what content is associated with the ID. In that case the IDTargetObserver

    * will be notified at those times when the result of LookupImageElement

    * changes.

    * At most one (aObserver, aData, aForImage) triple can be

    * registered for each ID.

    * @return the content currently associated with the ID.

    */

   virtual Element* AddIDTargetObserver(nsIAtom* aID, IDTargetObserver aObserver,

                                        void* aData, bool aForImage) = 0;

   /**

    * Remove the (aObserver, aData, aForImage) triple for a specific ID, if

    * registered.

    */

   virtual void RemoveIDTargetObserver(nsIAtom* aID, IDTargetObserver aObserver,

                                       void* aData, bool aForImage) = 0;

   /**

    * Get the Content-Type of this document.

    * (This will always return NS_OK, but has this signature to be compatible

    *  with nsIDOMDocument::GetContentType())

    */

   NS_IMETHOD GetContentType(nsAString& aContentType) = 0;

   /**

    * Set the Content-Type of this document.

    */

   virtual void SetContentType(const nsAString& aContentType) = 0;

   /**

    * Return the language of this document.

    */

   void GetContentLanguage(nsAString& aContentLanguage) const

   {

     CopyASCIItoUTF16(mContentLanguage, aContentLanguage);

   }

   // The states BidiEnabled and MathMLEnabled should persist across multiple views

   // (screen, print) of the same document.

   /**

    * Check if the document contains bidi data.

    * If so, we have to apply the Unicode Bidi Algorithm.

    */

   bool GetBidiEnabled() const

   {

     return mBidiEnabled;

   }

   /**

    * Indicate the document contains bidi data.

    * Currently, we cannot disable bidi, because once bidi is enabled,

    * it affects a frame model irreversibly, and plays even though

    * the document no longer contains bidi data.

    */

   void SetBidiEnabled()

   {

     mBidiEnabled = true;

   }

   /**

    * Check if the document contains (or has contained) any MathML elements.

    */

   bool GetMathMLEnabled() const

   {

     return mMathMLEnabled;

   }

   void SetMathMLEnabled()

   {

     mMathMLEnabled = true;

   }

   /**

    * Ask this document whether it's the initial document in its window.

    */

   bool IsInitialDocument() const

   {

     return mIsInitialDocumentInWindow;

   }

   /**

    * Tell this document that it's the initial document in its window.  See

    * comments on mIsInitialDocumentInWindow for when this should be called.

    */

   void SetIsInitialDocument(bool aIsInitialDocument)

   {

     mIsInitialDocumentInWindow = aIsInitialDocument;

   }

   /**

    * Get the bidi options for this document.

    * @see nsBidiUtils.h

    */

   uint32_t GetBidiOptions() const

   {

     return mBidiOptions;

   }

   /**

    * Set the bidi options for this document.  This just sets the bits;

    * callers are expected to take action as needed if they want this

    * change to actually change anything immediately.

    * @see nsBidiUtils.h

    */

   void SetBidiOptions(uint32_t aBidiOptions)

   {

     mBidiOptions = aBidiOptions;

   }

   /**

    * Get the has mixed active content loaded flag for this document.

    */

   bool GetHasMixedActiveContentLoaded()

   {

     return mHasMixedActiveContentLoaded;

   }

   /**

    * Set the has mixed active content loaded flag for this document.

    */

   void SetHasMixedActiveContentLoaded(bool aHasMixedActiveContentLoaded)

   {

     mHasMixedActiveContentLoaded = aHasMixedActiveContentLoaded;

   }

   /**

    * Get mixed active content blocked flag for this document.

    */

   bool GetHasMixedActiveContentBlocked()

   {

     return mHasMixedActiveContentBlocked;

   }

   /**

    * Set the mixed active content blocked flag for this document.

    */

   void SetHasMixedActiveContentBlocked(bool aHasMixedActiveContentBlocked)

   {

     mHasMixedActiveContentBlocked = aHasMixedActiveContentBlocked;

   }

   /**

    * Get the has mixed display content loaded flag for this document.

    */

   bool GetHasMixedDisplayContentLoaded()

   {

     return mHasMixedDisplayContentLoaded;

   }

   /**

    * Set the has mixed display content loaded flag for this document.

    */

   void SetHasMixedDisplayContentLoaded(bool aHasMixedDisplayContentLoaded)

   {

     mHasMixedDisplayContentLoaded = aHasMixedDisplayContentLoaded;

   }

   /**

    * Get mixed display content blocked flag for this document.

    */

   bool GetHasMixedDisplayContentBlocked()

   {

     return mHasMixedDisplayContentBlocked;

   }

   /**

    * Set the mixed display content blocked flag for this document.

    */

   void SetHasMixedDisplayContentBlocked(bool aHasMixedDisplayContentBlocked)

   {

     mHasMixedDisplayContentBlocked = aHasMixedDisplayContentBlocked;

   }

   /**

    * Get the sandbox flags for this document.

    * @see nsSandboxFlags.h for the possible flags

    */

   uint32_t GetSandboxFlags() const

   {

     return mSandboxFlags;

   }

   /**

    * Set the sandbox flags for this document.

    * @see nsSandboxFlags.h for the possible flags

    */

   void SetSandboxFlags(uint32_t sandboxFlags)

   {

     mSandboxFlags = sandboxFlags;

   }

   /**

    * Access HTTP header data (this may also get set from other

    * sources, like HTML META tags).

    */

   virtual void GetHeaderData(nsIAtom* aHeaderField, nsAString& aData) const = 0;

   virtual void SetHeaderData(nsIAtom* aheaderField, const nsAString& aData) = 0;

   /**

    * Create a new presentation shell that will use aContext for its

    * presentation context (presentation contexts <b>must not</b> be

    * shared among multiple presentation shells). The caller of this

    * method is responsible for calling BeginObservingDocument() on the

    * presshell if the presshell should observe document mutations.

    */

   virtual already_AddRefed<nsIPresShell> CreateShell(nsPresContext* aContext,

                                                      nsViewManager* aViewManager,

                                                      nsStyleSet* aStyleSet) = 0;

   virtual void DeleteShell() = 0;

   nsIPresShell* GetShell() const

   {

     return GetBFCacheEntry() ? nullptr : mPresShell;

   }

   void DisallowBFCaching()

   {

     NS_ASSERTION(!mBFCacheEntry, "We're already in the bfcache!");

     mBFCacheDisallowed = true;

   }

   bool IsBFCachingAllowed() const

   {

     return !mBFCacheDisallowed;

   }

   void SetBFCacheEntry(nsIBFCacheEntry* aEntry)

   {

     NS_ASSERTION(IsBFCachingAllowed() || !aEntry,

                  "You should have checked!");

     mBFCacheEntry = aEntry;

   }

   nsIBFCacheEntry* GetBFCacheEntry() const

   {

     return mBFCacheEntry;

   }

   /**

    * Return the parent document of this document. Will return null

    * unless this document is within a compound document and has a

    * parent. Note that this parent chain may cross chrome boundaries.

    */

   nsIDocument *GetParentDocument() const

   {

     return mParentDocument;

   }

   /**

    * Set the parent document of this document.

    */

   void SetParentDocument(nsIDocument* aParent)

   {

     mParentDocument = aParent;

   }

   /**

    * Are plugins allowed in this document ?

    */

   virtual nsresult GetAllowPlugins (bool* aAllowPlugins) = 0;

   /**

    * Set the sub document for aContent to aSubDoc.

    */

   virtual nsresult SetSubDocumentFor(Element* aContent,

                                      nsIDocument* aSubDoc) = 0;

   /**

    * Get the sub document for aContent

    */

   virtual nsIDocument *GetSubDocumentFor(nsIContent *aContent) const = 0;

   /**

    * Find the content node for which aDocument is a sub document.

    */

   virtual Element* FindContentForSubDocument(nsIDocument* aDocument) const = 0;

   /**

    * Return the doctype for this document.

    */

   mozilla::dom::DocumentType* GetDoctype() const;

   /**

    * Return the root element for this document.

    */

   Element* GetRootElement() const;

   virtual nsViewportInfo GetViewportInfo(const mozilla::ScreenIntSize& aDisplaySize) = 0;

   /**

    * True iff this doc will ignore manual character encoding overrides.

    */

   virtual bool WillIgnoreCharsetOverride() {

     return true;

   }

   /**

    * Return whether the document was created by a srcdoc iframe.

    */

   bool IsSrcdocDocument() const {

     return mIsSrcdocDocument;

   }

   /**

    * Sets whether the document was created by a srcdoc iframe.

    */

   void SetIsSrcdocDocument(bool aIsSrcdocDocument) {

     mIsSrcdocDocument = aIsSrcdocDocument;

   }

   /*

    * Gets the srcdoc string from within the channel (assuming both exist).

    * Returns a void string if this isn't a srcdoc document or if

    * the channel has not been set.

    */

   nsresult GetSrcdocData(nsAString& aSrcdocData);

   bool DidDocumentOpen() {

     return mDidDocumentOpen;

   }

 protected:

   virtual Element *GetRootElementInternal() const = 0;

 private:

   class SelectorCacheKey

   {

     public:

       SelectorCacheKey(const nsAString& aString) : mKey(aString)

       {

         MOZ_COUNT_CTOR(SelectorCacheKey);

       }

       nsString mKey;

       nsExpirationState mState;

       nsExpirationState* GetExpirationState() { return &mState; }

       ~SelectorCacheKey()

       {

         MOZ_COUNT_DTOR(SelectorCacheKey);

       }

   };

   class SelectorCacheKeyDeleter;

 public:

   class SelectorCache MOZ_FINAL

     : public nsExpirationTracker<SelectorCacheKey, 4>

   {

     public:

       SelectorCache();

       // CacheList takes ownership of aSelectorList.

       void CacheList(const nsAString& aSelector, nsCSSSelectorList* aSelectorList);

       virtual void NotifyExpired(SelectorCacheKey* aSelector) MOZ_OVERRIDE;

       // We do not call MarkUsed because it would just slow down lookups and

       // because we're OK expiring things after a few seconds even if they're

       // being used.  Returns whether we actually had an entry for aSelector.

       // If we have an entry and *aList is null, that indicates that aSelector

       // has already been parsed and is not a syntactically valid selector.

       bool GetList(const nsAString& aSelector, nsCSSSelectorList** aList)

       {

         return mTable.Get(aSelector, aList);

       }

       ~SelectorCache()

       {

         AgeAllGenerations();

       }

     private:

       nsClassHashtable<nsStringHashKey, nsCSSSelectorList> mTable;

   };

   SelectorCache& GetSelectorCache()

   {

     return mSelectorCache;

   }

   // Get the root <html> element, or return null if there isn't one (e.g.

   // if the root isn't <html>)

   Element* GetHtmlElement() const;

   // Returns the first child of GetHtmlContent which has the given tag,

   // or nullptr if that doesn't exist.

   Element* GetHtmlChildElement(nsIAtom* aTag);

   // Get the canonical <body> element, or return null if there isn't one (e.g.

   // if the root isn't <html> or if the <body> isn't there)

   mozilla::dom::HTMLBodyElement* GetBodyElement();

   // Get the canonical <head> element, or return null if there isn't one (e.g.

   // if the root isn't <html> or if the <head> isn't there)

   Element* GetHeadElement() {

     return GetHtmlChildElement(nsGkAtoms::head);

   }

   /**

    * Accessors to the collection of stylesheets owned by this document.

    * Style sheets are ordered, most significant last.

    */

   /**

    * Get the number of stylesheets

    *

    * @return the number of stylesheets

    * @throws no exceptions

    */

   virtual int32_t GetNumberOfStyleSheets() const = 0;

   /**

    * Get a particular stylesheet

    * @param aIndex the index the stylesheet lives at.  This is zero-based

    * @return the stylesheet at aIndex.  Null if aIndex is out of range.

    * @throws no exceptions

    */

   virtual nsIStyleSheet* GetStyleSheetAt(int32_t aIndex) const = 0;

   /**

    * Insert a sheet at a particular spot in the stylesheet list (zero-based)

    * @param aSheet the sheet to insert

    * @param aIndex the index to insert at.  This index will be

    *   adjusted for the "special" sheets.

    * @throws no exceptions

    */

   virtual void InsertStyleSheetAt(nsIStyleSheet* aSheet, int32_t aIndex) = 0;

   /**

    * Get the index of a particular stylesheet.  This will _always_

    * consider the "special" sheets as part of the sheet list.

    * @param aSheet the sheet to get the index of

    * @return aIndex the index of the sheet in the full list

    */

   virtual int32_t GetIndexOfStyleSheet(nsIStyleSheet* aSheet) const = 0;

   /**

    * Replace the stylesheets in aOldSheets with the stylesheets in

    * aNewSheets. The two lists must have equal length, and the sheet

    * at positon J in the first list will be replaced by the sheet at

    * position J in the second list.  Some sheets in the second list

    * may be null; if so the corresponding sheets in the first list

    * will simply be removed.

    */

   virtual void UpdateStyleSheets(nsCOMArray<nsIStyleSheet>& aOldSheets,

                                  nsCOMArray<nsIStyleSheet>& aNewSheets) = 0;

   /**

    * Add a stylesheet to the document

    */

   virtual void AddStyleSheet(nsIStyleSheet* aSheet) = 0;

   /**

    * Remove a stylesheet from the document

    */

   virtual void RemoveStyleSheet(nsIStyleSheet* aSheet) = 0;

   /**

    * Notify the document that the applicable state of the sheet changed

    * and that observers should be notified and style sets updated

    */

   virtual void SetStyleSheetApplicableState(nsIStyleSheet* aSheet,

                                             bool aApplicable) = 0;  

   /**

    * Just like the style sheet API, but for "catalog" sheets,

    * extra sheets inserted at the UA level.

    */

   virtual int32_t GetNumberOfCatalogStyleSheets() const = 0;

   virtual nsIStyleSheet* GetCatalogStyleSheetAt(int32_t aIndex) const = 0;

   virtual void AddCatalogStyleSheet(nsCSSStyleSheet* aSheet) = 0;

   virtual void EnsureCatalogStyleSheet(const char *aStyleSheetURI) = 0;

   enum additionalSheetType {

     eAgentSheet,

     eUserSheet,

     eAuthorSheet,

     SheetTypeCount

   };

   virtual nsresult LoadAdditionalStyleSheet(additionalSheetType aType, nsIURI* aSheetURI) = 0;

   virtual void RemoveAdditionalStyleSheet(additionalSheetType aType, nsIURI* sheetURI) = 0;

   virtual nsIStyleSheet* FirstAdditionalAuthorSheet() = 0;

   /**

    * Get this document's CSSLoader.  This is guaranteed to not return null.

    */

   mozilla::css::Loader* CSSLoader() const {

     return mCSSLoader;

   }

   /**

    * Get this document's StyleImageLoader.  This is guaranteed to not return null.

    */

   mozilla::css::ImageLoader* StyleImageLoader() const {

     return mStyleImageLoader;

   }

   /**

    * Get the channel that was passed to StartDocumentLoad or Reset for this

    * document.  Note that this may be null in some cases (eg if

    * StartDocumentLoad or Reset were never called)

    */

   virtual nsIChannel* GetChannel() const = 0;

   /**

    * Get this document's attribute stylesheet.  May return null if

    * there isn't one.

    */

   nsHTMLStyleSheet* GetAttributeStyleSheet() const {

     return mAttrStyleSheet;

   }

   /**

    * Get this document's inline style sheet.  May return null if there

    * isn't one

    */

   nsHTMLCSSStyleSheet* GetInlineStyleSheet() const {

     return mStyleAttrStyleSheet;

   }

   virtual void SetScriptGlobalObject(nsIScriptGlobalObject* aGlobalObject) = 0;

   /**

    * Get/set the object from which the context for the event/script handling can

    * be got. Normally GetScriptHandlingObject() returns the same object as

    * GetScriptGlobalObject(), but if the document is loaded as data,

    * non-null may be returned, even if GetScriptGlobalObject() returns null.

    * aHasHadScriptHandlingObject is set true if document has had the object

    * for event/script handling. Do not process any events/script if the method

    * returns null, but aHasHadScriptHandlingObject is true.

    */

   nsIScriptGlobalObject*

     GetScriptHandlingObject(bool& aHasHadScriptHandlingObject) const

   {

     aHasHadScriptHandlingObject = mHasHadScriptHandlingObject;

     return mScriptGlobalObject ? mScriptGlobalObject.get() :

                                  GetScriptHandlingObjectInternal();

   }

   virtual void SetScriptHandlingObject(nsIScriptGlobalObject* aScriptObject) = 0;

   /**

    * Get the object that is used as the scope for all of the content

    * wrappers whose owner document is this document. Unlike the script global

    * object, this will only return null when the global object for this

    * document is truly gone. Use this object when you're trying to find a

    * content wrapper in XPConnect.

    */

   virtual nsIGlobalObject* GetScopeObject() const = 0;

   virtual void SetScopeObject(nsIGlobalObject* aGlobal) = 0;

   /**

    * Return the window containing the document (the outer window).

    */

   nsPIDOMWindow *GetWindow() const

   {

     return mWindow ? mWindow->GetOuterWindow() : GetWindowInternal();

   }

   bool IsInBackgroundWindow() const

   {

     nsPIDOMWindow* outer = mWindow ? mWindow->GetOuterWindow() : nullptr;

     return outer && outer->IsBackground();

   }

   /**

    * Return the inner window used as the script compilation scope for

    * this document. If you're not absolutely sure you need this, use

    * GetWindow().

    */

   nsPIDOMWindow* GetInnerWindow() const

   {

     return mRemovedFromDocShell ? nullptr : mWindow;

   }

   /**

    * Return the outer window ID.

    */

   uint64_t OuterWindowID() const

   {

     nsPIDOMWindow *window = GetWindow();

     return window ? window->WindowID() : 0;

   }

   /**

    * Return the inner window ID.

    */

   uint64_t InnerWindowID()

   {

     nsPIDOMWindow *window = GetInnerWindow();

     return window ? window->WindowID() : 0;

   }

   /**

    * Get the script loader for this document

    */ 

   virtual nsScriptLoader* ScriptLoader() = 0;

   /**

    * Add/Remove an element to the document's id and name hashes

    */

   virtual void AddToIdTable(Element* aElement, nsIAtom* aId) = 0;

   virtual void RemoveFromIdTable(Element* aElement, nsIAtom* aId) = 0;

   virtual void AddToNameTable(Element* aElement, nsIAtom* aName) = 0;

   virtual void RemoveFromNameTable(Element* aElement, nsIAtom* aName) = 0;

   /**

    * Returns the element which either requested DOM full-screen mode, or

    * contains the element which requested DOM full-screen mode if the

    * requestee is in a subdocument. Note this element must be *in*

    * this document.

    */

   virtual Element* GetFullScreenElement() = 0;

   /**

    * Asynchronously requests that the document make aElement the fullscreen

    * element, and move into fullscreen mode. The current fullscreen element

    * (if any) is pushed onto the fullscreen element stack, and it can be

    * returned to fullscreen status by calling RestorePreviousFullScreenState().

    *

    * Note that requesting fullscreen in a document also makes the element which

    * contains this document in this document's parent document fullscreen. i.e.

    * the <iframe> or <browser> that contains this document is also mode

    * fullscreen. This happens recursively in all ancestor documents.

    */

   virtual void AsyncRequestFullScreen(Element* aElement) = 0;

   /**

    * Called when a frame in a child process has entered fullscreen or when a

    * fullscreen frame in a child process changes to another origin.

    * aFrameElement is the frame element which contains the child-process

    * fullscreen document, and aNewOrigin is the origin of the new fullscreen

    * document.

    */

   virtual nsresult RemoteFrameFullscreenChanged(nsIDOMElement* aFrameElement,

                                                 const nsAString& aNewOrigin) = 0;

   /**

    * Called when a frame in a remote child document has rolled back fullscreen

    * so that all its fullscreen element stacks are empty; we must continue the

    * rollback in this parent process' doc tree branch which is fullscreen.

    * Note that only one branch of the document tree can have its documents in

    * fullscreen state at one time. We're in inconsistent state if a

    * fullscreen document has a parent and that parent isn't fullscreen. We

    * preserve this property across process boundaries.

    */

    virtual nsresult RemoteFrameFullscreenReverted() = 0;

   /**

    * Restores the previous full-screen element to full-screen status. If there

    * is no former full-screen element, this exits full-screen, moving the

    * top-level browser window out of full-screen mode.

    */

   virtual void RestorePreviousFullScreenState() = 0;

   /**

    * Returns true if this document is in full-screen mode.

    */

   virtual bool IsFullScreenDoc() = 0;

   /**

    * Returns true if this document is a fullscreen leaf document, i.e. it

    * is in fullscreen mode and has no fullscreen children.

    */

   virtual bool IsFullscreenLeaf() = 0;

   /**

    * Returns the document which is at the root of this document's branch

    * in the in-process document tree. Returns nullptr if the document isn't

    * fullscreen.

    */

   virtual nsIDocument* GetFullscreenRoot() = 0;

   /**

    * Sets the fullscreen root to aRoot. This stores a weak reference to aRoot

    * in this document.

    */

   virtual void SetFullscreenRoot(nsIDocument* aRoot) = 0;

   /**

    * Sets whether this document is approved for fullscreen mode.

    * Documents aren't approved for fullscreen until chrome has sent a

    * "fullscreen-approved" notification with a subject which is a pointer

    * to the approved document.

    */

   virtual void SetApprovedForFullscreen(bool aIsApproved) = 0;

   /**

    * Exits documents out of DOM fullscreen mode.

    *

    * If aDocument is null, all fullscreen documents in all browser windows

    * exit fullscreen.

    *

    * If aDocument is non null, all documents from aDocument's fullscreen root

    * to the fullscreen leaf exit fullscreen. 

    *

    * Note that the fullscreen leaf is the bottom-most document which is

    * fullscreen, it may have non-fullscreen child documents. The fullscreen

    * root is usually the chrome document, but if fullscreen is content-only,

    * (see the comment in nsContentUtils.h on IsFullscreenApiContentOnly())

    * the fullscreen root will be a direct child of the chrome document, and

    * there may be other branches of the same doctree that are fullscreen.

    *

    * If aRunAsync is true, fullscreen is executed asynchronously.

    *

    * Note if aDocument is not fullscreen this function has no effect, even if

    * aDocument has fullscreen ancestors.

    */

   static void ExitFullscreen(nsIDocument* aDocument, bool aRunAsync);

   virtual void RequestPointerLock(Element* aElement) = 0;

   static void UnlockPointer(nsIDocument* aDoc = nullptr);

   //----------------------------------------------------------------------

   // Document notification API's

   /**

    * Add a new observer of document change notifications. Whenever

    * content is changed, appended, inserted or removed the observers are

    * informed.  An observer that is already observing the document must

    * not be added without being removed first.

    */

   virtual void AddObserver(nsIDocumentObserver* aObserver) = 0;

   /**

    * Remove an observer of document change notifications. This will

    * return false if the observer cannot be found.

    */

   virtual bool RemoveObserver(nsIDocumentObserver* aObserver) = 0;

   // Observation hooks used to propagate notifications to document observers.

   // BeginUpdate must be called before any batch of modifications of the

   // content model or of style data, EndUpdate must be called afterward.

   // To make this easy and painless, use the mozAutoDocUpdate helper class.

   virtual void BeginUpdate(nsUpdateType aUpdateType) = 0;

   virtual void EndUpdate(nsUpdateType aUpdateType) = 0;

   virtual void BeginLoad() = 0;

   virtual void EndLoad() = 0;

   enum ReadyState { READYSTATE_UNINITIALIZED = 0, READYSTATE_LOADING = 1, READYSTATE_INTERACTIVE = 3, READYSTATE_COMPLETE = 4};

   virtual void SetReadyStateInternal(ReadyState rs) = 0;

   ReadyState GetReadyStateEnum()

   {

     return mReadyState;

   }

   // notify that a content node changed state.  This must happen under

   // a scriptblocker but NOT within a begin/end update.

   virtual void ContentStateChanged(nsIContent* aContent,

                                    mozilla::EventStates aStateMask) = 0;

   // Notify that a document state has changed.

   // This should only be called by callers whose state is also reflected in the

   // implementation of nsDocument::GetDocumentState.

   virtual void DocumentStatesChanged(mozilla::EventStates aStateMask) = 0;

   // Observation hooks for style data to propagate notifications

   // to document observers

   virtual void StyleRuleChanged(nsIStyleSheet* aStyleSheet,

                                 nsIStyleRule* aOldStyleRule,

                                 nsIStyleRule* aNewStyleRule) = 0;

   virtual void StyleRuleAdded(nsIStyleSheet* aStyleSheet,

                               nsIStyleRule* aStyleRule) = 0;

   virtual void StyleRuleRemoved(nsIStyleSheet* aStyleSheet,

                                 nsIStyleRule* aStyleRule) = 0;

   /**

    * Flush notifications for this document and its parent documents

    * (since those may affect the layout of this one).

    */

   virtual void FlushPendingNotifications(mozFlushType aType) = 0;

   /**

    * Calls FlushPendingNotifications on any external resources this document

    * has. If this document has no external resources or is an external resource

    * itself this does nothing. This should only be called with

    * aType >= Flush_Style.

    */

   virtual void FlushExternalResources(mozFlushType aType) = 0;

   nsBindingManager* BindingManager() const

   {

     return mNodeInfoManager->GetBindingManager();

   }

   /**

    * Only to be used inside Gecko, you can't really do anything with the

    * pointer outside Gecko anyway.

    */

   nsNodeInfoManager* NodeInfoManager() const

   {

     return mNodeInfoManager;

   }

   /**

    * Reset the document using the given channel and loadgroup.  This works

    * like ResetToURI, but also sets the document's channel to aChannel.

    * The principal of the document will be set from the channel.

    */

   virtual void Reset(nsIChannel* aChannel, nsILoadGroup* aLoadGroup) = 0;

   /**

    * Reset this document to aURI, aLoadGroup, and aPrincipal.  aURI must not be

    * null.  If aPrincipal is null, a codebase principal based on aURI will be

    * used.

    */

   virtual void ResetToURI(nsIURI *aURI, nsILoadGroup* aLoadGroup,

                           nsIPrincipal* aPrincipal) = 0;

   /**

    * Set the container (docshell) for this document. Virtual so that

    * docshell can call it.

    */

   virtual void SetContainer(nsDocShell* aContainer);

   /**

    * Get the container (docshell) for this document.

    */

   virtual nsISupports* GetContainer() const;

   /**

    * Get the container's load context for this document.

    */

   nsILoadContext* GetLoadContext() const;

   /**

    * Get docshell the for this document.

    */

   nsIDocShell* GetDocShell() const;

   /**

    * Set and get XML declaration. If aVersion is null there is no declaration.

    * aStandalone takes values -1, 0 and 1 indicating respectively that there

    * was no standalone parameter in the declaration, that it was given as no,

    * or that it was given as yes.

    */

   virtual void SetXMLDeclaration(const char16_t *aVersion,

                                  const char16_t *aEncoding,

                                  const int32_t aStandalone) = 0;

   virtual void GetXMLDeclaration(nsAString& aVersion,

                                  nsAString& aEncoding,

                                  nsAString& Standalone) = 0;

   bool IsHTML() const

   {

     return mIsRegularHTML;

   }

   bool IsXUL() const

   {

     return mIsXUL;

   }

   virtual bool IsScriptEnabled() = 0;

   /**

    * Create an element with the specified name, prefix and namespace ID.

    */

   virtual nsresult CreateElem(const nsAString& aName, nsIAtom *aPrefix,

                               int32_t aNamespaceID,

                               nsIContent** aResult) = 0;

   /**

    * Get the security info (i.e. SSL state etc) that the document got

    * from the channel/document that created the content of the

    * document.

    *

    * @see nsIChannel

    */

   nsISupports *GetSecurityInfo()

   {

     return mSecurityInfo;

   }

   /**

    * Returns the default namespace ID used for elements created in this

    * document.

    */

   int32_t GetDefaultNamespaceID() const

   {

     return mDefaultElementType;

   }

   void DeleteAllProperties();

   void DeleteAllPropertiesFor(nsINode* aNode);

   nsPropertyTable* PropertyTable(uint16_t aCategory) {

     if (aCategory == 0)

       return &mPropertyTable;

     return GetExtraPropertyTable(aCategory);

   }

   uint32_t GetPropertyTableCount()

   { return mExtraPropertyTables.Length() + 1; }

   /**

    * Sets the ID used to identify this part of the multipart document

    */

   void SetPartID(uint32_t aID) {

     mPartID = aID;

   }

   /**

    * Return the ID used to identify this part of the multipart document

    */

   uint32_t GetPartID() const {

     return mPartID;

   }

   /**

    * Sanitize the document by resetting all input elements and forms that have

    * autocomplete=off to their default values.

    */

   virtual void Sanitize() = 0;

   /**

    * Enumerate all subdocuments.

    * The enumerator callback should return true to continue enumerating, or

    * false to stop.  This will never get passed a null aDocument.

    */

   typedef bool (*nsSubDocEnumFunc)(nsIDocument *aDocument, void *aData);

   virtual void EnumerateSubDocuments(nsSubDocEnumFunc aCallback,

                                      void *aData) = 0;

   /**

    * Check whether it is safe to cache the presentation of this document

    * and all of its subdocuments. This method checks the following conditions

    * recursively:

    *  - Some document types, such as plugin documents, cannot be safely cached.

    *  - If there are any pending requests, we don't allow the presentation

    *    to be cached.  Ideally these requests would be suspended and resumed,

    *    but that is difficult in some cases, such as XMLHttpRequest.

    *  - If there are any beforeunload or unload listeners, we must fire them

    *    for correctness, but this likely puts the document into a state where

    *    it would not function correctly if restored.

    *

    * |aNewRequest| should be the request for a new document which will

    * replace this document in the docshell.  The new document's request

    * will be ignored when checking for active requests.  If there is no

    * request associated with the new document, this parameter may be null.

    */

   virtual bool CanSavePresentation(nsIRequest *aNewRequest) = 0;

   /**

    * Notify the document that its associated ContentViewer is being destroyed.

    * This releases circular references so that the document can go away.

    * Destroy() is only called on documents that have a content viewer.

    */

   virtual void Destroy() = 0;

   /**

    * Notify the document that its associated ContentViewer is no longer

    * the current viewer for the docshell. The document might still

    * be rendered in "zombie state" until the next document is ready.

    * The document should save form control state.

    */

   virtual void RemovedFromDocShell() = 0;

   /**

    * Get the layout history state that should be used to save and restore state

    * for nodes in this document.  This may return null; if that happens state

    * saving and restoration is not possible.

    */

   virtual already_AddRefed<nsILayoutHistoryState> GetLayoutHistoryState() const = 0;

   /**

    * Methods that can be used to prevent onload firing while an event that

    * should block onload is posted.  onload is guaranteed to not fire until

    * either all calls to BlockOnload() have been matched by calls to

    * UnblockOnload() or the load has been stopped altogether (by the user

    * pressing the Stop button, say).

    */

   virtual void BlockOnload() = 0;

   /**

    * @param aFireSync whether to fire onload synchronously.  If false,

    * onload will fire asynchronously after all onload blocks have been

    * removed.  It will NOT fire from inside UnblockOnload.  If true,

    * onload may fire from inside UnblockOnload.

    */

   virtual void UnblockOnload(bool aFireSync) = 0;

   void BlockDOMContentLoaded()

   {

     ++mBlockDOMContentLoaded;

   }

   virtual void UnblockDOMContentLoaded() = 0;

   /**

    * Notification that the page has been shown, for documents which are loaded

    * into a DOM window.  This corresponds to the completion of document load,

    * or to the page's presentation being restored into an existing DOM window.

    * This notification fires applicable DOM events to the content window.  See

    * nsIDOMPageTransitionEvent.idl for a description of the |aPersisted|

    * parameter. If aDispatchStartTarget is null, the pageshow event is

    * dispatched on the ScriptGlobalObject for this document, otherwise it's

    * dispatched on aDispatchStartTarget.

    * Note: if aDispatchStartTarget isn't null, the showing state of the

    * document won't be altered.

    */

   virtual void OnPageShow(bool aPersisted,

                           mozilla::dom::EventTarget* aDispatchStartTarget) = 0;

   /**

    * Notification that the page has been hidden, for documents which are loaded

    * into a DOM window.  This corresponds to the unloading of the document, or

    * to the document's presentation being saved but removed from an existing

    * DOM window.  This notification fires applicable DOM events to the content

    * window.  See nsIDOMPageTransitionEvent.idl for a description of the

    * |aPersisted| parameter. If aDispatchStartTarget is null, the pagehide

    * event is dispatched on the ScriptGlobalObject for this document,

    * otherwise it's dispatched on aDispatchStartTarget.

    * Note: if aDispatchStartTarget isn't null, the showing state of the

    * document won't be altered.

    */

   virtual void OnPageHide(bool aPersisted,

                           mozilla::dom::EventTarget* aDispatchStartTarget) = 0;

   /*

    * We record the set of links in the document that are relevant to

    * style.

    */

   /**

    * Notification that an element is a link that is relevant to style.

    */

   virtual void AddStyleRelevantLink(mozilla::dom::Link* aLink) = 0;

   /**

    * Notification that an element is a link and its URI might have been

    * changed or the element removed. If the element is still a link relevant

    * to style, then someone must ensure that AddStyleRelevantLink is

    * (eventually) called on it again.

    */

   virtual void ForgetLink(mozilla::dom::Link* aLink) = 0;

   /**

    * Resets and removes a box object from the document's box object cache

    *

    * @param aElement canonical nsIContent pointer of the box object's element

    */

   virtual void ClearBoxObjectFor(nsIContent *aContent) = 0;

   /**

    * Get the box object for an element. This is not exposed through a

    * scriptable interface except for XUL documents.

    */

   virtual already_AddRefed<nsIBoxObject>

     GetBoxObjectFor(mozilla::dom::Element* aElement,

                     mozilla::ErrorResult& aRv) = 0;

   /**

    * Get the compatibility mode for this document

    */

   nsCompatibility GetCompatibilityMode() const {

     return mCompatMode;

   }

   /**

    * Check whether we've ever fired a DOMTitleChanged event for this

    * document.

    */

   bool HaveFiredDOMTitleChange() const {

     return mHaveFiredTitleChange;

   }

   /**

    * See GetAnonymousElementByAttribute on nsIDOMDocumentXBL.

    */

   virtual Element*

     GetAnonymousElementByAttribute(nsIContent* aElement,

                                    nsIAtom* aAttrName,

                                    const nsAString& aAttrValue) const = 0;

   /**

    * Helper for nsIDOMDocument::elementFromPoint implementation that allows

    * ignoring the scroll frame and/or avoiding layout flushes.

    *

    * @see nsIDOMWindowUtils::elementFromPoint

    */

   virtual Element* ElementFromPointHelper(float aX, float aY,

                                           bool aIgnoreRootScrollFrame,

                                           bool aFlushLayout) = 0;

   virtual nsresult NodesFromRectHelper(float aX, float aY,

                                        float aTopSize, float aRightSize,

                                        float aBottomSize, float aLeftSize,

                                        bool aIgnoreRootScrollFrame,

                                        bool aFlushLayout,

                                        nsIDOMNodeList** aReturn) = 0;

   /**

    * See FlushSkinBindings on nsBindingManager

    */

   virtual void FlushSkinBindings() = 0;

   /**

    * To batch DOMSubtreeModified, document needs to be informed when

    * a mutation event might be dispatched, even if the event isn't actually

    * created because there are no listeners for it.

    *

    * @param aTarget is the target for the mutation event.

    */

   void MayDispatchMutationEvent(nsINode* aTarget)

   {

     if (mSubtreeModifiedDepth > 0) {

       mSubtreeModifiedTargets.AppendObject(aTarget);

     }

   }

   /**

    * Marks as not-going-to-be-collected for the given generation of

    * cycle collection.

    */

   void MarkUncollectableForCCGeneration(uint32_t aGeneration)

   {

     mMarkedCCGeneration = aGeneration;

   }

   /**

    * Gets the cycle collector generation this document is marked for.

    */

   uint32_t GetMarkedCCGeneration()

   {

     return mMarkedCCGeneration;

   }

   bool IsLoadedAsData()

   {

     return mLoadedAsData;

   }

   bool IsLoadedAsInteractiveData()

   {

     return mLoadedAsInteractiveData;

   }

   bool MayStartLayout()

   {

     return mMayStartLayout;

   }

   void SetMayStartLayout(bool aMayStartLayout)

   {

     mMayStartLayout = aMayStartLayout;

   }

   already_AddRefed<nsIDocumentEncoder> GetCachedEncoder();

   void SetCachedEncoder(already_AddRefed<nsIDocumentEncoder> aEncoder);

   // In case of failure, the document really can't initialize the frame loader.

   virtual nsresult InitializeFrameLoader(nsFrameLoader* aLoader) = 0;

   // In case of failure, the caller must handle the error, for example by

   // finalizing frame loader asynchronously.

   virtual nsresult FinalizeFrameLoader(nsFrameLoader* aLoader) = 0;

   // Removes the frame loader of aShell from the initialization list.

   virtual void TryCancelFrameLoaderInitialization(nsIDocShell* aShell) = 0;

   //  Returns true if the frame loader of aShell is in the finalization list.

   virtual bool FrameLoaderScheduledToBeFinalized(nsIDocShell* aShell) = 0;

   /**

    * Check whether this document is a root document that is not an

    * external resource.

    */

   bool IsRootDisplayDocument() const

   {

     return !mParentDocument && !mDisplayDocument;

   }

   bool IsBeingUsedAsImage() const {

     return mIsBeingUsedAsImage;

   }

   void SetIsBeingUsedAsImage() {

     mIsBeingUsedAsImage = true;

   }

   bool IsResourceDoc() const {

     return IsBeingUsedAsImage() || // Are we a helper-doc for an SVG image?

       !!mDisplayDocument;          // Are we an external resource doc?

   }

   /**

    * Get the document for which this document is an external resource.  This

    * will be null if this document is not an external resource.  Otherwise,

    * GetDisplayDocument() will return a non-null document, and

    * GetDisplayDocument()->GetDisplayDocument() is guaranteed to be null.

    */

   nsIDocument* GetDisplayDocument() const

   {

     return mDisplayDocument;

   }

   /**

    * Set the display document for this document.  aDisplayDocument must not be

    * null.

    */

   void SetDisplayDocument(nsIDocument* aDisplayDocument)

   {

     NS_PRECONDITION(!GetShell() &&

                     !GetContainer() &&

                     !GetWindow(),

                     "Shouldn't set mDisplayDocument on documents that already "

                     "have a presentation or a docshell or a window");

     NS_PRECONDITION(aDisplayDocument != this, "Should be different document");

     NS_PRECONDITION(!aDisplayDocument->GetDisplayDocument(),

                     "Display documents should not nest");

     mDisplayDocument = aDisplayDocument;

   }

   /**

    * A class that represents an external resource load that has begun but

    * doesn't have a document yet.  Observers can be registered on this object,

    * and will be notified after the document is created.  Observers registered

    * after the document has been created will NOT be notified.  When observers

    * are notified, the subject will be the newly-created document, the topic

    * will be "external-resource-document-created", and the data will be null.

    * If document creation fails for some reason, observers will still be

    * notified, with a null document pointer.

    */

   class ExternalResourceLoad : public nsISupports

   {

   public:

     virtual ~ExternalResourceLoad() {}

     void AddObserver(nsIObserver* aObserver) {

       NS_PRECONDITION(aObserver, "Must have observer");

       mObservers.AppendElement(aObserver);

     }

     const nsTArray< nsCOMPtr<nsIObserver> > & Observers() {

       return mObservers;

     }

   protected:

     nsAutoTArray< nsCOMPtr<nsIObserver>, 8 > mObservers;    

   };

   /**

    * Request an external resource document for aURI.  This will return the

    * resource document if available.  If one is not available yet, it will

    * start loading as needed, and the pending load object will be returned in

    * aPendingLoad so that the caller can register an observer to wait for the

    * load.  If this function returns null and doesn't return a pending load,

    * that means that there is no resource document for this URI and won't be

    * one in the future.

    *

    * @param aURI the URI to get

    * @param aRequestingNode the node making the request

    * @param aPendingLoad the pending load for this request, if any

    */

   virtual nsIDocument*

     RequestExternalResource(nsIURI* aURI,

                             nsINode* aRequestingNode,

                             ExternalResourceLoad** aPendingLoad) = 0;

   /**

    * Enumerate the external resource documents associated with this document.

    * The enumerator callback should return true to continue enumerating, or

    * false to stop.  This callback will never get passed a null aDocument.

    */

   virtual void EnumerateExternalResources(nsSubDocEnumFunc aCallback,

                                           void* aData) = 0;

   /**

    * Return whether the document is currently showing (in the sense of

    * OnPageShow() having been called already and OnPageHide() not having been

    * called yet.

    */

   bool IsShowing() const { return mIsShowing; }

   /**

    * Return whether the document is currently visible (in the sense of

    * OnPageHide having been called and OnPageShow not yet having been called)

    */

   bool IsVisible() const { return mVisible; }

   /**

    * Return whether the document and all its ancestors are visible in the sense of

    * pageshow / hide.

    */

   bool IsVisibleConsideringAncestors() const;

   /**

    * Return true when this document is active, i.e., the active document

    * in a content viewer.  Note that this will return true for bfcached

    * documents, so this does NOT match the "active document" concept in

    * the WHATWG spec.  That would correspond to GetInnerWindow() &&

    * GetInnerWindow()->IsCurrentInnerWindow().

    */

   bool IsActive() const { return mDocumentContainer && !mRemovedFromDocShell; }

   void RegisterFreezableElement(nsIContent* aContent);

   bool UnregisterFreezableElement(nsIContent* aContent);

   typedef void (* FreezableElementEnumerator)(nsIContent*, void*);

   void EnumerateFreezableElements(FreezableElementEnumerator aEnumerator,

                                   void* aData);

   // Indicates whether mAnimationController has been (lazily) initialized.

   // If this returns true, we're promising that GetAnimationController()

   // will have a non-null return value.

   bool HasAnimationController()  { return !!mAnimationController; }

   // Getter for this document's SMIL Animation Controller. Performs lazy

   // initialization, if this document supports animation and if

   // mAnimationController isn't yet initialized.

   virtual nsSMILAnimationController* GetAnimationController() = 0;

   // Makes the images on this document capable of having their animation

   // active or suspended. An Image will animate as long as at least one of its

   // owning Documents needs it to animate; otherwise it can suspend.

   virtual void SetImagesNeedAnimating(bool aAnimating) = 0;

   enum SuppressionType {

     eAnimationsOnly = 0x1,

     // Note that suppressing events also suppresses animation frames, so

     // there's no need to split out events in its own bitmask.

     eEvents = 0x3,

   };

   /**

    * Prevents user initiated events from being dispatched to the document and

    * subdocuments.

    */

   virtual void SuppressEventHandling(SuppressionType aWhat,

                                      uint32_t aIncrease = 1) = 0;

   /**

    * Unsuppress event handling.

    * @param aFireEvents If true, delayed events (focus/blur) will be fired

    *                    asynchronously.

    */

   virtual void UnsuppressEventHandlingAndFireEvents(SuppressionType aWhat,

                                                     bool aFireEvents) = 0;

   uint32_t EventHandlingSuppressed() const { return mEventsSuppressed; }

   uint32_t AnimationsPaused() const { return mAnimationsPaused; }

   bool IsEventHandlingEnabled() {

     return !EventHandlingSuppressed() && mScriptGlobalObject;

   }

   /**

    * Increment the number of external scripts being evaluated.

    */

   void BeginEvaluatingExternalScript() { ++mExternalScriptsBeingEvaluated; }

   /**

    * Decrement the number of external scripts being evaluated.

    */

   void EndEvaluatingExternalScript() { --mExternalScriptsBeingEvaluated; }

   bool IsDNSPrefetchAllowed() const { return mAllowDNSPrefetch; }

   /**

    * Returns true if this document is allowed to contain XUL element and

    * use non-builtin XBL bindings.

    */

   bool AllowXULXBL() {

     return mAllowXULXBL == eTriTrue ? true :

            mAllowXULXBL == eTriFalse ? false :

            InternalAllowXULXBL();

   }

   void ForceEnableXULXBL() {

     mAllowXULXBL = eTriTrue;

   }

   /**

    * Returns the template content owner document that owns the content of

    * HTMLTemplateElement.

    */

   virtual nsIDocument* GetTemplateContentsOwner() = 0;

   /**

    * true when this document is a static clone of a normal document.

    * For example print preview and printing use static documents.

    */

   bool IsStaticDocument() { return mIsStaticDocument; }

   /**

    * Clones the document and subdocuments and stylesheet etc.

    * @param aCloneContainer The container for the clone document.

    */

   virtual already_AddRefed<nsIDocument>

   CreateStaticClone(nsIDocShell* aCloneContainer);

   /**

    * If this document is a static clone, this returns the original

    * document.

    */

   nsIDocument* GetOriginalDocument()

   {

     MOZ_ASSERT(!mOriginalDocument || !mOriginalDocument->GetOriginalDocument());

     return mOriginalDocument;

   }

   /**

    * Called by nsParser to preload images. Can be removed and code moved

    * to nsPreloadURIs::PreloadURIs() in file nsParser.cpp whenever the

    * parser-module is linked with gklayout-module.  aCrossOriginAttr should

    * be a void string if the attr is not present.

    */

   virtual void MaybePreLoadImage(nsIURI* uri,

                                  const nsAString& aCrossOriginAttr) = 0;

   /**

    * Called by nsParser to preload style sheets.  Can also be merged into the

    * parser if and when the parser is merged with libgklayout.  aCrossOriginAttr

    * should be a void string if the attr is not present.

    */

   virtual void PreloadStyle(nsIURI* aURI, const nsAString& aCharset,

                             const nsAString& aCrossOriginAttr) = 0;

   /**

    * Called by the chrome registry to load style sheets.  Can be put

    * back there if and when when that module is merged with libgklayout.

    *

    * This always does a synchronous load.  If aIsAgentSheet is true,

    * it also uses the system principal and enables unsafe rules.

    * DO NOT USE FOR UNTRUSTED CONTENT.

    */

   virtual nsresult LoadChromeSheetSync(nsIURI* aURI, bool aIsAgentSheet,

                                        nsCSSStyleSheet** aSheet) = 0;

   /**

    * Returns true if the locale used for the document specifies a direction of

    * right to left. For chrome documents, this comes from the chrome registry.

    * This is used to determine the current state for the :-moz-locale-dir pseudoclass

    * so once can know whether a document is expected to be rendered left-to-right

    * or right-to-left.

    */

   virtual bool IsDocumentRightToLeft() { return false; }

   enum DocumentTheme {

     Doc_Theme_Uninitialized, // not determined yet

     Doc_Theme_None,

     Doc_Theme_Neutral,

     Doc_Theme_Dark,

     Doc_Theme_Bright

   };

   /**

    * Set the document's pending state object (as serialized using structured

    * clone).

    */

   void SetStateObject(nsIStructuredCloneContainer *scContainer);

   /**

    * Returns Doc_Theme_None if there is no lightweight theme specified,

    * Doc_Theme_Dark for a dark theme, Doc_Theme_Bright for a light theme, and

    * Doc_Theme_Neutral for any other theme. This is used to determine the state

    * of the pseudoclasses :-moz-lwtheme and :-moz-lwtheme-text.

    */

   virtual int GetDocumentLWTheme() { return Doc_Theme_None; }

   /**

    * Returns the document state.

    * Document state bits have the form NS_DOCUMENT_STATE_* and are declared in

    * nsIDocument.h.

    */

   virtual mozilla::EventStates GetDocumentState() = 0;

   virtual nsISupports* GetCurrentContentSink() = 0;

   /**

    * Register/Unregister a hostobject uri as being "owned" by this document.

    * I.e. that its lifetime is connected with this document. When the document

    * goes away it should "kill" the uri by calling

    * nsHostObjectProtocolHandler::RemoveDataEntry

    */

   virtual void RegisterHostObjectUri(const nsACString& aUri) = 0;

   virtual void UnregisterHostObjectUri(const nsACString& aUri) = 0;

   virtual void SetScrollToRef(nsIURI *aDocumentURI) = 0;

   virtual void ScrollToRef() = 0;

   virtual void ResetScrolledToRefAlready() = 0;

   virtual void SetChangeScrollPosWhenScrollingToRef(bool aValue) = 0;

   /**

    * This method is similar to GetElementById() from nsIDOMDocument but it

    * returns a mozilla::dom::Element instead of a nsIDOMElement.

    * It prevents converting nsIDOMElement to mozilla::dom::Element which is

    * already converted from mozilla::dom::Element.

    */

   virtual Element* GetElementById(const nsAString& aElementId) = 0;

   /**

    * This method returns _all_ the elements in this document which

    * have id aElementId, if there are any.  Otherwise it returns null.

    * The entries of the nsSmallVoidArray are Element*

    */

   virtual const nsSmallVoidArray* GetAllElementsForId(const nsAString& aElementId) const = 0;

   /**

    * Lookup an image element using its associated ID, which is usually provided

    * by |-moz-element()|. Similar to GetElementById, with the difference that

    * elements set using mozSetImageElement have higher priority.

    * @param aId the ID associated the element we want to lookup

    * @return the element associated with |aId|

    */

   virtual Element* LookupImageElement(const nsAString& aElementId) = 0;

   virtual already_AddRefed<mozilla::dom::UndoManager> GetUndoManager() = 0;

   typedef mozilla::dom::CallbackObjectHolder<

     mozilla::dom::FrameRequestCallback,

     nsIFrameRequestCallback> FrameRequestCallbackHolder;

   nsresult ScheduleFrameRequestCallback(const FrameRequestCallbackHolder& aCallback,

                                         int32_t *aHandle);

   void CancelFrameRequestCallback(int32_t aHandle);

   typedef nsTArray<FrameRequestCallbackHolder> FrameRequestCallbackList;

   /**

    * Put this document's frame request callbacks into the provided

    * list, and forget about them.

    */

   void TakeFrameRequestCallbacks(FrameRequestCallbackList& aCallbacks);

   // This returns true when the document tree is being teared down.

   bool InUnlinkOrDeletion() { return mInUnlinkOrDeletion; }

   /*

    * Image Tracking

    *

    * Style and content images register their imgIRequests with their document

    * so that the document can efficiently tell all descendant images when they

    * are and are not visible. When an image is on-screen, we want to call

    * LockImage() on it so that it doesn't do things like discarding frame data

    * to save memory. The PresShell informs the document whether its images

    * should be locked or not via SetImageLockingState().

    *

    * See bug 512260.

    */

   // Add/Remove images from the document image tracker

   virtual nsresult AddImage(imgIRequest* aImage) = 0;

   // If the REQUEST_DISCARD flag is passed then if the lock count is zero we

   // will request the image be discarded now (instead of waiting).

   enum { REQUEST_DISCARD = 0x1 };

   virtual nsresult RemoveImage(imgIRequest* aImage, uint32_t aFlags = 0) = 0;

   // Makes the images on this document locked/unlocked. By default, the locking

   // state is unlocked/false.

   virtual nsresult SetImageLockingState(bool aLocked) = 0;

   virtual nsresult AddPlugin(nsIObjectLoadingContent* aPlugin) = 0;

   virtual void RemovePlugin(nsIObjectLoadingContent* aPlugin) = 0;

   virtual void GetPlugins(nsTArray<nsIObjectLoadingContent*>& aPlugins) = 0;

   virtual nsresult GetStateObject(nsIVariant** aResult) = 0;

   virtual nsDOMNavigationTiming* GetNavigationTiming() const = 0;

   virtual nsresult SetNavigationTiming(nsDOMNavigationTiming* aTiming) = 0;

   virtual Element* FindImageMap(const nsAString& aNormalizedMapName) = 0;

   // Add aLink to the set of links that need their status resolved. 

   void RegisterPendingLinkUpdate(mozilla::dom::Link* aLink);

   // Remove aLink from the set of links that need their status resolved.

   // This function must be called when links are removed from the document.

   void UnregisterPendingLinkUpdate(mozilla::dom::Link* aElement);

   // Update state on links in mLinksToUpdate.  This function must

   // be called prior to selector matching.

   void FlushPendingLinkUpdates();

 #define DEPRECATED_OPERATION(_op) e##_op,

   enum DeprecatedOperations {

 #include "nsDeprecatedOperationList.h"

     eDeprecatedOperationCount

   };

 #undef DEPRECATED_OPERATION

   void WarnOnceAbout(DeprecatedOperations aOperation, bool asError = false);

   virtual void PostVisibilityUpdateEvent() = 0;

   bool IsSyntheticDocument() const { return mIsSyntheticDocument; }

   void SetNeedLayoutFlush() {

     mNeedLayoutFlush = true;

     if (mDisplayDocument) {

       mDisplayDocument->SetNeedLayoutFlush();

     }

   }

   void SetNeedStyleFlush() {

     mNeedStyleFlush = true;

     if (mDisplayDocument) {

       mDisplayDocument->SetNeedStyleFlush();

     }

   }

   // Note: nsIDocument is a sub-class of nsINode, which has a

   // SizeOfExcludingThis function.  However, because nsIDocument objects can

   // only appear at the top of the DOM tree, we have a specialized measurement

   // function which returns multiple sizes.

   virtual void DocAddSizeOfExcludingThis(nsWindowSizes* aWindowSizes) const;

   // DocAddSizeOfIncludingThis doesn't need to be overridden by sub-classes

   // because nsIDocument inherits from nsINode;  see the comment above the

   // declaration of nsINode::SizeOfIncludingThis.

   virtual void DocAddSizeOfIncludingThis(nsWindowSizes* aWindowSizes) const;

   bool MayHaveDOMMutationObservers()

   {

     return mMayHaveDOMMutationObservers;

   }

   void SetMayHaveDOMMutationObservers()

   {

     mMayHaveDOMMutationObservers = true;

   }

   bool IsInSyncOperation()

   {

     return mInSyncOperationCount != 0;

   }

   void SetIsInSyncOperation(bool aSync)

   {

     if (aSync) {

       ++mInSyncOperationCount;

     } else {

       --mInSyncOperationCount;

     }

   }

   bool CreatingStaticClone() const

   {

     return mCreatingStaticClone;

   }

   /**

    * Creates a new element in the HTML namespace with a local name given by

    * aTag.

    */

   already_AddRefed<Element> CreateHTMLElement(nsIAtom* aTag);

   // WebIDL API

   nsIGlobalObject* GetParentObject() const

   {

     return GetScopeObject();

   }

   static already_AddRefed<nsIDocument>

     Constructor(const GlobalObject& aGlobal,

                 mozilla::ErrorResult& rv);

   virtual mozilla::dom::DOMImplementation*

     GetImplementation(mozilla::ErrorResult& rv) = 0;

   void GetURL(nsString& retval) const;

   void GetDocumentURI(nsString& retval) const;

   // Return the URI for the document.

   // The returned value may differ if the document is loaded via XHR, and

   // when accessed from chrome privileged script and

   // from content privileged script for compatibility.

   void GetDocumentURIFromJS(nsString& aDocumentURI) const;

   void GetCompatMode(nsString& retval) const;

   void GetCharacterSet(nsAString& retval) const;

   // Skip GetContentType, because our NS_IMETHOD version above works fine here.

   // GetDoctype defined above

   Element* GetDocumentElement() const

   {

     return GetRootElement();

   }

   enum ElementCallbackType {

     eCreated,

     eAttached,

     eDetached,

     eAttributeChanged

   };

   /**

    * Registers an unresolved custom element that is a candidate for

    * upgrade when the definition is registered via registerElement.

    * |aTypeName| is the name of the custom element type, if it is not

    * provided, then element name is used. |aTypeName| should be provided

    * when registering a custom element that extends an existing

    * element. e.g. <button is="x-button">.

    */

   virtual nsresult RegisterUnresolvedElement(Element* aElement,

                                              nsIAtom* aTypeName = nullptr) = 0;

   virtual void EnqueueLifecycleCallback(ElementCallbackType aType,

                                         Element* aCustomElement,

                                         mozilla::dom::LifecycleCallbackArgs* aArgs = nullptr,

                                         mozilla::dom::CustomElementDefinition* aDefinition = nullptr) = 0;

   virtual void SwizzleCustomElement(Element* aElement,

                                     const nsAString& aTypeExtension,

                                     uint32_t aNamespaceID,

                                     mozilla::ErrorResult& rv) = 0;

   virtual void

     RegisterElement(JSContext* aCx, const nsAString& aName,

                     const mozilla::dom::ElementRegistrationOptions& aOptions,

                     JS::MutableHandle<JSObject*> aRetval,

                     mozilla::ErrorResult& rv) = 0;

   /**

    * In some cases, new document instances must be associated with

    * an existing web components custom element registry as specified.

    */

   virtual void UseRegistryFromDocument(nsIDocument* aDocument) = 0;

   already_AddRefed<nsContentList>

   GetElementsByTagName(const nsAString& aTagName)

   {

     return NS_GetContentList(this, kNameSpaceID_Unknown, aTagName);

   }

   already_AddRefed<nsContentList>

     GetElementsByTagNameNS(const nsAString& aNamespaceURI,

                            const nsAString& aLocalName,

                            mozilla::ErrorResult& aResult);

   already_AddRefed<nsContentList>

     GetElementsByClassName(const nsAString& aClasses);

   // GetElementById defined above

   already_AddRefed<Element> CreateElement(const nsAString& aTagName,

                                           mozilla::ErrorResult& rv);

   already_AddRefed<Element> CreateElementNS(const nsAString& aNamespaceURI,

                                             const nsAString& aQualifiedName,

                                             mozilla::ErrorResult& rv);

   virtual already_AddRefed<Element> CreateElement(const nsAString& aTagName,

                                                   const nsAString& aTypeExtension,

                                                   mozilla::ErrorResult& rv) = 0;

   virtual already_AddRefed<Element> CreateElementNS(const nsAString& aNamespaceURI,

                                                     const nsAString& aQualifiedName,

                                                     const nsAString& aTypeExtension,

                                                     mozilla::ErrorResult& rv) = 0;

   already_AddRefed<mozilla::dom::DocumentFragment>

     CreateDocumentFragment() const;

   already_AddRefed<nsTextNode> CreateTextNode(const nsAString& aData) const;

   already_AddRefed<mozilla::dom::Comment>

     CreateComment(const nsAString& aData) const;

   already_AddRefed<mozilla::dom::ProcessingInstruction>

     CreateProcessingInstruction(const nsAString& target, const nsAString& data,

                                 mozilla::ErrorResult& rv) const;

   already_AddRefed<nsINode>

     ImportNode(nsINode& aNode, bool aDeep, mozilla::ErrorResult& rv) const;

   nsINode* AdoptNode(nsINode& aNode, mozilla::ErrorResult& rv);

   already_AddRefed<mozilla::dom::Event>

     CreateEvent(const nsAString& aEventType, mozilla::ErrorResult& rv) const;

   already_AddRefed<nsRange> CreateRange(mozilla::ErrorResult& rv);

   already_AddRefed<mozilla::dom::NodeIterator>

     CreateNodeIterator(nsINode& aRoot, uint32_t aWhatToShow,

                        mozilla::dom::NodeFilter* aFilter,

                        mozilla::ErrorResult& rv) const;

   already_AddRefed<mozilla::dom::NodeIterator>

     CreateNodeIterator(nsINode& aRoot, uint32_t aWhatToShow,

                        const mozilla::dom::NodeFilterHolder& aFilter,

                        mozilla::ErrorResult& rv) const;

   already_AddRefed<mozilla::dom::TreeWalker>

     CreateTreeWalker(nsINode& aRoot, uint32_t aWhatToShow,

                      mozilla::dom::NodeFilter* aFilter, mozilla::ErrorResult& rv) const;

   already_AddRefed<mozilla::dom::TreeWalker>

     CreateTreeWalker(nsINode& aRoot, uint32_t aWhatToShow,

                      const mozilla::dom::NodeFilterHolder& aFilter,

                      mozilla::ErrorResult& rv) const;

   // Deprecated WebIDL bits

   already_AddRefed<mozilla::dom::CDATASection>

     CreateCDATASection(const nsAString& aData, mozilla::ErrorResult& rv);

   already_AddRefed<mozilla::dom::Attr>

     CreateAttribute(const nsAString& aName, mozilla::ErrorResult& rv);

   already_AddRefed<mozilla::dom::Attr>

     CreateAttributeNS(const nsAString& aNamespaceURI,

                       const nsAString& aQualifiedName,

                       mozilla::ErrorResult& rv);

   void GetInputEncoding(nsAString& aInputEncoding);

   already_AddRefed<nsIDOMLocation> GetLocation() const;

   void GetReferrer(nsAString& aReferrer) const;

   void GetLastModified(nsAString& aLastModified) const;

   void GetReadyState(nsAString& aReadyState) const;

   // Not const because otherwise the compiler can't figure out whether to call

   // this GetTitle or the nsAString version from non-const methods, since

   // neither is an exact match.

   virtual void GetTitle(nsString& aTitle) = 0;

   virtual void SetTitle(const nsAString& aTitle, mozilla::ErrorResult& rv) = 0;

   void GetDir(nsAString& aDirection) const;

   void SetDir(const nsAString& aDirection);

   nsIDOMWindow* GetDefaultView() const

   {

     return GetWindow();

   }

   Element* GetActiveElement();

   bool HasFocus(mozilla::ErrorResult& rv) const;

   // Event handlers are all on nsINode already

   bool MozSyntheticDocument() const

   {

     return IsSyntheticDocument();

   }

   Element* GetCurrentScript();

   void ReleaseCapture() const;

   virtual void MozSetImageElement(const nsAString& aImageElementId,

                                   Element* aElement) = 0;

   nsIURI* GetDocumentURIObject() const;

   // Not const because all the full-screen goop is not const

   virtual bool MozFullScreenEnabled() = 0;

   virtual Element* GetMozFullScreenElement(mozilla::ErrorResult& rv) = 0;

   bool MozFullScreen()

   {

     return IsFullScreenDoc();

   }

   void MozCancelFullScreen();

   Element* GetMozPointerLockElement();

   void MozExitPointerLock()

   {

     UnlockPointer(this);

   }

   bool Hidden() const

   {

     return mVisibilityState != mozilla::dom::VisibilityState::Visible;

   }

   bool MozHidden() // Not const because of WarnOnceAbout

   {

     WarnOnceAbout(ePrefixedVisibilityAPI);

     return Hidden();

   }

   mozilla::dom::VisibilityState VisibilityState()

   {

     return mVisibilityState;

   }

   mozilla::dom::VisibilityState MozVisibilityState()

   {

     WarnOnceAbout(ePrefixedVisibilityAPI);

     return VisibilityState();

   }

   virtual mozilla::dom::StyleSheetList* StyleSheets() = 0;

   void GetSelectedStyleSheetSet(nsAString& aSheetSet);

   virtual void SetSelectedStyleSheetSet(const nsAString& aSheetSet) = 0;

   virtual void GetLastStyleSheetSet(nsString& aSheetSet) = 0;

   void GetPreferredStyleSheetSet(nsAString& aSheetSet);

   virtual mozilla::dom::DOMStringList* StyleSheetSets() = 0;

   virtual void EnableStyleSheetsForSet(const nsAString& aSheetSet) = 0;

   Element* ElementFromPoint(float aX, float aY);

   /**

    * Retrieve the location of the caret position (DOM node and character

    * offset within that node), given a point.

    *

    * @param aX Horizontal point at which to determine the caret position, in

    *           page coordinates.

    * @param aY Vertical point at which to determine the caret position, in

    *           page coordinates.

    */

   already_AddRefed<nsDOMCaretPosition>

     CaretPositionFromPoint(float aX, float aY);

   // QuerySelector and QuerySelectorAll already defined on nsINode

   nsINodeList* GetAnonymousNodes(Element& aElement);

   Element* GetAnonymousElementByAttribute(Element& aElement,

                                           const nsAString& aAttrName,

                                           const nsAString& aAttrValue);

   Element* GetBindingParent(nsINode& aNode);

   void LoadBindingDocument(const nsAString& aURI, mozilla::ErrorResult& rv);

   already_AddRefed<nsIDOMXPathExpression>

     CreateExpression(const nsAString& aExpression,

                      nsIDOMXPathNSResolver* aResolver,

                      mozilla::ErrorResult& rv);

   already_AddRefed<nsIDOMXPathNSResolver>

     CreateNSResolver(nsINode* aNodeResolver, mozilla::ErrorResult& rv);

   already_AddRefed<nsISupports>

     Evaluate(const nsAString& aExpression, nsINode* aContextNode,

              nsIDOMXPathNSResolver* aResolver, uint16_t aType,

              nsISupports* aResult, mozilla::ErrorResult& rv);

   // Touch event handlers already on nsINode

   already_AddRefed<mozilla::dom::Touch>

     CreateTouch(nsIDOMWindow* aView, mozilla::dom::EventTarget* aTarget,

                 int32_t aIdentifier, int32_t aPageX, int32_t aPageY,

                 int32_t aScreenX, int32_t aScreenY, int32_t aClientX,

                 int32_t aClientY, int32_t aRadiusX, int32_t aRadiusY,

                 float aRotationAngle, float aForce);

   already_AddRefed<mozilla::dom::TouchList> CreateTouchList();

   already_AddRefed<mozilla::dom::TouchList>

     CreateTouchList(mozilla::dom::Touch& aTouch,

                     const mozilla::dom::Sequence<mozilla::dom::OwningNonNull<mozilla::dom::Touch> >& aTouches);

   already_AddRefed<mozilla::dom::TouchList>

     CreateTouchList(const mozilla::dom::Sequence<mozilla::dom::OwningNonNull<mozilla::dom::Touch> >& aTouches);

   void SetStyleSheetChangeEventsEnabled(bool aValue)

   {

     mStyleSheetChangeEventsEnabled = aValue;

   }

   bool StyleSheetChangeEventsEnabled() const

   {

     return mStyleSheetChangeEventsEnabled;

   }

   void ObsoleteSheet(nsIURI *aSheetURI, mozilla::ErrorResult& rv);

   void ObsoleteSheet(const nsAString& aSheetURI, mozilla::ErrorResult& rv);

   // ParentNode

   nsIHTMLCollection* Children();

   uint32_t ChildElementCount();

   virtual nsHTMLDocument* AsHTMLDocument() { return nullptr; }

   virtual JSObject* WrapObject(JSContext *aCx) MOZ_OVERRIDE;

 private:

   uint64_t mWarnedAbout;

   SelectorCache mSelectorCache;

 protected:

   ~nsIDocument();

   nsPropertyTable* GetExtraPropertyTable(uint16_t aCategory);

   // Never ever call this. Only call GetWindow!

   virtual nsPIDOMWindow *GetWindowInternal() const = 0;

   // Never ever call this. Only call GetScriptHandlingObject!

   virtual nsIScriptGlobalObject* GetScriptHandlingObjectInternal() const = 0;

   // Never ever call this. Only call AllowXULXBL!

   virtual bool InternalAllowXULXBL() = 0;

   /**

    * These methods should be called before and after dispatching

    * a mutation event.

    * To make this easy and painless, use the mozAutoSubtreeModified helper class.

    */

   virtual void WillDispatchMutationEvent(nsINode* aTarget) = 0;

   virtual void MutationEventDispatched(nsINode* aTarget) = 0;

   friend class mozAutoSubtreeModified;

   virtual Element* GetNameSpaceElement()

   {

     return GetRootElement();

   }

   void SetContentTypeInternal(const nsACString& aType);

   nsCString GetContentTypeInternal() const

   {

     return mContentType;

   }

   mozilla::dom::XPathEvaluator* XPathEvaluator();

   nsCString mReferrer;

   nsString mLastModified;

   nsCOMPtr<nsIURI> mDocumentURI;

   nsCOMPtr<nsIURI> mOriginalURI;

   nsCOMPtr<nsIURI> mChromeXHRDocURI;

   nsCOMPtr<nsIURI> mDocumentBaseURI;

   nsCOMPtr<nsIURI> mChromeXHRDocBaseURI;

   nsWeakPtr mDocumentLoadGroup;

   mozilla::WeakPtr<nsDocShell> mDocumentContainer;

   nsCString mCharacterSet;

   int32_t mCharacterSetSource;

   // This is just a weak pointer; the parent document owns its children.

   nsIDocument* mParentDocument;

   // A reference to the element last returned from GetRootElement().

   mozilla::dom::Element* mCachedRootElement;

   // This is a weak reference, but we hold a strong reference to mNodeInfo,

   // which in turn holds a strong reference to this mNodeInfoManager.

   nsNodeInfoManager* mNodeInfoManager;

   nsRefPtr<mozilla::css::Loader> mCSSLoader;

   nsRefPtr<mozilla::css::ImageLoader> mStyleImageLoader;

   nsRefPtr<nsHTMLStyleSheet> mAttrStyleSheet;

   nsRefPtr<nsHTMLCSSStyleSheet> mStyleAttrStyleSheet;

   // The set of all object, embed, applet, video and audio elements for

   // which this is the owner document. (They might not be in the document.)

   // These are non-owning pointers, the elements are responsible for removing

   // themselves when they go away.

   nsAutoPtr<nsTHashtable<nsPtrHashKey<nsIContent> > > mFreezableElements;

   // The set of all links that need their status resolved.  Links must add themselves

   // to this set by calling RegisterPendingLinkUpdate when added to a document and must

   // remove themselves by calling UnregisterPendingLinkUpdate when removed from a document.

   nsTHashtable<nsPtrHashKey<mozilla::dom::Link> > mLinksToUpdate;

   // SMIL Animation Controller, lazily-initialized in GetAnimationController

   nsRefPtr<nsSMILAnimationController> mAnimationController;

   // Table of element properties for this document.

   nsPropertyTable mPropertyTable;

   nsTArray<nsAutoPtr<nsPropertyTable> > mExtraPropertyTables;

   // Our cached .children collection

   nsCOMPtr<nsIHTMLCollection> mChildrenCollection;

   // Compatibility mode

   nsCompatibility mCompatMode;

   // Our readyState

   ReadyState mReadyState;

   // Our visibility state

   mozilla::dom::VisibilityState mVisibilityState;

   // True if BIDI is enabled.

   bool mBidiEnabled;

   // True if a MathML element has ever been owned by this document.

   bool mMathMLEnabled;

   // True if this document is the initial document for a window.  This should

   // basically be true only for documents that exist in newly-opened windows or

   // documents created to satisfy a GetDocument() on a window when there's no

   // document in it.

   bool mIsInitialDocumentInWindow;

   bool mIsRegularHTML;

   bool mIsXUL;

   enum {

     eTriUnset = 0,

     eTriFalse,

     eTriTrue

   } mAllowXULXBL;

   // True if we're loaded as data and therefor has any dangerous stuff, such

   // as scripts and plugins, disabled.

   bool mLoadedAsData;

   // This flag is only set in XMLDocument, for e.g. documents used in XBL. We

   // don't want animations to play in such documents, so we need to store the

   // flag here so that we can check it in nsDocument::GetAnimationController.

   bool mLoadedAsInteractiveData;

   // If true, whoever is creating the document has gotten it to the

   // point where it's safe to start layout on it.

   bool mMayStartLayout;

   // True iff we've ever fired a DOMTitleChanged event for this document

   bool mHaveFiredTitleChange;

   // True iff IsShowing() should be returning true

   bool mIsShowing;

   // True iff the document "page" is not hidden (i.e. currently in the

   // bfcache)

   bool mVisible;

   // True if our content viewer has been removed from the docshell

   // (it may still be displayed, but in zombie state). Form control data

   // has been saved.

   bool mRemovedFromDocShell;

   // True iff DNS prefetch is allowed for this document.  Note that if the

   // document has no window, DNS prefetch won't be performed no matter what.

   bool mAllowDNSPrefetch;

   // True when this document is a static clone of a normal document

   bool mIsStaticDocument;

   // True while this document is being cloned to a static document.

   bool mCreatingStaticClone;

   // True iff the document is being unlinked or deleted.

   bool mInUnlinkOrDeletion;

   // True if document has ever had script handling object.

   bool mHasHadScriptHandlingObject;

   // True if we're an SVG document being used as an image.

   bool mIsBeingUsedAsImage;

   // True is this document is synthetic : stand alone image, video, audio

   // file, etc.

   bool mIsSyntheticDocument;

   // True if this document has links whose state needs updating

   bool mHasLinksToUpdate;

   // True if a layout flush might not be a no-op

   bool mNeedLayoutFlush;

   // True if a style flush might not be a no-op

   bool mNeedStyleFlush;

   // True if a DOMMutationObserver is perhaps attached to a node in the document.

   bool mMayHaveDOMMutationObservers;

   // True if a document has loaded Mixed Active Script (see nsMixedContentBlocker.cpp)

   bool mHasMixedActiveContentLoaded;

   // True if a document has blocked Mixed Active Script (see nsMixedContentBlocker.cpp)

   bool mHasMixedActiveContentBlocked;

   // True if a document has loaded Mixed Display/Passive Content (see nsMixedContentBlocker.cpp)

   bool mHasMixedDisplayContentLoaded;

   // True if a document has blocked Mixed Display/Passive Content (see nsMixedContentBlocker.cpp)

   bool mHasMixedDisplayContentBlocked;

   // True if DisallowBFCaching has been called on this document.

   bool mBFCacheDisallowed;

   // If true, we have an input encoding.  If this is false, then the

   // document was created entirely in memory

   bool mHaveInputEncoding;

   bool mHasHadDefaultView;

   // Whether style sheet change events will be dispatched for this document

   bool mStyleSheetChangeEventsEnabled;

   // Whether the document was created by a srcdoc iframe.

   bool mIsSrcdocDocument;

   // Records whether we've done a document.open. If this is true, it's possible

   // for nodes from this document to have outdated wrappers in their wrapper

   // caches.

   bool mDidDocumentOpen;

 #ifdef DEBUG

   /**

    * This is true while FlushPendingLinkUpdates executes.  Calls to

    * [Un]RegisterPendingLinkUpdate will assert when this is true.

    */

   bool mIsLinkUpdateRegistrationsForbidden;

 #endif

   // The document's script global object, the object from which the

   // document can get its script context and scope. This is the

   // *inner* window object.

   nsCOMPtr<nsIScriptGlobalObject> mScriptGlobalObject;

   // If mIsStaticDocument is true, mOriginalDocument points to the original

   // document.

   nsCOMPtr<nsIDocument> mOriginalDocument;

   // The bidi options for this document.  What this bitfield means is

   // defined in nsBidiUtils.h

   uint32_t mBidiOptions;

   // The sandbox flags on the document. These reflect the value of the sandbox attribute of the

   // associated IFRAME or CSP-protectable content, if existent. These are set at load time and

   // are immutable - see nsSandboxFlags.h for the possible flags.

   uint32_t mSandboxFlags;

   nsCString mContentLanguage;

   // The channel that got passed to nsDocument::StartDocumentLoad(), if any.

   nsCOMPtr<nsIChannel> mChannel;

 private:

   nsCString mContentType;

 protected:

   // The document's security info

   nsCOMPtr<nsISupports> mSecurityInfo;

   // if this document is part of a multipart document,

   // the ID can be used to distinguish it from the other parts.

   uint32_t mPartID;

   // Cycle collector generation in which we're certain that this document

   // won't be collected

   uint32_t mMarkedCCGeneration;

   nsIPresShell* mPresShell;

   nsCOMArray<nsINode> mSubtreeModifiedTargets;

   uint32_t            mSubtreeModifiedDepth;

   // If we're an external resource document, this will be non-null and will

   // point to our "display document": the one that all resource lookups should

   // go to.

   nsCOMPtr<nsIDocument> mDisplayDocument;

   uint32_t mEventsSuppressed;

   uint32_t mAnimationsPaused;

   /**

    * The number number of external scripts (ones with the src attribute) that

    * have this document as their owner and that are being evaluated right now.

    */

   uint32_t mExternalScriptsBeingEvaluated;

   /**

    * The current frame request callback handle

    */

   int32_t mFrameRequestCallbackCounter;

   // Weak reference to mScriptGlobalObject QI:d to nsPIDOMWindow,

   // updated on every set of mSecriptGlobalObject.

   nsPIDOMWindow *mWindow;

   nsCOMPtr<nsIDocumentEncoder> mCachedEncoder;

   struct FrameRequest;

   nsTArray<FrameRequest> mFrameRequestCallbacks;

   // This object allows us to evict ourself from the back/forward cache.  The

   // pointer is non-null iff we're currently in the bfcache.

   nsIBFCacheEntry *mBFCacheEntry;

   // Our base target.

   nsString mBaseTarget;

   nsCOMPtr<nsIStructuredCloneContainer> mStateObjectContainer;

   nsCOMPtr<nsIVariant> mStateObjectCached;

   uint8_t mDefaultElementType;

   uint32_t mInSyncOperationCount;

   nsRefPtr<mozilla::dom::XPathEvaluator> mXPathEvaluator;

   uint32_t mBlockDOMContentLoaded;

   bool mDidFireDOMContentLoaded:1;

 };

 NS_DEFINE_STATIC_IID_ACCESSOR(nsIDocument, NS_IDOCUMENT_IID)

 /**

  * mozAutoSubtreeModified batches DOM mutations so that a DOMSubtreeModified

  * event is dispatched, if necessary, when the outermost mozAutoSubtreeModified

  * object is deleted.

  */

 class MOZ_STACK_CLASS mozAutoSubtreeModified

 {

 public:

   /**

    * @param aSubTreeOwner The document in which a subtree will be modified.

    * @param aTarget       The target of the possible DOMSubtreeModified event.

    *                      Can be nullptr, in which case mozAutoSubtreeModified

    *                      is just used to batch DOM mutations.

    */

   mozAutoSubtreeModified(nsIDocument* aSubtreeOwner, nsINode* aTarget)

   {

     UpdateTarget(aSubtreeOwner, aTarget);

   }

   ~mozAutoSubtreeModified()

   {

     UpdateTarget(nullptr, nullptr);

   }

   void UpdateTarget(nsIDocument* aSubtreeOwner, nsINode* aTarget)

   {

     if (mSubtreeOwner) {

       mSubtreeOwner->MutationEventDispatched(mTarget);

     }

     mTarget = aTarget;

     mSubtreeOwner = aSubtreeOwner;

     if (mSubtreeOwner) {

       mSubtreeOwner->WillDispatchMutationEvent(mTarget);

     }

   }

 private:

   nsCOMPtr<nsINode>     mTarget;

   nsCOMPtr<nsIDocument> mSubtreeOwner;

 };

 class MOZ_STACK_CLASS nsAutoSyncOperation

 {

 public:

   nsAutoSyncOperation(nsIDocument* aDocument);

   ~nsAutoSyncOperation();

 private:

   nsCOMArray<nsIDocument> mDocuments;

   uint32_t                mMicroTaskLevel;

 };

 // XXX These belong somewhere else

 nsresult

 NS_NewHTMLDocument(nsIDocument** aInstancePtrResult, bool aLoadedAsData = false);

 nsresult

 NS_NewXMLDocument(nsIDocument** aInstancePtrResult, bool aLoadedAsData = false);

 nsresult

 NS_NewSVGDocument(nsIDocument** aInstancePtrResult);

 nsresult

 NS_NewImageDocument(nsIDocument** aInstancePtrResult);

 nsresult

 NS_NewVideoDocument(nsIDocument** aInstancePtrResult);

 // Note: it's the caller's responsibility to create or get aPrincipal as needed

 // -- this method will not attempt to get a principal based on aDocumentURI.

 // Also, both aDocumentURI and aBaseURI must not be null.

 nsresult

 NS_NewDOMDocument(nsIDOMDocument** aInstancePtrResult,

                   const nsAString& aNamespaceURI, 

                   const nsAString& aQualifiedName, 

                   nsIDOMDocumentType* aDoctype,