author Dylan Roeh <>
Tue, 28 Aug 2018 11:35:46 -0500
changeset 481113 31683bdf39d7bcacf8d9bf265fc2365024473fbe
parent 480201 e972452d0ef7fb2878c25cda8e7ceedeec854537
child 481265 de319cd7dd2b1909db62e5ee0c2a6fc11d47f668
permissions -rw-r--r--
Bug 1485178 - Only migrate sharedprefs when in Fennec. r=snorp a=ritu

/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at */
#ifndef nsIDocument_h___
#define nsIDocument_h___

#include "mozilla/FlushType.h"           // for enum
#include "nsAttrAndChildArray.h"
#include "nsAutoPtr.h"                   // for member
#include "nsCOMArray.h"                  // for member
#include "nsCompatibility.h"             // for member
#include "nsCOMPtr.h"                    // for member
#include "nsGkAtoms.h"                   // for static class members
#include "nsIApplicationCache.h"
#include "nsIApplicationCacheContainer.h"
#include "nsIContentViewer.h"
#include "nsIInterfaceRequestor.h"
#include "nsILoadContext.h"
#include "nsILoadGroup.h"                // for member (in nsCOMPtr)
#include "nsINode.h"                     // for base class
#include "nsIParser.h"
#include "nsIPresShell.h"
#include "nsIChannelEventSink.h"
#include "nsIProgressEventSink.h"
#include "nsISecurityEventSink.h"
#include "nsIScriptGlobalObject.h"       // for member (in nsCOMPtr)
#include "nsIServiceManager.h"
#include "nsIURI.h"                      // for use in inline functions
#include "nsIUUIDGenerator.h"
#include "nsPIDOMWindow.h"               // for use in inline functions
#include "nsPropertyTable.h"             // for member
#include "nsStringFwd.h"
#include "nsTHashtable.h"                // for member
#include "nsURIHashKey.h"
#include "mozilla/net/ReferrerPolicy.h"  // for member
#include "nsWeakReference.h"
#include "mozilla/UseCounter.h"
#include "mozilla/WeakPtr.h"
#include "Units.h"
#include "nsContentListDeclarations.h"
#include "nsExpirationTracker.h"
#include "nsClassHashtable.h"
#include "mozilla/CORSMode.h"
#include "mozilla/dom/DispatcherTrait.h"
#include "mozilla/dom/DocumentOrShadowRoot.h"
#include "mozilla/LinkedList.h"
#include "mozilla/NotNull.h"
#include "mozilla/SegmentedVector.h"
#include "mozilla/ServoBindingTypes.h"
#include "mozilla/StyleSheet.h"
#include "mozilla/TimeStamp.h"
#include "mozilla/UniquePtr.h"
#include <bitset>                        // for member

// windows.h #defines CreateEvent
#ifdef CreateEvent
#undef CreateEvent

#include "mozilla/dom/DocumentBinding.h"
namespace mozilla {
namespace dom {
class ElementCreationOptionsOrString;
} // namespace dom
} // namespace mozilla

class gfxUserFontSet;
class imgIRequest;
class nsBindingManager;
class nsCachableElementsByNameNodeList;
class nsIDocShell;
class nsDocShell;
class nsDOMNavigationTiming;
class nsDOMStyleSheetSetList;
class nsFrameLoader;
class nsGlobalWindowInner;
class nsHTMLCSSStyleSheet;
class nsHTMLDocument;
class nsHTMLStyleSheet;
class nsGenericHTMLElement;
class nsAtom;
class nsIBFCacheEntry;
class nsIChannel;
class nsIContent;
class nsIContentSink;
class nsIDocShell;
class nsIDocShellTreeItem;
class nsIDocumentEncoder;
class nsIDocumentObserver;
class nsIHTMLCollection;
class nsILayoutHistoryState;
class nsILoadContext;
class nsIObjectLoadingContent;
class nsIObserver;
class nsIPrincipal;
class nsIRequest;
class nsIRunnable;
class nsISecurityConsoleMessage;
class nsIStreamListener;
class nsIStructuredCloneContainer;
class nsIURI;
class nsIVariant;
class nsViewManager;
class nsPresContext;
class nsRange;
class nsSMILAnimationController;
class nsSVGElement;
class nsTextNode;
class nsUnblockOnloadEvent;
class nsWindowSizes;
class nsDOMCaretPosition;
class nsViewportInfo;
class nsIGlobalObject;
class nsIXULWindow;

namespace mozilla {
class AbstractThread;
class CSSStyleSheet;
class Encoding;
class ErrorResult;
class EventStates;
class EventListenerManager;
class PendingAnimationTracker;
class ServoStyleSet;
template<typename> class OwningNonNull;
struct URLExtraData;

namespace css {
class Loader;
class ImageLoader;
class Rule;
} // namespace css

namespace dom {
class Animation;
class AnonymousContent;
class Attr;
class BoxObject;
class ClientInfo;
class ClientState;
class CDATASection;
class Comment;
struct CustomElementDefinition;
class DocGroup;
class DocumentFragment;
class DocumentTimeline;
class DocumentType;
class DOMImplementation;
class DOMIntersectionObserver;
class DOMStringList;
class Element;
struct ElementCreationOptions;
class Event;
class EventTarget;
class FontFaceSet;
class FrameRequestCallback;
struct FullscreenRequest;
class ImageTracker;
class HTMLBodyElement;
class HTMLSharedElement;
class HTMLImageElement;
struct LifecycleCallbackArgs;
class Link;
class Location;
class MediaQueryList;
class GlobalObject;
class NodeFilter;
class NodeIterator;
enum class OrientationType : uint8_t;
class ProcessingInstruction;
class Promise;
class ScriptLoader;
class Selection;
class ServiceWorkerDescriptor;
class StyleSheetList;
class SVGDocument;
class SVGSVGElement;
class Touch;
class TouchList;
class TreeWalker;
class XPathEvaluator;
class XPathExpression;
class XPathNSResolver;
class XPathResult;
class XULDocument;
template<typename> class Sequence;

template<typename, typename> class CallbackObjectHolder;

enum class CallerType : uint32_t;

} // namespace dom
} // namespace mozilla

// Must be kept in sync with xpcom/rust/xpcom/src/interfaces/
{ 0xce1f7627, 0x7109, 0x4977, \
  { 0xba, 0x77, 0x49, 0x0f, 0xfd, 0xe0, 0x7a, 0xaa } }

// 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
  DocumentFlavorPlain, // Just a Document

// Document states

// RTL locale: specific to the XUL localedir attribute
// Window activation status

// Some function forward-declarations
class nsContentList;
class nsDocumentOnStack;

class nsDocHeaderData
  nsDocHeaderData(nsAtom* aField, const nsAString& aData)
    : mField(aField), mData(aData), mNext(nullptr)

    delete mNext;

  RefPtr<nsAtom> mField;
  nsString mData;
  nsDocHeaderData* mNext;

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

   * 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
    virtual ~ExternalResourceLoad() {}

    void AddObserver(nsIObserver* aObserver)
      MOZ_ASSERT(aObserver, "Must have observer");

    const nsTArray<nsCOMPtr<nsIObserver>> & Observers()
      return mObservers;
    AutoTArray<nsCOMPtr<nsIObserver>, 8> mObservers;


   * Request an external resource document.  This does exactly what
   * nsIDocument::RequestExternalResource is documented to do.
  nsIDocument* RequestResource(nsIURI* aURI,
                               nsINode* aRequestingNode,
                               nsIDocument* aDisplayDocument,
                               ExternalResourceLoad** aPendingLoad);

   * Enumerate the resource documents.  See
   * nsIDocument::EnumerateExternalResources.
  void EnumerateResources(nsSubDocEnumFunc aCallback, void* aData);

   * Traverse ourselves for cycle-collection
  void Traverse(nsCycleCollectionTraversalCallback* aCallback) const;

   * Shut ourselves down (used for cycle-collection unlink), as well
   * as for document destruction.
  void Shutdown()
    mHaveShutDown = true;

  bool HaveShutDown() const
    return mHaveShutDown;

  // Needs to be public so we can traverse them sanely
  struct ExternalResource
    nsCOMPtr<nsIDocument> mDocument;
    nsCOMPtr<nsIContentViewer> mViewer;
    nsCOMPtr<nsILoadGroup> mLoadGroup;

  // Hide all our viewers
  void HideViewers();

  // Show all our viewers
  void ShowViewers();

  class PendingLoad : public ExternalResourceLoad,
                      public nsIStreamListener
    ~PendingLoad() {}

    explicit PendingLoad(nsIDocument* aDisplayDocument) :


     * Start aURI loading.  This will perform the necessary security checks and
     * so forth.
    nsresult StartLoad(nsIURI* aURI, nsINode* aRequestingNode);

     * Set up an nsIContentViewer based on aRequest.  This is guaranteed to
     * put null in *aViewer and *aLoadGroup on all failures.
    nsresult SetupViewer(nsIRequest* aRequest, nsIContentViewer** aViewer,
                         nsILoadGroup** aLoadGroup);

    nsCOMPtr<nsIDocument> mDisplayDocument;
    nsCOMPtr<nsIStreamListener> mTargetListener;
    nsCOMPtr<nsIURI> mURI;
  friend class PendingLoad;

  class LoadgroupCallbacks final : public nsIInterfaceRequestor
    ~LoadgroupCallbacks() {}
    explicit LoadgroupCallbacks(nsIInterfaceRequestor* aOtherCallbacks)
      : mCallbacks(aOtherCallbacks)
    // The only reason it's safe to hold a strong ref here without leaking is
    // that the notificationCallbacks on a loadgroup aren't the docshell itself
    // but a shim that holds a weak reference to the docshell.
    nsCOMPtr<nsIInterfaceRequestor> mCallbacks;

    // Use shims for interfaces that docshell implements directly so that we
    // don't hand out references to the docshell.  The shims should all allow
    // getInterface back on us, but other than that each one should only
    // implement one interface.

    // XXXbz I wish we could just derive the _allcaps thing from _i
#define DECL_SHIM(_i, _allcaps)                                              \
    class _i##Shim final : public nsIInterfaceRequestor,                     \
                           public _i                                         \
    {                                                                        \
      ~_i##Shim() {}                                                         \
    public:                                                                  \
      _i##Shim(nsIInterfaceRequestor* aIfreq, _i* aRealPtr)                  \
        : mIfReq(aIfreq), mRealPtr(aRealPtr)                                 \
      {                                                                      \
        NS_ASSERTION(mIfReq, "Expected non-null here");                      \
        NS_ASSERTION(mRealPtr, "Expected non-null here");                    \
      }                                                                      \
      NS_DECL_ISUPPORTS                                                      \
      NS_FORWARD_NSIINTERFACEREQUESTOR(mIfReq->)                             \
      NS_FORWARD_##_allcaps(mRealPtr->)                                      \
    private:                                                                 \
      nsCOMPtr<nsIInterfaceRequestor> mIfReq;                                \
      nsCOMPtr<_i> mRealPtr;                                                 \

#undef DECL_SHIM

   * Add an ExternalResource for aURI.  aViewer and aLoadGroup might be null
   * when this is called if the URI didn't result in an XML document.  This
   * function makes sure to remove the pending load for aURI, if any, from our
   * hashtable, and to notify its observers, if any.
  nsresult AddExternalResource(nsIURI* aURI, nsIContentViewer* aViewer,
                               nsILoadGroup* aLoadGroup,
                               nsIDocument* aDisplayDocument);

  nsClassHashtable<nsURIHashKey, ExternalResource> mMap;
  nsRefPtrHashtable<nsURIHashKey, PendingLoad> mPendingLoads;
  bool mHaveShutDown;


// For classifying a flash document based on its principal.
class PrincipalFlashClassifier;

// Document interface.  This is implemented by all document objects in
// Gecko.
class nsIDocument : public nsINode,
                    public mozilla::dom::DocumentOrShadowRoot,
                    public mozilla::dom::DispatcherTrait
  typedef mozilla::dom::GlobalObject GlobalObject;

  using Encoding = mozilla::Encoding;
  template <typename T> using NotNull = mozilla::NotNull<T>;

  typedef nsExternalResourceMap::ExternalResourceLoad ExternalResourceLoad;
  typedef mozilla::net::ReferrerPolicy ReferrerPolicyEnum;
  typedef mozilla::dom::Element Element;
  typedef mozilla::dom::FullscreenRequest FullscreenRequest;



  // This helper class must be set when we dispatch beforeunload and unload
  // events in order to avoid unterminate sync XHRs.
  class MOZ_RAII PageUnloadingEventTimeStamp
    nsCOMPtr<nsIDocument> mDocument;
    bool mSet;

    explicit PageUnloadingEventTimeStamp(nsIDocument* aDocument)
      : mDocument(aDocument)
      , mSet(false)
      if (mDocument->mPageUnloadingEventTimeStamp.IsNull()) {
        mSet = true;

      if (mSet) {

   * 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;

  virtual void SetSuppressParserErrorElement(bool aSuppress) {}
  virtual bool SuppressParserErrorElement() { return false; }

  virtual void SetSuppressParserErrorConsoleMessages(bool aSuppress) {}
  virtual bool SuppressParserErrorConsoleMessages() { return false; }

  // nsINode
  bool IsNodeOfType(uint32_t aFlags) const final;
  nsIContent* GetChildAt_Deprecated(uint32_t aIndex) const final
    return mChildren.GetSafeChildAt(aIndex);

  int32_t ComputeIndexOf(const nsINode* aPossibleChild) const final
    return mChildren.IndexOfChild(aPossibleChild);

  uint32_t GetChildCount() const final
    return mChildren.ChildCount();

  nsresult InsertChildBefore(nsIContent* aKid, nsIContent* aBeforeThis,
                             bool aNotify) override;
  void RemoveChildNode(nsIContent* aKid, bool aNotify) final;
  nsresult Clone(mozilla::dom::NodeInfo* aNodeInfo,
                 nsINode **aResult,
                 bool aPreallocateChildren) const override

   * 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.
  void NotifyPossibleTitleChange(bool aBoundTitleElement);

   * Return the URI for the document. May return null.
   * The value returned corresponds to the "document's address" in
   * HTML5.  As such, it may change over the lifetime of the document, for
   * instance as a result of the user navigating to a fragment identifier on
   * the page, or as a result to 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 that has changed from its original value (for
   * example, due to history.pushState() or replaceState() being invoked on the
   * document).
   * This method corresponds to the "creation URL" 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.
  void SetDocumentURI(nsIURI* aURI);

   * Set the URI for the document loaded via XHR, when accessed from
   * chrome privileged script.
  void SetChromeXHRDocURI(nsIURI* aURI)
    mChromeXHRDocURI = aURI;

   * Set the base URI for the document loaded via XHR, when accessed from
   * chrome privileged script.
  void SetChromeXHRDocBaseURI(nsIURI* aURI)
    mChromeXHRDocBaseURI = aURI;

   * Set referrer policy and upgrade-insecure-requests flags
  void ApplySettingsFromCSP(bool aSpeculative);

  already_AddRefed<nsIParser> CreatorParserOrNull()
    nsCOMPtr<nsIParser> parser = mParser;
    return parser.forget();

   * Return the referrer policy of the document. Return "default" if there's no
   * valid meta referrer tag found in the document.
  ReferrerPolicyEnum GetReferrerPolicy() const
    return mReferrerPolicy;

   * GetReferrerPolicy() for Document.webidl.
  uint32_t ReferrerPolicy() const
    return GetReferrerPolicy();

   * If true, this flag indicates that all mixed content subresource
   * loads for this document (and also embeded browsing contexts) will
   * be blocked.
  bool GetBlockAllMixedContent(bool aPreload) const
    if (aPreload) {
      return mBlockAllMixedContentPreloads;
    return mBlockAllMixedContent;

   * If true, this flag indicates that all subresource loads for this
   * document need to be upgraded from http to https.
   * This flag becomes true if the CSP of the document itself, or any
   * of the document's ancestors up to the toplevel document makes use
   * of the CSP directive 'upgrade-insecure-requests'.
  bool GetUpgradeInsecureRequests(bool aPreload) const
    if (aPreload) {
      return mUpgradeInsecurePreloads;
    return mUpgradeInsecureRequests;

  void SetReferrer(const nsACString& aReferrer) {
    mReferrer = aReferrer;

   * Set the principal responsible for this document.  Chances are,
   * you do not want to be using this.
  void SetPrincipal(nsIPrincipal* aPrincipal);

   * Get the list of ancestor principals for a document.  This is the same as
   * the ancestor list for the document's docshell the last time SetContainer()
   * was called with a non-null argument. See the documentation for the
   * corresponding getter in docshell for how this list is determined.  We store
   * a copy of the list, because we may lose the ability to reach our docshell
   * before people stop asking us for this information.
  const nsTArray<nsCOMPtr<nsIPrincipal>>& AncestorPrincipals() const
    return mAncestorPrincipals;

   * Get the list of ancestor outerWindowIDs for a document that correspond to
   * the ancestor principals (see above for more details).
  const nsTArray<uint64_t>& AncestorOuterWindowIDs() const
    return mAncestorOuterWindowIDs;

   * 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 fallback base URL for this document, as defined in the HTML
   * specification.  Note that this can return null if there is no document URI.
   * XXXbz: This doesn't implement the bits for about:blank yet.
  nsIURI* GetFallbackBaseURI() const
    if (mIsSrcdocDocument && mParentDocument) {
      return mParentDocument->GetDocBaseURI();
    return mDocumentURI;

   * 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 and has no explicit base URL, return the parent
   * document's base URL.
  nsIURI* GetDocBaseURI() const
    if (mDocumentBaseURI) {
      return mDocumentBaseURI;
    return GetFallbackBaseURI();

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

  void SetBaseURI(nsIURI* aURI);

   * Return the URL data which style system needs for resolving url value.
   * This method attempts to use the cached object in mCachedURLData, but
   * if the base URI, document URI, or principal has changed since last
   * call to this function, or the function is called the first time for
   * the document, a new one is created.
  mozilla::URLExtraData* DefaultStyleAttrURLData();

   * Get/Set the base target of a link in a document.
  void GetBaseTarget(nsAString& aBaseTarget) const
    aBaseTarget = mBaseTarget;

  void SetBaseTarget(const nsString& aBaseTarget) {
    mBaseTarget = aBaseTarget;

   * Return a standard name for the document's character set.
  NotNull<const Encoding*> GetDocumentCharacterSet() const
    return mCharacterSet;

   * Set the document's character encoding.
  virtual void SetDocumentCharacterSet(NotNull<const Encoding*> aEncoding);

  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;

   * Get the Content-Type of this document.
  void GetContentType(nsAString& aContentType);

   * Set the Content-Type of this document.
  virtual void SetContentType(const nsAString& aContentType);

   * 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;

   * Normally we assert if a runnable labeled with one DocGroup touches data
   * from another DocGroup. Calling IgnoreDocGroupMismatches() on a document
   * means that we can touch that document from any DocGroup without asserting.
  void IgnoreDocGroupMismatches()
    mIgnoreDocGroupMismatches = true;

   * 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;

   * Set the mixed content object subrequest flag for this document.
  void SetHasMixedContentObjectSubrequest(bool aHasMixedContentObjectSubrequest)
    mHasMixedContentObjectSubrequest = aHasMixedContentObjectSubrequest;

   * Set CSP flag for this document.
  void SetHasCSP(bool aHasCSP)
    mHasCSP = aHasCSP;

   * Set unsafe-inline CSP flag for this document.
  void SetHasUnsafeInlineCSP(bool aHasUnsafeInlineCSP)
    mHasUnsafeInlineCSP = aHasUnsafeInlineCSP;

   * Set unsafe-eval CSP flag for this document.
  void SetHasUnsafeEvalCSP(bool aHasUnsafeEvalCSP)
    mHasUnsafeEvalCSP = aHasUnsafeEvalCSP;

   * Get tracking content blocked flag for this document.
  bool GetHasTrackingContentBlocked()
    return mHasTrackingContentBlocked;

   * Set the tracking content blocked flag for this document.
  void SetHasTrackingContentBlocked(bool aHasTrackingContentBlocked)
    mHasTrackingContentBlocked = aHasTrackingContentBlocked;

   * Get tracking content loaded flag for this document.
  bool GetHasTrackingContentLoaded()
    return mHasTrackingContentLoaded;

   * Set the tracking content loaded flag for this document.
  void SetHasTrackingContentLoaded(bool aHasTrackingContentLoaded)
    mHasTrackingContentLoaded = aHasTrackingContentLoaded;

   * Get the sandbox flags for this document.
   * @see nsSandboxFlags.h for the possible flags
  uint32_t GetSandboxFlags() const
    return mSandboxFlags;

   * Get string representation of sandbox flags (null if no flags are set)
  void GetSandboxFlagsAsString(nsAString& aFlags);

   * Set the sandbox flags for this document.
   * @see nsSandboxFlags.h for the possible flags
  void SetSandboxFlags(uint32_t sandboxFlags)
    mSandboxFlags = sandboxFlags;

   * Called when the document was decoded as UTF-8 and decoder encountered no
   * errors.
  void EnableEncodingMenu()
    mEncodingMenuDisabled = false;

   * Access HTTP header data (this may also get set from other
   * sources, like HTML META tags).
  void GetHeaderData(nsAtom* aHeaderField, nsAString& aData) const;
  void SetHeaderData(nsAtom* aheaderField, const nsAString& aData);

   * 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.
  already_AddRefed<nsIPresShell> CreateShell(
    nsPresContext* aContext,
    nsViewManager* aViewManager,
    mozilla::UniquePtr<mozilla::ServoStyleSet> aStyleSet);
  void DeleteShell();

  nsIPresShell* GetShell() const
    return GetBFCacheEntry() ? nullptr : mPresShell;

  nsIPresShell* GetObservingShell() const
    return mPresShell && mPresShell->IsObservingDocument()
      ? mPresShell : nullptr;

  // Return whether the presshell for this document is safe to flush.
  bool IsSafeToFlush() const;

  nsPresContext* GetPresContext() const
    nsIPresShell* shell = GetShell();
    return shell ? shell->GetPresContext() : nullptr;

  bool HasShellOrBFCacheEntry() const
    return mPresShell || mBFCacheEntry;

  // Instead using this method, what you probably want is
  // RemoveFromBFCacheSync() as we do in MessagePort and BroadcastChannel.
  void DisallowBFCaching()
    NS_ASSERTION(!mBFCacheEntry, "We're already in the bfcache!");
    mBFCacheDisallowed = true;

  bool IsBFCachingAllowed() const
    return !mBFCacheDisallowed;

  // Accepts null to clear the BFCache entry too.
  void SetBFCacheEntry(nsIBFCacheEntry* 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;
    if (aParent) {
      mIgnoreDocGroupMismatches = aParent->mIgnoreDocGroupMismatches;

   * Are plugins allowed in this document ?
  bool GetAllowPlugins();

   * Set the sub document for aContent to aSubDoc.
  nsresult SetSubDocumentFor(Element* aContent, nsIDocument* aSubDoc);

   * Get the sub document for aContent
  nsIDocument* GetSubDocumentFor(nsIContent* aContent) const;

   * Find the content node for which aDocument is a sub document.
  Element* FindContentForSubDocument(nsIDocument* aDocument) const;

   * Return the doctype for this document.
  mozilla::dom::DocumentType* GetDoctype() const;

   * Return the root element for this document.
  Element* GetRootElement() const;

  mozilla::dom::Selection* GetSelection(mozilla::ErrorResult& aRv);

   * Gets the event target to dispatch key events to if there is no focused
   * content in the document.
  virtual nsIContent* GetUnfocusedKeyEventTarget();

   * Retrieve information about the viewport as a data structure.
   * This will return information in the viewport META data section
   * of the document. This can be used in lieu of ProcessViewportInfo(),
   * which places the viewport information in the document header instead
   * of returning it directly.
   * @param aDisplaySize size of the on-screen display area for this
   * document, in device pixels.
   * NOTE: If the site is optimized for mobile (via the doctype), this
   * will return viewport information that specifies default information.
  nsViewportInfo GetViewportInfo(const mozilla::ScreenIntSize& aDisplaySize);

   * It updates the viewport overflow type with the given two widths
   * and the viewport setting of the document.
   * This should only be called when there is out-of-reach overflow
   * happens on the viewport, i.e. the viewport should be using
   * `overflow: hidden`. And it should only be called on a top level
   * content document.
  void UpdateViewportOverflowType(nscoord aScrolledWidth,
                                  nscoord aScrollportWidth);

   * 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;

  InsertAnonymousContent(mozilla::dom::Element& aElement,
                         mozilla::ErrorResult& aError);
  void RemoveAnonymousContent(mozilla::dom::AnonymousContent& aContent,
                              mozilla::ErrorResult& aError);
   * If aNode is a descendant of anonymous content inserted by
   * InsertAnonymousContent, this method returns the root element of the
   * inserted anonymous content (in other words, the clone of the aElement
   * that was passed to InsertAnonymousContent).
  Element* GetAnonRootIfInAnonymousContentContainer(nsINode* aNode) const;
  nsTArray<RefPtr<mozilla::dom::AnonymousContent>>& GetAnonymousContents() {
    return mAnonymousContents;

  mozilla::TimeStamp GetPageUnloadingEventTimeStamp() const
    if (!mParentDocument) {
      return mPageUnloadingEventTimeStamp;

    mozilla::TimeStamp parentTimeStamp(mParentDocument->GetPageUnloadingEventTimeStamp());
    if (parentTimeStamp.IsNull()) {
      return mPageUnloadingEventTimeStamp;

    if (!mPageUnloadingEventTimeStamp ||
        parentTimeStamp < mPageUnloadingEventTimeStamp) {
      return parentTimeStamp;

    return mPageUnloadingEventTimeStamp;

  void NotifyLayerManagerRecreated();

   * Add an SVG element to the list of elements that need
   * their mapped attributes resolved to a Servo declaration block.
   * These are weak pointers, please manually unschedule them when an element
   * is removed.
  void ScheduleSVGForPresAttrEvaluation(nsSVGElement* aSVG)

  // Unschedule an element scheduled by ScheduleFrameRequestCallback (e.g. for
  // when it is destroyed)
  void UnscheduleSVGForPresAttrEvaluation(nsSVGElement* aSVG)

  // Resolve all SVG pres attrs scheduled in ScheduleSVGForPresAttrEvaluation
  void ResolveScheduledSVGPresAttrs();

  mozilla::Maybe<mozilla::dom::ClientInfo> GetClientInfo() const;
  mozilla::Maybe<mozilla::dom::ClientState> GetClientState() const;
  mozilla::Maybe<mozilla::dom::ServiceWorkerDescriptor> GetController() const;

  // Returns the size of the mBlockedTrackingNodes array.
  // This array contains nodes that have been blocked to prevent
  // user tracking. They most likely have had their nsIChannel
  // canceled by the URL classifier (Safebrowsing).
  // A script can subsequently use GetBlockedTrackingNodes()
  // to get a list of references to these nodes.
  // Note:
  // This expresses how many tracking nodes have been blocked for this
  // document since its beginning, not how many of them are still around
  // in the DOM tree. Weak references to blocked nodes are added in the
  // mBlockedTrackingNodesArray but they are not removed when those nodes
  // are removed from the tree or even garbage collected.
  long BlockedTrackingNodeCount() const
    return mBlockedTrackingNodes.Length();

  // Returns strong references to mBlockedTrackingNodes. (nsIDocument.h)
  // This array contains nodes that have been blocked to prevent
  // user tracking. They most likely have had their nsIChannel
  // canceled by the URL classifier (Safebrowsing).
  already_AddRefed<nsSimpleContentList> BlockedTrackingNodes() const;

  friend class nsUnblockOnloadEvent;

  nsresult InitCSP(nsIChannel* aChannel);

  void PostUnblockOnloadEvent();

  void DoUnblockOnload();

  void ClearAllBoxObjects();

  void MaybeEndOutermostXBLUpdate();

  void DispatchContentLoadedEvents();

  void DispatchPageTransition(mozilla::dom::EventTarget* aDispatchTarget,
                              const nsAString& aType,
                              bool aPersisted);

  // Call this before the document does something that will unbind all content.
  // That will stop us from doing a lot of work as each element is removed.
  void DestroyElementMaps();

  Element* GetRootElementInternal() const;
  void DoNotifyPossibleTitleChange();

  void SetPageUnloadingEventTimeStamp()
    mPageUnloadingEventTimeStamp = mozilla::TimeStamp::NowLoRes();

  void CleanUnloadEventsTimeStamp()
    mPageUnloadingEventTimeStamp = mozilla::TimeStamp();

   * Clears any Servo element data stored on Elements in the document.
  void ClearStaleServoData();

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

      nsString mKey;
      nsExpirationState mState;

      nsExpirationState* GetExpirationState() { return &mState; }


  class SelectorCacheKeyDeleter;

  class SelectorCache final
    : public nsExpirationTracker<SelectorCacheKey, 4>
    using SelectorList = mozilla::UniquePtr<RawServoSelectorList>;

    explicit SelectorCache(nsIEventTarget* aEventTarget);

    void CacheList(const nsAString& aSelector, SelectorList aSelectorList)
      SelectorCacheKey* key = new SelectorCacheKey(aSelector);
      mTable.Put(key->mKey, std::move(aSelectorList));

    void NotifyExpired(SelectorCacheKey* aSelector) final;

    // 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 the selector list returned has a null
    // RawServoSelectorList*, that indicates that aSelector has already been
    // parsed and is not a syntactically valid selector.
    SelectorList* GetList(const nsAString& aSelector)
      return mTable.GetValue(aSelector);


    nsDataHashtable<nsStringHashKey, SelectorList> mTable;

  SelectorCache& GetSelectorCache() {
    if (!mSelectorCache) {
      mSelectorCache =
    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(nsAtom* 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);
  // Get the "body" in the sense of document.body: The first <body> or
  // <frameset> that's a child of a root <html>
  nsGenericHTMLElement* GetBody();
  // Set the "body" in the sense of document.body.
  void SetBody(nsGenericHTMLElement* aBody, mozilla::ErrorResult& rv);
  // Get the "head" element in the sense of document.head.
  mozilla::dom::HTMLSharedElement* GetHead();

   * Accessors to the collection of stylesheets owned by this document.
   * Style sheets are ordered, most significant last.

   * These exists to allow us to on-demand load user-agent style sheets that
   * would otherwise be loaded by nsDocumentViewer::CreateStyleSet. This allows
   * us to keep the memory used by a document's rule cascade data (the stuff in
   * its nsStyleSet's nsCSSRuleProcessors) - which can be considerable - lower
   * than it would be if we loaded all built-in user-agent style sheets up
   * front.
   * By "built-in" user-agent style sheets we mean the user-agent style sheets
   * that gecko itself supplies (such as html.css and svg.css) as opposed to
   * user-agent level style sheets inserted by add-ons or the like.
   * This function prepends the given style sheet to the document's style set
   * in order to make sure that it does not override user-agent style sheets
   * supplied by add-ons or by the app (Firefox OS or Firefox Mobile, for
   * example), since their sheets should override built-in sheets.
   * TODO We can get rid of the whole concept of delayed loading if we fix
   * bug 77999.
  void EnsureOnDemandBuiltInUASheet(mozilla::StyleSheet* aSheet);

  mozilla::dom::StyleSheetList* StyleSheets()
    return &DocumentOrShadowRoot::EnsureDOMStyleSheets();

  void InsertSheetAt(size_t aIndex, mozilla::StyleSheet&);

   * 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.
  void UpdateStyleSheets(
      nsTArray<RefPtr<mozilla::StyleSheet>>& aOldSheets,
      nsTArray<RefPtr<mozilla::StyleSheet>>& aNewSheets);

   * Add a stylesheet to the document
   * TODO(emilio): This is only used by parts of editor that are no longer in
   * use by m-c or c-c, so remove.
  void AddStyleSheet(mozilla::StyleSheet* aSheet)
    InsertSheetAt(SheetCount(), *aSheet);

   * Remove a stylesheet from the document
  void RemoveStyleSheet(mozilla::StyleSheet* aSheet);

   * Notify the document that the applicable state of the sheet changed
   * and that observers should be notified and style sets updated
  void SetStyleSheetApplicableState(mozilla::StyleSheet* aSheet,
                                    bool aApplicable);

  enum additionalSheetType {

  nsresult LoadAdditionalStyleSheet(additionalSheetType aType,
                                    nsIURI* aSheetURI);
  nsresult AddAdditionalStyleSheet(additionalSheetType aType,
                                   mozilla::StyleSheet* aSheet);
  void RemoveAdditionalStyleSheet(additionalSheetType aType, nsIURI* sheetURI);

  mozilla::StyleSheet* GetFirstAdditionalAuthorSheet()
    return mAdditionalSheets[eAuthorSheet].SafeElementAt(0);

   * Assuming that aDocSheets is an array of document-level style
   * sheets for this document, returns the index that aSheet should
   * be inserted at to maintain document ordering.
   * Type T has to cast to StyleSheet*.
   * Defined in nsIDocumentInlines.h.
  template<typename T>
  size_t FindDocStyleSheetInsertionPoint(const nsTArray<T>& aDocSheets,
                                         const mozilla::StyleSheet& aSheet);

   * 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)
  nsIChannel* GetChannel() const
    return mChannel;

   * 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);

   * 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.
    GetScriptHandlingObject(bool& aHasHadScriptHandlingObject) const
    aHasHadScriptHandlingObject = mHasHadScriptHandlingObject;
    return mScriptGlobalObject ? mScriptGlobalObject.get() :
  void SetScriptHandlingObject(nsIScriptGlobalObject* aScriptObject);

   * 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.
  nsIGlobalObject* GetScopeObject() const;
  void SetScopeObject(nsIGlobalObject* aGlobal);

   * Return the window containing the document (the outer window).
  nsPIDOMWindowOuter *GetWindow() const
    return mWindow ? mWindow->GetOuterWindow() : GetWindowInternal();

  bool IsInBackgroundWindow() const
    auto* 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().
  nsPIDOMWindowInner* GetInnerWindow() const
    return mRemovedFromDocShell ? nullptr : mWindow;

   * Return the outer window ID.
  uint64_t OuterWindowID() const
    nsPIDOMWindowOuter* window = GetWindow();
    return window ? window->WindowID() : 0;

   * Return the inner window ID.
  uint64_t InnerWindowID() const
    nsPIDOMWindowInner* window = GetInnerWindow();
    return window ? window->WindowID() : 0;

  bool IsTopLevelWindowInactive() const;

   * Get the script loader for this document
  mozilla::dom::ScriptLoader* ScriptLoader()
    return mScriptLoader;

   * Add/Remove an element to the document's id and name hashes
  void AddToIdTable(Element* aElement, nsAtom* aId);
  void RemoveFromIdTable(Element* aElement, nsAtom* aId);
  void AddToNameTable(Element* aElement, nsAtom* aName);
  void RemoveFromNameTable(Element* aElement, nsAtom* aName);

   * Returns all elements in the fullscreen stack in the insertion order.
  nsTArray<Element*> GetFullscreenStack() const;

   * 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.
  void AsyncRequestFullScreen(mozilla::UniquePtr<FullscreenRequest>&&);

  // Do the "fullscreen element ready check" from the fullscreen spec.
  // It returns true if the given element is allowed to go into fullscreen.
  bool FullscreenElementReadyCheck(Element* aElement, bool aWasCallerChrome);

  // This is called asynchronously by nsIDocument::AsyncRequestFullScreen()
  // to move this document into full-screen mode if allowed.
  void RequestFullScreen(mozilla::UniquePtr<FullscreenRequest>&& aRequest);

  // Removes all elements from the full-screen stack, removing full-scren
  // styles from the top element in the stack.
  void CleanupFullscreenState();

  // Pushes aElement onto the full-screen stack, and removes full-screen styles
  // from the former full-screen stack top, and its ancestors, and applies the
  // styles to aElement. aElement becomes the new "full-screen element".
  bool FullScreenStackPush(Element* aElement);

  // Remove the top element from the full-screen stack. Removes the full-screen
  // styles from the former top element, and applies them to the new top
  // element, if there is one.
  void FullScreenStackPop();

   * 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.
  nsresult RemoteFrameFullscreenChanged(mozilla::dom::Element* aFrameElement);

   * 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.
   nsresult RemoteFrameFullscreenReverted();

   * 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.
  void RestorePreviousFullScreenState();

   * Returns true if this document is a fullscreen leaf document, i.e. it
   * is in fullscreen mode and has no fullscreen children.
  bool IsFullscreenLeaf();

   * 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.
  nsIDocument* GetFullscreenRoot();

   * Sets the fullscreen root to aRoot. This stores a weak reference to aRoot
   * in this document.
  void SetFullscreenRoot(nsIDocument* aRoot);

   * Synchronously cleans up the fullscreen state on the given document.
   * Calling this without performing fullscreen transition could lead
   * to undesired effect (the transition happens after document state
   * flips), hence it should only be called either by nsGlobalWindow
   * when we have performed the transition, or when it is necessary to
   * clean up the state immediately. Otherwise, AsyncExitFullscreen()
   * should be called instead.
   * aDocument must not be null.
  static void ExitFullscreenInDocTree(nsIDocument* aDocument);

   * Ask the document to exit fullscreen state asynchronously.
   * Different from ExitFullscreenInDocTree(), this allows the window
   * to perform fullscreen transition first if any.
   * If aDocument is null, it will exit fullscreen from all documents
   * in all windows.
  static void AsyncExitFullscreen(nsIDocument* aDocument);

   * Handles any pending fullscreen in aDocument or its subdocuments.
   * Returns whether there is any fullscreen request handled.
  static bool HandlePendingFullscreenRequests(nsIDocument* aDocument);

   * Dispatch fullscreenerror event and report the failure message to
   * the console.
  void DispatchFullscreenError(const char* aMessage);

  void RequestPointerLock(Element* aElement, mozilla::dom::CallerType);
  bool SetPointerLock(Element* aElement, int aCursorStyle);

  static void UnlockPointer(nsIDocument* aDoc = nullptr);

  // ScreenOrientation related APIs

  void SetCurrentOrientation(mozilla::dom::OrientationType aType,
                             uint16_t aAngle)
    mCurrentOrientationType = aType;
    mCurrentOrientationAngle = aAngle;

  uint16_t CurrentOrientationAngle() const
    return mCurrentOrientationAngle;
  mozilla::dom::OrientationType CurrentOrientationType() const
    return mCurrentOrientationType;
  void SetOrientationPendingPromise(mozilla::dom::Promise* aPromise);
  mozilla::dom::Promise* GetOrientationPendingPromise() const
    return mOrientationPendingPromise;


  // 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.
  void AddObserver(nsIDocumentObserver* aObserver);

   * Remove an observer of document change notifications. This will
   * return false if the observer cannot be found.
  bool RemoveObserver(nsIDocumentObserver* aObserver);

  // 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.
  void BeginUpdate();
  virtual void EndUpdate() = 0;

  virtual void BeginLoad() = 0;
  virtual void EndLoad() = 0;

  void SetReadyStateInternal(ReadyState rs);
  ReadyState GetReadyStateEnum()
    return mReadyState;

  // notify that a content node changed state.  This must happen under
  // a scriptblocker but NOT within a begin/end update.
  void ContentStateChanged(
      nsIContent* aContent, mozilla::EventStates aStateMask);

  // 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.
  void DocumentStatesChanged(mozilla::EventStates aStateMask);

  // Observation hooks for style data to propagate notifications
  // to document observers
  void StyleRuleChanged(mozilla::StyleSheet* aStyleSheet,
                        mozilla::css::Rule* aStyleRule);
  void StyleRuleAdded(mozilla::StyleSheet* aStyleSheet,
                      mozilla::css::Rule* aStyleRule);
  void StyleRuleRemoved(mozilla::StyleSheet* aStyleSheet,
                        mozilla::css::Rule* aStyleRule);

   * Flush notifications for this document and its parent documents
   * (since those may affect the layout of this one).
  void FlushPendingNotifications(mozilla::FlushType aType);

   * Another variant of the above FlushPendingNotifications.  This function
   * takes a ChangesToFlush to specify whether throttled animations are flushed
   * or not.
   * If in doublt, use the above FlushPendingNotifications.
  void FlushPendingNotifications(mozilla::ChangesToFlush aFlush);

   * 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 >= FlushType::Style.
  void FlushExternalResources(mozilla::FlushType aType);

  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);

   * 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);

   * 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.
  void SetXMLDeclaration(const char16_t* aVersion,
                         const char16_t* aEncoding,
                         const int32_t aStandalone);
  void GetXMLDeclaration(nsAString& aVersion,
                         nsAString& aEncoding,
                         nsAString& Standalone);

   * Returns true if this is what HTML 5 calls an "HTML document" (for example
   * regular HTML document with Content-Type "text/html", image documents and
   * media documents).  Returns false for XHTML and any other documents parsed
   * by the XML parser.
  bool IsHTMLDocument() const
    return mType == eHTML;
  bool IsHTMLOrXHTML() const
    return mType == eHTML || mType == eXHTML;
  bool IsXMLDocument() const
    return !IsHTMLDocument();
  bool IsSVGDocument() const
    return mType == eSVG;
  bool IsXULDocument() const
    return mType == eXUL;
  bool IsUnstyledDocument()
    return IsLoadedAsData() || IsLoadedAsInteractiveData();
  bool LoadsFullXULStyleSheetUpFront()
    if (IsXULDocument()) {
      return true;
    if (IsSVGDocument()) {
      return false;
    return AllowXULXBL();

  bool IsScriptEnabled();

  bool IsTopLevelContentDocument() const { return mIsTopLevelContentDocument; }
  void SetIsTopLevelContentDocument(bool aIsTopLevelContentDocument)
    mIsTopLevelContentDocument = aIsTopLevelContentDocument;
    // When a document is set as TopLevelContentDocument, it must be
    // allowpaymentrequest. We handle the false case while a document is appended
    // in SetSubDocumentFor
    if (aIsTopLevelContentDocument) {

  bool IsContentDocument() const { return mIsContentDocument; }
  void SetIsContentDocument(bool aIsContentDocument)
    mIsContentDocument = aIsContentDocument;

   * Create an element with the specified name, prefix and namespace ID.
   * Returns null if element name parsing failed.
  already_AddRefed<Element> CreateElem(const nsAString& aName,
                                       nsAtom* aPrefix,
                                       int32_t aNamespaceID,
                                       const nsAString* aIs = nullptr);

   * 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;

   * Get the channel that failed to load and resulted in an error page, if it
   * exists. This is only relevant to error pages.
  nsIChannel* GetFailedChannel() const
    return mFailedChannel;

   * Set the channel that failed to load and resulted in an error page.
   * This is only relevant to error pages.
  void SetFailedChannel(nsIChannel* aChannel)
    mFailedChannel = aChannel;

   * 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()
    return mPropertyTable;

   * 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.
  void Sanitize();

   * 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);
  void EnumerateSubDocuments(nsSubDocEnumFunc aCallback, void *aData);

   * Collect all the descendant documents for which |aCalback| returns true.
   * The callback function must not mutate any state for the given document.
  typedef bool (*nsDocTestFunc)(const nsIDocument* aDocument);
  void CollectDescendantDocuments(
    nsTArray<nsCOMPtr<nsIDocument>>& aDescendants,
    nsDocTestFunc aCallback) const;

   * 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);

   * 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.
  already_AddRefed<nsILayoutHistoryState> GetLayoutHistoryState() const;

   * 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()

  void UnblockDOMContentLoaded();

   * 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
   * PageTransitionEvent.webidl 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);

   * 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 PageTransitionEvent.webidl 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.
  void OnPageHide(bool aPersisted,
                  mozilla::dom::EventTarget* aDispatchStartTarget);

   * 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.
  void AddStyleRelevantLink(mozilla::dom::Link* aLink)
    NS_ASSERTION(aLink, "Passing in a null link.  Expect crashes RSN!");
#ifdef DEBUG
    nsPtrHashKey<mozilla::dom::Link>* entry = mStyledLinks.GetEntry(aLink);
    NS_ASSERTION(!entry, "Document already knows about this Link!");
    mStyledLinksCleared = false;

   * 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.
  void ForgetLink(mozilla::dom::Link* aLink)
    NS_ASSERTION(aLink, "Passing in a null link.  Expect crashes RSN!");
#ifdef DEBUG
    nsPtrHashKey<mozilla::dom::Link>* entry = mStyledLinks.GetEntry(aLink);
    NS_ASSERTION(entry || mStyledLinksCleared,
                 "Document knows nothing about this Link!");

  // Refreshes the hrefs of all the links in the document.
  void RefreshLinkHrefs();

   * Resets and removes a box object from the document's box object cache
   * @param aElement canonical nsIContent pointer of the box object's element
  void ClearBoxObjectFor(nsIContent* aContent);

   * Get the box object for an element. This is not exposed through a
   * scriptable interface except for XUL documents.
    GetBoxObjectFor(mozilla::dom::Element* aElement, mozilla::ErrorResult& aRv);

   * Support for window.matchMedia()

    MatchMedia(const nsAString& aMediaQueryList,
               mozilla::dom::CallerType aCallerType);

  mozilla::LinkedList<mozilla::dom::MediaQueryList>& MediaQueryLists() {
    return mDOMMediaQueryLists;

   * 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;

  Element* GetAnonymousElementByAttribute(nsIContent* aElement,
                                          nsAtom* aAttrName,
                                          const nsAString& aAttrValue) const;

  nsresult NodesFromRectHelper(float aX, float aY,
                               float aTopSize, float aRightSize,
                               float aBottomSize, float aLeftSize,
                               bool aIgnoreRootScrollFrame,
                               bool aFlushLayout,
                               nsINodeList** aReturn);

   * See FlushSkinBindings on nsBindingManager
  void FlushSkinBindings();

   * 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) {

   * 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;

   * Returns whether this document is cookie averse. See
  bool IsCookieAverse() const
    // If we are a document that "has no browsing context."
    if (!GetInnerWindow()) {
      return true;

    // If we are a document "whose URL's scheme is not a network scheme."
    // NB: Explicitly allow file: URIs to store cookies.
    nsCOMPtr<nsIURI> codebaseURI;

    if (!codebaseURI) {
      return true;

    nsAutoCString scheme;
    return !scheme.EqualsLiteral("http") &&
           !scheme.EqualsLiteral("https") &&
           !scheme.EqualsLiteral("ftp") &&

  bool IsLoadedAsData()
    return mLoadedAsData;

  bool IsLoadedAsInteractiveData()
    return mLoadedAsInteractiveData;

  bool MayStartLayout()
    return mMayStartLayout;

  virtual void SetMayStartLayout(bool aMayStartLayout);

  already_AddRefed<nsIDocumentEncoder> GetCachedEncoder();

  void SetCachedEncoder(already_AddRefed<nsIDocumentEncoder> aEncoder);

  // In case of failure, the document really can't initialize the frame loader.
  nsresult InitializeFrameLoader(nsFrameLoader* aLoader);
  // In case of failure, the caller must handle the error, for example by
  // finalizing frame loader asynchronously.
  nsresult FinalizeFrameLoader(nsFrameLoader* aLoader, nsIRunnable* aFinalizer);
  // Removes the frame loader of aShell from the initialization list.
  void TryCancelFrameLoaderInitialization(nsIDocShell* aShell);

   * 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 IsSVGGlyphsDocument() const
    return mIsSVGGlyphsDocument;

  void SetIsSVGGlyphsDocument()
    mIsSVGGlyphsDocument = true;

  bool IsResourceDoc() const {
    return IsBeingUsedAsImage() || // Are we a helper-doc for an SVG image?
      mHasDisplayDocument;         // 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)
    MOZ_ASSERT(!GetShell() &&
               !GetContainer() &&
               "Shouldn't set mDisplayDocument on documents that already "
               "have a presentation or a docshell or a window");
    MOZ_ASSERT(aDisplayDocument, "Must not be null");
    MOZ_ASSERT(aDisplayDocument != this, "Should be different document");
               "Display documents should not nest");
    mDisplayDocument = aDisplayDocument;
    mHasDisplayDocument = !!aDisplayDocument;

   * 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
  nsIDocument* RequestExternalResource(nsIURI* aURI,
                                       nsINode* aRequestingNode,
                                       ExternalResourceLoad** aPendingLoad);

   * 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.
  void EnumerateExternalResources(nsSubDocEnumFunc aCallback, void* aData);

  nsExternalResourceMap& ExternalResourceMap()
    return mExternalResourceMap;

   * 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., an 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 - see IsCurrentActiveDocument.
  bool IsActive() const { return mDocumentContainer && !mRemovedFromDocShell; }

   * Return true if this is the current active document for its
   * docshell. Note that a docshell may have multiple active documents
   * due to the bfcache -- this should be used when you need to
   * differentiate the *current* active document from any active
   * documents.
  bool IsCurrentActiveDocument() const
    nsPIDOMWindowInner* inner = GetInnerWindow();
    return inner && inner->IsCurrentInnerWindow() && inner->GetDoc() == this;

   * Returns whether this document should perform image loads.
  bool ShouldLoadImages() const
    // We check IsBeingUsedAsImage() so that SVG documents loaded as
    // images can themselves have data: URL image references.
    return IsCurrentActiveDocument() || IsBeingUsedAsImage();

   * Register/Unregister the ActivityObserver into mActivityObservers to listen
   * the document's activity changes such as OnPageHide, visibility, activity.
   * The ActivityObserver objects can be nsIObjectLoadingContent or
   * nsIDocumentActivity or HTMLMEdiaElement.
  void RegisterActivityObserver(nsISupports* aSupports);
  bool UnregisterActivityObserver(nsISupports* aSupports);
  // Enumerate all the observers in mActivityObservers by the aEnumerator.
  typedef void (* ActivityObserverEnumerator)(nsISupports*, void*);
  void EnumerateActivityObservers(ActivityObserverEnumerator 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.
  // If HasAnimationController is true, this is guaranteed to return non-null.
  nsSMILAnimationController* GetAnimationController();

  // Gets the tracker for animations that are waiting to start.
  // Returns nullptr if there is no pending animation tracker for this document
  // which will be the case if there have never been any CSS animations or
  // transitions on elements in the document.
  mozilla::PendingAnimationTracker* GetPendingAnimationTracker()
    return mPendingAnimationTracker;

  // Gets the tracker for animations that are waiting to start and
  // creates it if it doesn't already exist. As a result, the return value
  // will never be nullptr.
  mozilla::PendingAnimationTracker* GetOrCreatePendingAnimationTracker();

   * Prevents user initiated events from being dispatched to the document and
   * subdocuments.
  void SuppressEventHandling(uint32_t aIncrease = 1);

   * Unsuppress event handling.
   * @param aFireEvents If true, delayed events (focus/blur) will be fired
   *                    asynchronously.
  void UnsuppressEventHandlingAndFireEvents(bool aFireEvents);

  uint32_t EventHandlingSuppressed() const { return mEventsSuppressed; }

  bool IsEventHandlingEnabled() {
    return !EventHandlingSuppressed() && mScriptGlobalObject;

  void DecreaseEventSuppression()

   * Increment
  void IncrementIgnoreDestructiveWritesCounter() { ++mIgnoreDestructiveWritesCounter; }

   * Decrement
  void DecrementIgnoreDestructiveWritesCounter() { --mIgnoreDestructiveWritesCounter; }

  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 :

  void ForceEnableXULXBL() {
    mAllowXULXBL = eTriTrue;

   * Returns the template content owner document that owns the content of
   * HTMLTemplateElement.
  nsIDocument* GetTemplateContentsOwner();

   * Returns true if this document is a static clone of a normal document.
   * We create static clones for print preview and printing (possibly other
   * things in future).
   * Note that static documents are also "loaded as data" (if this method
   * returns true, IsLoadedAsData() will also return true).
  bool IsStaticDocument() { return mIsStaticDocument; }

   * Clones the document along with any subdocuments, stylesheet, etc.
   * The resulting document and everything it contains (including any
   * sub-documents) are created purely via cloning.  The returned documents and
   * any sub-documents are "loaded as data" documents to preserve the state as
   * it was during the clone process (we don't want external resources to load
   * and replace the cloned resources).
   * @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;

   * If this document is a static clone, let the original document know that
   * we're going away and then release our reference to it.
  void UnlinkOriginalDocumentIfStatic();

   * These are called by the parser as it encounters <picture> tags, the end of
   * said tags, and possible picture <source srcset> sources respectively. These
   * are used to inform ResolvePreLoadImage() calls.  Unset attributes are
   * expected to be marked void.
   * NOTE that the parser does not attempt to track the current picture nesting
   * level or whether the given <source> tag is within a picture -- it is only
   * guaranteed to order these calls properly with respect to
   * ResolvePreLoadImage.

  void PreloadPictureOpened()

  void PreloadPictureClosed();

  void PreloadPictureImageSource(const nsAString& aSrcsetAttr,
                                 const nsAString& aSizesAttr,
                                 const nsAString& aTypeAttr,
                                 const nsAString& aMediaAttr);

   * Called by the parser to resolve an image for preloading. The parser will
   * call the PreloadPicture* functions to inform us of possible <picture>
   * nesting and possible sources, which are used to inform URL selection
   * responsive <picture> or <img srcset> images.  Unset attributes are expected
   * to be marked void.
   * If this image is for <picture> or <img srcset>, aIsImgSet will be set to
   * true, false otherwise.
  ResolvePreloadImage(nsIURI *aBaseURI,
                      const nsAString& aSrcAttr,
                      const nsAString& aSrcsetAttr,
                      const nsAString& aSizesAttr,
                      bool *aIsImgSet);
   * 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.
   * aIsImgSet is the value got from calling ResolvePreloadImage, it is true
   * when this image is for loading <picture> or <img srcset> images.
  void MaybePreLoadImage(nsIURI* uri,
                         const nsAString& aCrossOriginAttr,
                         ReferrerPolicyEnum aReferrerPolicy,
                         bool aIsImgSet);

   * Called by images to forget an image preload when they start doing
   * the real load.
  void ForgetImagePreload(nsIURI* aURI);

   * 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.
  void PreloadStyle(nsIURI* aURI,
                    const mozilla::Encoding* aEncoding,
                    const nsAString& aCrossOriginAttr,
                    ReferrerPolicyEnum aReferrerPolicy,
                    const nsAString& aIntegrity);

   * 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.
  nsresult LoadChromeSheetSync(nsIURI* aURI, bool aIsAgentSheet,
                               RefPtr<mozilla::StyleSheet>* aSheet);

   * 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; }

   * Called by Parser for link rel=preconnect
  void MaybePreconnect(nsIURI* uri, mozilla::CORSMode aCORSMode);

  enum DocumentTheme {
    Doc_Theme_Uninitialized, // not determined yet

   * 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 DocumentTheme GetDocumentLWTheme() { return Doc_Theme_None; }
  virtual DocumentTheme ThreadSafeGetDocumentLWTheme() const { return Doc_Theme_None; }

   * Returns the document state.
   * Document state bits have the form NS_DOCUMENT_STATE_* and are declared in
   * nsIDocument.h.
  mozilla::EventStates GetDocumentState() const
    return mDocumentState;

  nsISupports* GetCurrentContentSink();

  void SetAutoFocusElement(Element* aAutoFocusElement);
  void TriggerAutoFocus();

  void SetScrollToRef(nsIURI* aDocumentURI);
  void ScrollToRef();
  void ResetScrolledToRefAlready()
    mScrolledToRefAlready = false;

  void SetChangeScrollPosWhenScrollingToRef(bool aValue)
    mChangeScrollPosWhenScrollingToRef = aValue;

  using mozilla::dom::DocumentOrShadowRoot::GetElementById;
  using mozilla::dom::DocumentOrShadowRoot::GetElementsByTagName;
  using mozilla::dom::DocumentOrShadowRoot::GetElementsByTagNameNS;
  using mozilla::dom::DocumentOrShadowRoot::GetElementsByClassName;

   * 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|
  Element* LookupImageElement(const nsAString& aElementId);

  mozilla::dom::DocumentTimeline* Timeline();
  mozilla::LinkedList<mozilla::dom::DocumentTimeline>& Timelines()
    return mTimelines;

  void GetAnimations(nsTArray<RefPtr<mozilla::dom::Animation>>& aAnimations);

  mozilla::dom::SVGSVGElement* GetSVGRootElement() const;

  nsresult ScheduleFrameRequestCallback(mozilla::dom::FrameRequestCallback& aCallback,
                                        int32_t *aHandle);
  void CancelFrameRequestCallback(int32_t aHandle);

  typedef nsTArray<RefPtr<mozilla::dom::FrameRequestCallback>> FrameRequestCallbackList;
   * Put this document's frame request callbacks into the provided
   * list, and forget about them.
  void TakeFrameRequestCallbacks(FrameRequestCallbackList& aCallbacks);

   * @return true if this document's frame request callbacks should be
   * throttled. We throttle requestAnimationFrame for documents which aren't
   * visible (e.g. scrolled out of the viewport).
  bool ShouldThrottleFrameRequests();

  // This returns true when the document tree is being teared down.
  bool InUnlinkOrDeletion() { return mInUnlinkOrDeletion; }

  mozilla::dom::ImageTracker* ImageTracker();

  // AddPlugin adds a plugin-related element to mPlugins when the element is
  // added to the tree.
  void AddPlugin(nsIObjectLoadingContent* aPlugin)

  // RemovePlugin removes a plugin-related element to mPlugins when the
  // element is removed from the tree.
  void RemovePlugin(nsIObjectLoadingContent* aPlugin)

  // GetPlugins returns the plugin-related elements from
  // the frame and any subframes.
  void GetPlugins(nsTArray<nsIObjectLoadingContent*>& aPlugins);

  // Adds an element to mResponsiveContent when the element is
  // added to the tree.
  void AddResponsiveContent(mozilla::dom::HTMLImageElement* aContent)

  // Removes an element from mResponsiveContent when the element is
  // removed from the tree.
  void RemoveResponsiveContent(mozilla::dom::HTMLImageElement* aContent)

  void AddComposedDocShadowRoot(mozilla::dom::ShadowRoot& aShadowRoot)

  using ShadowRootSet = nsTHashtable<nsPtrHashKey<mozilla::dom::ShadowRoot>>;

  void RemoveComposedDocShadowRoot(mozilla::dom::ShadowRoot& aShadowRoot)

  // If you're considering using this, you probably want to use
  // ShadowRoot::IsComposedDocParticipant instead. This is just for
  // sanity-checking.
  bool IsComposedDocShadowRoot(mozilla::dom::ShadowRoot& aShadowRoot)
    return mComposedShadowRoots.Contains(&aShadowRoot);

  const ShadowRootSet& ComposedShadowRoots() const
    return mComposedShadowRoots;

  // Notifies any responsive content added by AddResponsiveContent upon media
  // features values changing.
  void NotifyMediaFeatureValuesChanged();

  nsresult GetStateObject(nsIVariant** aResult);

  nsDOMNavigationTiming* GetNavigationTiming() const
    return mTiming;

  void SetNavigationTiming(nsDOMNavigationTiming* aTiming);

  Element* FindImageMap(const nsAString& aNormalizedMapName);

  // Add aLink to the set of links that need their status resolved.
  void RegisterPendingLinkUpdate(mozilla::dom::Link* aLink);

  // Update state on links in mLinksToUpdate.  This function must be called
  // prior to selector matching that needs to differentiate between :link and
  // :visited.  In particular, it does _not_ need to be called before doing any
  // selector matching that uses TreeMatchContext::eNeverMatchVisited.  The only
  // reason we haven't moved all calls to this function entirely inside the
  // TreeMatchContext constructor is to not call it all the time during various
  // style system and frame construction operations (though it would likely be a
  // no-op for all but the first call).
  // XXXbz Does this really need to be called before selector matching?  All it
  // will do is ensure all the links involved are registered to observe history,
  // which won't synchronously change their state to :visited anyway!  So
  // calling this won't affect selector matching done immediately afterward, as
  // far as I can tell.
  void FlushPendingLinkUpdates();

  void FlushPendingLinkUpdatesFromRunnable();

#define DEPRECATED_OPERATION(_op) e##_op,
  enum DeprecatedOperations {
#include "nsDeprecatedOperationList.h"
  bool HasWarnedAbout(DeprecatedOperations aOperation) const;
  void WarnOnceAbout(DeprecatedOperations aOperation,
                     bool asError = false) const;

#define DOCUMENT_WARNING(_op) e##_op,
  enum DocumentWarnings {
#include "nsDocumentWarningList.h"
  bool HasWarnedAbout(DocumentWarnings aWarning) const;
  void WarnOnceAbout(DocumentWarnings aWarning,
                     bool asError = false,
                     const char16_t **aParams = nullptr,
                     uint32_t aParamsLength = 0) const;

  // Posts an event to call UpdateVisibilityState
  void PostVisibilityUpdateEvent();

  bool IsSyntheticDocument() const { return mIsSyntheticDocument; }

  // 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 MayHaveAnimationObservers()
    return mMayHaveAnimationObservers;

  void SetMayHaveAnimationObservers()
    mMayHaveAnimationObservers = true;

  bool IsInSyncOperation()
    return mInSyncOperationCount != 0;

  void SetIsInSyncOperation(bool aSync)
    if (aSync) {
    } else {

  bool CreatingStaticClone() const
    return mCreatingStaticClone;

   * Creates a new element in the HTML namespace with a local name given by
   * aTag.
  already_AddRefed<Element> CreateHTMLElement(nsAtom* aTag);

  // WebIDL API
  nsIGlobalObject* GetParentObject() const
    return GetScopeObject();
  static already_AddRefed<nsIDocument>
    Constructor(const GlobalObject& aGlobal,
                mozilla::ErrorResult& rv);
  mozilla::dom::DOMImplementation* GetImplementation(mozilla::ErrorResult& rv);
  MOZ_MUST_USE nsresult GetURL(nsString& retval) const;
  MOZ_MUST_USE nsresult 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,
                            mozilla::dom::CallerType aCallerType,
                            mozilla::ErrorResult& aRv) 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 {

  nsIDocument* GetTopLevelContentDocument();

  // Returns the associated XUL window if this is a top-level chrome document,
  // null otherwise.
  already_AddRefed<nsIXULWindow> GetXULWindowIfToplevelChrome() const;

  CreateElement(const nsAString& aTagName,
                const mozilla::dom::ElementCreationOptionsOrString& aOptions,
                mozilla::ErrorResult& rv);
  CreateElementNS(const nsAString& aNamespaceURI,
                  const nsAString& aQualifiedName,
                  const mozilla::dom::ElementCreationOptionsOrString& aOptions,
                  mozilla::ErrorResult& rv);
    CreateDocumentFragment() const;
  already_AddRefed<nsTextNode> CreateTextNode(const nsAString& aData) const;
  already_AddRefed<nsTextNode> CreateEmptyTextNode() const;
    CreateComment(const nsAString& aData) const;
    CreateProcessingInstruction(const nsAString& target, const nsAString& data,
                                mozilla::ErrorResult& rv) const;
    ImportNode(nsINode& aNode, bool aDeep, mozilla::ErrorResult& rv) const;
  nsINode* AdoptNode(nsINode& aNode, mozilla::ErrorResult& rv);
    CreateEvent(const nsAString& aEventType,
                mozilla::dom::CallerType aCallerType,
                mozilla::ErrorResult& rv) const;
  already_AddRefed<nsRange> CreateRange(mozilla::ErrorResult& rv);
    CreateNodeIterator(nsINode& aRoot, uint32_t aWhatToShow,
                       mozilla::dom::NodeFilter* aFilter,
                       mozilla::ErrorResult& rv) const;
    CreateTreeWalker(nsINode& aRoot, uint32_t aWhatToShow,
                     mozilla::dom::NodeFilter* aFilter, mozilla::ErrorResult& rv) const;
  // Deprecated WebIDL bits
    CreateCDATASection(const nsAString& aData, mozilla::ErrorResult& rv);
    CreateAttribute(const nsAString& aName, mozilla::ErrorResult& rv);
    CreateAttributeNS(const nsAString& aNamespaceURI,
                      const nsAString& aQualifiedName,
                      mozilla::ErrorResult& rv);
  void GetInputEncoding(nsAString& aInputEncoding) const;
  already_AddRefed<mozilla::dom::Location> GetLocation() const;
  void GetReferrer(nsAString& aReferrer) const;
  void GetLastModified(nsAString& aLastModified) const;
  void GetReadyState(nsAString& aReadyState) const;

  void GetTitle(nsAString& aTitle);
  void SetTitle(const nsAString& aTitle, mozilla::ErrorResult& rv);
  void GetDir(nsAString& aDirection) const;
  void SetDir(const nsAString& aDirection);
  nsIHTMLCollection* Images();
  nsIHTMLCollection* Embeds();
  nsIHTMLCollection* Plugins()
    return Embeds();
  nsIHTMLCollection* Links();
  nsIHTMLCollection* Forms();
  nsIHTMLCollection* Scripts();
  already_AddRefed<nsContentList> GetElementsByName(const nsAString& aName)
    return GetFuncStringContentList<nsCachableElementsByNameNodeList>(this,
  nsPIDOMWindowOuter* GetDefaultView() const
    return GetWindow();
  Element* GetActiveElement();
  bool HasFocus(mozilla::ErrorResult& rv) const;
  nsIHTMLCollection* Applets();
  nsIHTMLCollection* Anchors();
  mozilla::TimeStamp LastFocusTime() const;
  void SetLastFocusTime(const mozilla::TimeStamp& aFocusTime);
  // Event handlers are all on nsINode already
  bool MozSyntheticDocument() const
    return IsSyntheticDocument();
  Element* GetCurrentScript();
  void ReleaseCapture() const;
  void MozSetImageElement(const nsAString& aImageElementId, Element* aElement);
  nsIURI* GetDocumentURIObject() const;
  // Not const because all the full-screen goop is not const
  bool FullscreenEnabled(mozilla::dom::CallerType aCallerType);
  Element* FullScreenStackTop();
  bool Fullscreen()
    return !!GetFullscreenElement();
  void ExitFullscreen();
  void ExitPointerLock()

  static bool IsUnprefixedFullscreenEnabled(JSContext* aCx, JSObject* aObject);

  bool Hidden() const
    return mVisibilityState != mozilla::dom::VisibilityState::Visible;
  mozilla::dom::VisibilityState VisibilityState() const
    return mVisibilityState;
  void GetSelectedStyleSheetSet(nsAString& aSheetSet);
  void SetSelectedStyleSheetSet(const nsAString& aSheetSet);
  void GetLastStyleSheetSet(nsAString& aSheetSet)
    aSheetSet = mLastStyleSheetSet;
  const nsString& GetCurrentStyleSheetSet() const
    return mLastStyleSheetSet.IsEmpty()
      ? mPreferredStyleSheetSet
      : mLastStyleSheetSet;
  void SetPreferredStyleSheetSet(const nsAString&);
  void GetPreferredStyleSheetSet(nsAString& aSheetSet)
    aSheetSet = mPreferredStyleSheetSet;
  mozilla::dom::DOMStringList* StyleSheetSets();
  void EnableStyleSheetsForSet(const nsAString& aSheetSet);

   * 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.
    CaretPositionFromPoint(float aX, float aY);

  Element* GetScrollingElement();
  // A way to check whether a given element is what would get returned from
  // GetScrollingElement.  It can be faster than comparing to the return value
  // of GetScrollingElement() due to being able to avoid flushes in various
  // cases.  This method assumes that null is NOT passed.
  bool IsScrollingElement(Element* aElement);

  // 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,
                           nsIPrincipal& aSubjectPrincipal,
                           mozilla::ErrorResult& rv);
    CreateExpression(const nsAString& aExpression,
                     mozilla::dom::XPathNSResolver* aResolver,
                     mozilla::ErrorResult& rv);
  nsINode* CreateNSResolver(nsINode& aNodeResolver);
    Evaluate(JSContext* aCx, const nsAString& aExpression, nsINode& aContextNode,
             mozilla::dom::XPathNSResolver* aResolver, uint16_t aType,
             JS::Handle<JSObject*> aResult, mozilla::ErrorResult& rv);
  // Touch event handlers already on nsINode
    CreateTouch(nsGlobalWindowInner* 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();
    CreateTouchList(mozilla::dom::Touch& aTouch,
                    const mozilla::dom::Sequence<mozilla::OwningNonNull<mozilla::dom::Touch> >& aTouches);
    CreateTouchList(const mozilla::dom::Sequence<mozilla::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);

  already_AddRefed<mozilla::dom::Promise> BlockParsing(mozilla::dom::Promise& aPromise,
                                                       const mozilla::dom::BlockParsingOptions& aOptions,
                                                       mozilla::ErrorResult& aRv);

  already_AddRefed<nsIURI> GetMozDocumentURIIfNotForErrorPages();

  mozilla::dom::Promise* GetDocumentReadyForIdle(mozilla::ErrorResult& aRv);

  // ParentNode
  nsIHTMLCollection* Children();
  uint32_t ChildElementCount();

   * Asserts IsHTMLOrXHTML, and can't return null.
   * Defined inline in nsHTMLDocument.h
  inline nsHTMLDocument* AsHTMLDocument();

   * Asserts IsSVGDocument, and can't return null.
   * Defined inline in SVGDocument.h
  inline mozilla::dom::SVGDocument* AsSVGDocument();

   * Asserts IsXULDocument, and can't return null.
   * Defined inline in XULDocument.h
  inline mozilla::dom::XULDocument* AsXULDocument();

   * Given a node, get a weak reference to it and append that reference to
   * mBlockedTrackingNodes. Can be used later on to look up a node in it.
   * (e.g., by the UI)
  void AddBlockedTrackingNode(nsINode *node)
    if (!node) {

    nsWeakPtr weakNode = do_GetWeakReference(node);

    if (weakNode) {

  gfxUserFontSet* GetUserFontSet(bool aFlushUserFontSet = true);
  void FlushUserFontSet();
  void MarkUserFontSetDirty();
  mozilla::dom::FontFaceSet* GetFonts() { return mFontFaceSet; }

  // FontFaceSource
  mozilla::dom::FontFaceSet* Fonts();

  bool DidFireDOMContentLoaded() const { return mDidFireDOMContentLoaded; }

  bool IsSynthesized();

  enum class UseCounterReportKind {
    // Flush the document's use counters only; the use counters for any
    // external resource documents will be flushed when the external
    // resource documents themselves are destroyed.

    // Flush use counters for the document and for its external resource
    // documents. (Should only be necessary for tests, where we need
    // flushing to happen synchronously and deterministically.)

  void ReportUseCounters(UseCounterReportKind aKind = UseCounterReportKind::eDefault);

  void SetDocumentUseCounter(mozilla::UseCounter aUseCounter)
    if (!mUseCounters[aUseCounter]) {
      mUseCounters[aUseCounter] = true;

  void SetPageUseCounter(mozilla::UseCounter aUseCounter);

  void SetDocumentAndPageUseCounter(mozilla::UseCounter aUseCounter)

  void PropagateUseCounters(nsIDocument* aParentDocument);

  void SetUserHasInteracted(bool aUserHasInteracted);
  bool UserHasInteracted()
    return mUserHasInteracted;

  // This would be called when document get activated by specific user gestures
  // and propagate the user activation flag to its parent.
  void NotifyUserActivation();

  // Return true if document has interacted by specific user gestures.
  bool HasBeenUserActivated();

  bool HasScriptsBlockedBySandbox();

  bool InlineScriptAllowedByCSP();

  void ReportHasScrollLinkedEffect();
  bool HasScrollLinkedEffect() const
    return mHasScrollLinkedEffect;

  mozilla::dom::DocGroup* GetDocGroup() const;

  void AddIntersectionObserver(mozilla::dom::DOMIntersectionObserver* aObserver)
               "Intersection observer already in the list");

  void RemoveIntersectionObserver(mozilla::dom::DOMIntersectionObserver* aObserver)

  bool HasIntersectionObservers() const
    return !mIntersectionObservers.IsEmpty();

  void UpdateIntersectionObservations();
  void ScheduleIntersectionObserverNotification();
  void NotifyIntersectionObservers();

  // Dispatch a runnable related to the document.
  nsresult Dispatch(mozilla::TaskCategory aCategory,
                    already_AddRefed<nsIRunnable>&& aRunnable) final;

  virtual nsISerialEventTarget*
  EventTargetFor(mozilla::TaskCategory aCategory) const override;

  virtual mozilla::AbstractThread*
  AbstractMainThreadFor(mozilla::TaskCategory aCategory) override;

  // The URLs passed to these functions should match what
  // JS::DescribeScriptedCaller() returns, since these APIs are used to
  // determine whether some code is being called from a tracking script.
  void NoteScriptTrackingStatus(const nsACString& aURL, bool isTracking);
  bool IsScriptTracking(const nsACString& aURL) const;

  // For more information on Flash classification, see
  // toolkit/components/url-classifier/flash-block-lists.rst
  mozilla::dom::FlashClassification DocumentFlashClassification();
  bool IsThirdParty();

  bool IsScopedStyleEnabled();

  nsINode* GetServoRestyleRoot() const
    return mServoRestyleRoot;

  uint32_t GetServoRestyleRootDirtyBits() const
    return mServoRestyleRootDirtyBits;

  void ClearServoRestyleRoot()
    mServoRestyleRoot = nullptr;
    mServoRestyleRootDirtyBits = 0;

  inline void SetServoRestyleRoot(nsINode* aRoot, uint32_t aDirtyBits);
  inline void SetServoRestyleRootDirtyBits(uint32_t aDirtyBits);

  bool ShouldThrowOnDynamicMarkupInsertion()
    return mThrowOnDynamicMarkupInsertionCounter;

  void IncrementThrowOnDynamicMarkupInsertionCounter()

  void DecrementThrowOnDynamicMarkupInsertionCounter()

  bool ShouldIgnoreOpens() const
    return mIgnoreOpensDuringUnloadCounter;

  void IncrementIgnoreOpensDuringUnloadCounter()

  void DecrementIgnoreOpensDuringUnloadCounter()

  bool AllowPaymentRequest() const
    return mAllowPaymentRequest;

  void SetAllowPaymentRequest(bool aAllowPaymentRequest)
    mAllowPaymentRequest = aAllowPaymentRequest;

  bool IsShadowDOMEnabled() const
    return mIsShadowDOMEnabled;

  bool ModuleScriptsEnabled();

   * Find the (non-anonymous) content in this document for aFrame. It will
   * be aFrame's content node if that content is in this document and not
   * anonymous. Otherwise, when aFrame is in a subdocument, we use the frame
   * element containing the subdocument containing aFrame, and/or find the
   * nearest non-anonymous ancestor in this document.
   * Returns null if there is no such element.
  nsIContent* GetContentInThisDocument(nsIFrame* aFrame) const;

  void ReportShadowDOMUsage();

  already_AddRefed<nsIPrincipal> MaybeDowngradePrincipal(nsIPrincipal* aPrincipal);

  void EnsureOnloadBlocker();

  void SendToConsole(nsCOMArray<nsISecurityConsoleMessage>& aMessages);

  // Returns true if the scheme for the url for this document is "about".
  bool IsAboutPage() const;

  bool ContainsEMEContent();
  bool ContainsMSEContent();

  void MaybeInitializeFinalizeFrameLoaders();

   * Returns the title element of the document as defined by the HTML
   * specification, or null if there isn't one.  For documents whose root
   * element is an <svg:svg>, this is the first <svg:title> element that's a
   * child of the root.  For other documents, it's the first HTML title element
   * in the document.
  Element* GetTitleElement();

  // Retrieves the classification of the Flash plugins in the document based on
  // the classification lists.
  mozilla::dom::FlashClassification PrincipalFlashClassification();

  // Attempts to determine the Flash classification of this page based on the
  // the classification lists and the classification of parent documents.
  mozilla::dom::FlashClassification ComputeFlashClassification();

  void RecordNavigationTiming(ReadyState aReadyState);

  // This method may fire a DOM event; if it does so it will happen
  // synchronously.
  void UpdateVisibilityState();

  // Recomputes the visibility state but doesn't set the new value.
  mozilla::dom::VisibilityState ComputeVisibilityState() const;

  // Since we wouldn't automatically play media from non-visited page, we need
  // to notify window when the page was first visited.
  void MaybeActiveMediaComponents();

  // Apply the fullscreen state to the document, and trigger related
  // events. It returns false if the fullscreen element ready check
  // fails and nothing gets changed.
  bool ApplyFullscreen(const FullscreenRequest& aRequest);

  bool GetUseCounter(mozilla::UseCounter aUseCounter)
    return mUseCounters[aUseCounter];

  void SetChildDocumentUseCounter(mozilla::UseCounter aUseCounter)
    if (!mChildDocumentUseCounters[aUseCounter]) {
      mChildDocumentUseCounters[aUseCounter] = true;

  bool GetChildDocumentUseCounter(mozilla::UseCounter aUseCounter)
    return mChildDocumentUseCounters[aUseCounter];

  void UpdateDocumentStates(mozilla::EventStates);

  void AddOnDemandBuiltInUASheet(mozilla::StyleSheet* aSheet);
  void RemoveDocStyleSheetsFromStyleSets();
  void RemoveStyleSheetsFromStyleSets(
      const nsTArray<RefPtr<mozilla::StyleSheet>>& aSheets,
      mozilla::SheetType aType);
  void ResetStylesheetsToURI(nsIURI* aURI);
  void FillStyleSet(mozilla::ServoStyleSet* aStyleSet);
  void AddStyleSheetToStyleSets(mozilla::StyleSheet* aSheet);
  void RemoveStyleSheetFromStyleSets(mozilla::StyleSheet* aSheet);
  void NotifyStyleSheetAdded(mozilla::StyleSheet* aSheet, bool aDocumentSheet);
  void NotifyStyleSheetRemoved(mozilla::StyleSheet* aSheet, bool aDocumentSheet);
  void NotifyStyleSheetApplicableStateChanged();
  // Just like EnableStyleSheetsForSet, but doesn't check whether
  // aSheetSet is null and allows the caller to control whether to set
  // aSheetSet as the preferred set in the CSSLoader.
  void EnableStyleSheetsForSetInternal(const nsAString& aSheetSet,
                                       bool aUpdateCSSLoader);

  mutable std::bitset<eDeprecatedOperationCount> mDeprecationWarnedAbout;
  mutable std::bitset<eDocumentWarningCount> mDocWarningWarnedAbout;

  // Lazy-initialization to have mDocGroup initialized in prior to the
  // SelectorCaches.
  mozilla::UniquePtr<SelectorCache> mSelectorCache;

  friend class nsDocumentOnStack;

  void IncreaseStackRefCnt()

  void DecreaseStackRefCnt()
    if (--mStackRefCnt == 0 && mNeedsReleaseAfterStackRefCntRelease) {
      mNeedsReleaseAfterStackRefCntRelease = false;


  // Never ever call this. Only call GetWindow!
  nsPIDOMWindowOuter* GetWindowInternal() const;

  // Never ever call this. Only call GetScriptHandlingObject!
  nsIScriptGlobalObject* GetScriptHandlingObjectInternal() const;

  // Never ever call this. Only call AllowXULXBL!
  bool InternalAllowXULXBL();

   * These methods should be called before and after dispatching
   * a mutation event.
   * To make this easy and painless, use the mozAutoSubtreeModified helper class.
  void WillDispatchMutationEvent(nsINode* aTarget);
  void MutationEventDispatched(nsINode* aTarget);
  friend class mozAutoSubtreeModified;

  virtual Element* GetNameSpaceElement() override
    return GetRootElement();

  void SetContentTypeInternal(const nsACString& aType);

  nsCString GetContentTypeInternal() const
    return mContentType;

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

  // Update our frame request callback scheduling state, if needed.  This will
  // schedule or unschedule them, if necessary, and update
  // mFrameRequestCallbacksScheduled.  aOldShell should only be passed when
  // mPresShell is becoming null; in that case it will be used to get hold of
  // the relevant refresh driver.
  void UpdateFrameRequestCallbackSchedulingState(nsIPresShell* aOldShell = nullptr);

  // Helper for GetScrollingElement/IsScrollingElement.
  bool IsPotentiallyScrollable(mozilla::dom::HTMLBodyElement* aBody);

  // Return the same type parent docuement if exists, or return null.
  nsIDocument* GetSameTypeParentDocument();

  // Return the first parent document with same pricipal, return nullptr if we
  // can't find it.
  nsIDocument* GetFirstParentDocumentWithSamePrincipal(nsIPrincipal* aPrincipal);

  // Activate the flag 'mUserHasActivatedInteraction' by specific user gestures.
  void ActivateByUserGesture();
  void MaybeActivateByUserGesture(nsIPrincipal* aPrincipal);

  // Helpers for GetElementsByName.
  static bool MatchNameAttribute(mozilla::dom::Element* aElement,
                                 int32_t aNamespaceID,
                                 nsAtom* aAtom, void* aData);
  static void* UseExistingNameString(nsINode* aRootNode, const nsString* aName);

  void MaybeResolveReadyForIdle();

  nsCString mReferrer;
  nsString mLastModified;

  nsCOMPtr<nsIURI> mDocumentURI;
  nsCOMPtr<nsIURI> mOriginalURI;
  nsCOMPtr<nsIURI> mChromeXHRDocURI;
  nsCOMPtr<nsIURI> mDocumentBaseURI;
  nsCOMPtr<nsIURI> mChromeXHRDocBaseURI;

  // A lazily-constructed URL data for style system to resolve URL value.
  RefPtr<mozilla::URLExtraData> mCachedURLData;

  nsWeakPtr mDocumentLoadGroup;

  bool mReferrerPolicySet;
  ReferrerPolicyEnum mReferrerPolicy;

  bool mBlockAllMixedContent;
  bool mBlockAllMixedContentPreloads;
  bool mUpgradeInsecureRequests;
  bool mUpgradeInsecurePreloads;

  mozilla::WeakPtr<nsDocShell> mDocumentContainer;

  NotNull<const Encoding*> 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;
  RefPtr<mozilla::css::Loader> mCSSLoader;
  RefPtr<mozilla::css::ImageLoader> mStyleImageLoader;
  RefPtr<nsHTMLStyleSheet> mAttrStyleSheet;
  RefPtr<nsHTMLCSSStyleSheet> mStyleAttrStyleSheet;

  // Tracking for images in the document.
  RefPtr<mozilla::dom::ImageTracker> mImageTracker;

  // A hashtable of ShadowRoots belonging to the composed doc.
  // See ShadowRoot::SetIsComposedDocParticipant.
  ShadowRootSet mComposedShadowRoots;

  // The set of all object, embed, video/audio elements or
  // nsIObjectLoadingContent or nsIDocumentActivity 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<nsISupports> > > mActivityObservers;

  // A hashtable of styled links keyed by address pointer.
  nsTHashtable<nsPtrHashKey<mozilla::dom::Link>> mStyledLinks;
#ifdef DEBUG
  // Indicates whether mStyledLinks was cleared or not.  This is used to track
  // state so we can provide useful assertions to consumers of ForgetLink and
  // AddStyleRelevantLink.
  bool mStyledLinksCleared;

  // The array of all links that need their status resolved.  Links must add themselves
  // to this set by calling RegisterPendingLinkUpdate when added to a document.
  static const size_t kSegmentSize = 128;

  typedef mozilla::SegmentedVector<nsCOMPtr<mozilla::dom::Link>,

  LinksToUpdateList mLinksToUpdate;

  // SMIL Animation Controller, lazily-initialized in GetAnimationController
  RefPtr<nsSMILAnimationController> mAnimationController;

  // Table of element properties for this document.
  nsPropertyTable mPropertyTable;

  // Our cached .children collection
  nsCOMPtr<nsIHTMLCollection> mChildrenCollection;

  // Various DOM lists
  RefPtr<nsContentList> mImages;
  RefPtr<nsContentList> mEmbeds;
  RefPtr<nsContentList> mLinks;
  RefPtr<nsContentList> mForms;
  RefPtr<nsContentList> mScripts;
  nsCOMPtr<nsIHTMLCollection> mApplets;
  RefPtr<nsContentList> mAnchors;

  // container for per-context fonts (downloadable, SVG, etc.)
  RefPtr<mozilla::dom::FontFaceSet> mFontFaceSet;

  // Last time this document or a one of its sub-documents was focused.  If
  // focus has never occurred then mLastFocusTime.IsNull() will be true.
  mozilla::TimeStamp mLastFocusTime;

  mozilla::EventStates mDocumentState;

  RefPtr<mozilla::dom::Promise> mReadyForIdle;

  // True if BIDI is enabled.
  bool mBidiEnabled : 1;
  // True if a MathML element has ever been owned by this document.
  bool mMathMLEnabled : 1;

  // 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 : 1;

  bool mIgnoreDocGroupMismatches : 1;

  // True if we're loaded as data and therefor has any dangerous stuff, such
  // as scripts and plugins, disabled.
  bool mLoadedAsData : 1;

  // 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 : 1;

  // If true, whoever is creating the document has gotten it to the
  // point where it's safe to start layout on it.
  bool mMayStartLayout : 1;

  // True iff we've ever fired a DOMTitleChanged event for this document
  bool mHaveFiredTitleChange : 1;

  // State for IsShowing(). mIsShowing starts off false. It becomes true when
  // OnPageShow happens and becomes false when OnPageHide happens. So it's false
  // before the initial load completes and when we're in bfcache or unloaded,
  // true otherwise.
  bool mIsShowing : 1;

  // State for IsVisible(). mVisible starts off true. It becomes false when
  // OnPageHide happens, and becomes true again when OnPageShow happens.  So
  // it's false only when we're in bfcache or unloaded.
  bool mVisible : 1;

  // 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 : 1;

  // 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 : 1;

  // True when this document is a static clone of a normal document
  bool mIsStaticDocument : 1;

  // True while this document is being cloned to a static document.
  bool mCreatingStaticClone : 1;

  // True iff the document is being unlinked or deleted.
  bool mInUnlinkOrDeletion : 1;

  // True if document has ever had script handling object.
  bool mHasHadScriptHandlingObject : 1;

  // True if we're an SVG document being used as an image.
  bool mIsBeingUsedAsImage : 1;

  // True is this document is synthetic : stand alone image, video, audio
  // file, etc.
  bool mIsSyntheticDocument : 1;

  // True is there is a pending runnable which will call FlushPendingLinkUpdates().
  bool mHasLinksToUpdateRunnable : 1;

  // True if we're flushing pending link updates.
  bool mFlushingPendingLinkUpdates : 1;

  // True if a DOMMutationObserver is perhaps attached to a node in the document.
  bool mMayHaveDOMMutationObservers : 1;

  // True if an nsIAnimationObserver is perhaps attached to a node in the document.
  bool mMayHaveAnimationObservers : 1;

  // True if a document has loaded Mixed Active Script (see nsMixedContentBlocker.cpp)
  bool mHasMixedActiveContentLoaded : 1;

  // True if a document has blocked Mixed Active Script (see nsMixedContentBlocker.cpp)
  bool mHasMixedActiveContentBlocked : 1;

  // True if a document has loaded Mixed Display/Passive Content (see nsMixedContentBlocker.cpp)
  bool mHasMixedDisplayContentLoaded : 1;

  // True if a document has blocked Mixed Display/Passive Content (see nsMixedContentBlocker.cpp)
  bool mHasMixedDisplayContentBlocked : 1;

  // True if a document loads a plugin object that attempts to load mixed content subresources through necko(see nsMixedContentBlocker.cpp)
  bool mHasMixedContentObjectSubrequest : 1;

  // True if a document load has a CSP attached.
  bool mHasCSP : 1;

  // True if a document load has a CSP with unsafe-eval attached.
  bool mHasUnsafeEvalCSP : 1;

  // True if a document load has a CSP with unsafe-inline attached.
  bool mHasUnsafeInlineCSP : 1;

  // True if a document has blocked Tracking Content
  bool mHasTrackingContentBlocked : 1;

  // True if a document has loaded Tracking Content
  bool mHasTrackingContentLoaded : 1;

  // True if DisallowBFCaching has been called on this document.
  bool mBFCacheDisallowed : 1;

  bool mHasHadDefaultView : 1;

  // Whether style sheet change events will be dispatched for this document
  bool mStyleSheetChangeEventsEnabled : 1;

  // Whether the document was created by a srcdoc iframe.
  bool mIsSrcdocDocument : 1;

  // Records whether we've done a If this is true, it's possible
  // for nodes from this document to have outdated wrappers in their wrapper
  // caches.
  bool mDidDocumentOpen : 1;

  // Whether this document has a display document and thus is considered to
  // be a resource document.  Normally this is the same as !!mDisplayDocument,
  // but mDisplayDocument is cleared during Unlink.  mHasDisplayDocument is
  // valid in the document's destructor.
  bool mHasDisplayDocument : 1;

  // Is the current mFontFaceSet valid?
  bool mFontFaceSetDirty : 1;

  // Has GetUserFontSet() been called?
  bool mGetUserFontSetCalled : 1;

  // True if we have fired the DOMContentLoaded event, or don't plan to fire one
  // (e.g. we're not being parsed at all).
  bool mDidFireDOMContentLoaded : 1;

  // True if ReportHasScrollLinkedEffect() has been called.
  bool mHasScrollLinkedEffect : 1;

  // True if we have frame request callbacks scheduled with the refresh driver.
  // This should generally be updated only via
  // UpdateFrameRequestCallbackSchedulingState.
  bool mFrameRequestCallbacksScheduled : 1;

  bool mIsTopLevelContentDocument : 1;

  bool mIsContentDocument : 1;

  // True if we have called BeginLoad and are expecting a paired EndLoad call.
  bool mDidCallBeginLoad : 1;

  // True if the document is allowed to use PaymentRequest.
  bool mAllowPaymentRequest : 1;

  // True if the encoding menu should be disabled.
  bool mEncodingMenuDisabled : 1;

  // True if dom.webcomponents.shadowdom.enabled pref is set when document is
  // created.
  bool mIsShadowDOMEnabled : 1;

  // True if this document is for an SVG-in-OpenType font.
  bool mIsSVGGlyphsDocument : 1;

  // True if the document is being destroyed.
  bool mInDestructor: 1;

  // True if the document has been detached from its content viewer.
  bool mIsGoingAway: 1;

  bool mInXBLUpdate: 1;

  bool mNeedsReleaseAfterStackRefCntRelease: 1;

  // Whether we have filled our pres shell's style set with the document's
  // additional sheets and sheets from the nsStyleSheetService.
  bool mStyleSetFilled: 1;

  // Keeps track of whether we have a pending
  // 'style-sheet-applicable-state-changed' notification.
  bool mSSApplicableStateNotificationPending: 1;

  // True if this document has ever had an HTML or SVG <title> element
  // bound to it
  bool mMayHaveTitleElement: 1;

  bool mDOMLoadingSet: 1;
  bool mDOMInteractiveSet: 1;
  bool mDOMCompleteSet: 1;
  bool mAutoFocusFired: 1;

  bool mScrolledToRefAlready : 1;
  bool mChangeScrollPosWhenScrollingToRef : 1;

  bool mHasWarnedAboutBoxObjects: 1;

  bool mDelayFrameLoaderInitialization: 1;

  bool mSynchronousDOMContentLoaded: 1;

  // Set to true when the document is possibly controlled by the ServiceWorker.
  // Used to prevent multiple requests to ServiceWorkerManager.
  bool mMaybeServiceWorkerControlled: 1;

  // These member variables cache information about the viewport so we don't
  // have to recalculate it each time.
  bool mValidWidth: 1;
  bool mValidHeight: 1;
  bool mAutoSize: 1;
  bool mAllowZoom: 1;
  bool mAllowDoubleTapZoom: 1;
  bool mValidScaleFloat: 1;
  bool mValidMaxScale: 1;
  bool mScaleStrEmpty: 1;
  bool mWidthStrEmpty: 1;

  // Parser aborted. True if the parser of this document was forcibly
  // terminated instead of letting it finish at its own pace.
  bool mParserAborted: 1;

  // Whether we have reported use counters for this document with Telemetry yet.
  // Normally this is only done at document destruction time, but for image
  // documents (SVG documents) that are not guaranteed to be destroyed, we
  // report use counters when the image cache no longer has any imgRequestProxys
  // pointing to them.  We track whether we ever reported use counters so
  // that we only report them once for the document.
  bool mReportedUseCounters: 1;

  bool mHasReportedShadowDOMUsage: 1;

#ifdef DEBUG
  bool mWillReparent: 1;

  uint8_t mPendingFullscreenRequests;

  uint8_t mXMLDeclarationBits;

  // Currently active onload blockers.
  uint32_t mOnloadBlockCount;

  // Onload blockers which haven't been activated yet.
  uint32_t mAsyncOnloadBlockCount;

  // Compatibility mode
  nsCompatibility mCompatMode;

  // Our readyState
  ReadyState mReadyState;

  // Our visibility state
  mozilla::dom::VisibilityState mVisibilityState;
  static_assert(sizeof(mozilla::dom::VisibilityState) == sizeof(uint8_t),
                "Error size of mVisibilityState and mDummy");
  uint8_t mDummy;

  enum Type {
    eUnknown, // should never be used

  Type mType;

  uint8_t mDefaultElementType;

  enum Tri {
    eTriUnset = 0,

  Tri mAllowXULXBL;

  // 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;
  nsCString mContentType;
  // For document.write() we may need a different content type than mContentType.
  nsCString mContentTypeForWriteCalls;

  // The document's security info
  nsCOMPtr<nsISupports> mSecurityInfo;

  // The channel that failed to load and resulted in an error page.
  // This only applies to error pages. Might be null.
  nsCOMPtr<nsIChannel> mFailedChannel;

  // 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;

  // All images in process of being preloaded.  This is a hashtable so
  // we can remove them as the real image loads start; that way we
  // make sure to not keep the image load going when no one cares
  // about it anymore.
  nsRefPtrHashtable<nsURIHashKey, imgIRequest> mPreloadingImages;

  // A list of preconnects initiated by the preloader. This prevents
  // the same uri from being used more than once, and allows the dom
  // builder to not repeat the work of the preloader.
  nsDataHashtable<nsURIHashKey, bool> mPreloadedPreconnects;

  // Current depth of picture elements from parser
  uint32_t mPreloadPictureDepth;

  // Set if we've found a URL for the current picture
  nsString mPreloadPictureFoundSource;

  // 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 mIgnoreDestructiveWritesCounter;

   * The current frame request callback handle
  int32_t mFrameRequestCallbackCounter;

  // Count of live static clones of this document.
  uint32_t mStaticCloneCount;

  // Array of nodes that have been blocked to prevent user tracking.
  // They most likely have had their nsIChannel canceled by the URL
  // classifier. (Safebrowsing)
  // Weak nsINode pointers are used to allow nodes to disappear.
  nsTArray<nsWeakPtr> mBlockedTrackingNodes;

  // Weak reference to mScriptGlobalObject QI:d to nsPIDOMWindow,
  // updated on every set of mScriptGlobalObject.
  nsPIDOMWindowInner* 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;

  uint32_t mInSyncOperationCount;

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

  nsTArray<RefPtr<mozilla::dom::AnonymousContent>> mAnonymousContents;

  uint32_t mBlockDOMContentLoaded;

  // Our live MediaQueryLists
  mozilla::LinkedList<mozilla::dom::MediaQueryList> mDOMMediaQueryLists;

  // Array of observers
  nsTObserverArray<nsIDocumentObserver*> mObservers;

  // Flags for use counters used directly by this document.
  std::bitset<mozilla::eUseCounter_Count> mUseCounters;
  // Flags for use counters used by any child documents of this document.
  std::bitset<mozilla::eUseCounter_Count> mChildDocumentUseCounters;
  // Flags for whether we've notified our top-level "page" of a use counter
  // for this child document.
  std::bitset<mozilla::eUseCounter_Count> mNotifiedPageForUseCounter;

  // Whether the user has interacted with the document or not:
  bool mUserHasInteracted;

  // Whether the user has interacted with the document via some specific user
  // gestures.
  bool mUserHasActivatedInteraction;

  mozilla::TimeStamp mPageUnloadingEventTimeStamp;

  RefPtr<mozilla::dom::DocGroup> mDocGroup;

  // The set of all the tracking script URLs.  URLs are added to this set by
  // calling NoteScriptTrackingStatus().  Currently we assume that a URL not
  // existing in the set means the corresponding script isn't a tracking script.
  nsTHashtable<nsCStringHashKey> mTrackingScripts;

  // List of ancestor principals.  This is set at the point a document
  // is connected to a docshell and not mutated thereafter.
  nsTArray<nsCOMPtr<nsIPrincipal>> mAncestorPrincipals;
  // List of ancestor outerWindowIDs that correspond to the ancestor principals.
  nsTArray<uint64_t> mAncestorOuterWindowIDs;

  // Pointer to our parser if we're currently in the process of being
  // parsed into.
  nsCOMPtr<nsIParser> mParser;

  nsrefcnt mStackRefCnt;

  // Weak reference to our sink for in case we no longer have a parser.  This
  // will allow us to flush out any pending stuff from the sink even if
  // EndLoad() has already happened.
  nsWeakPtr mWeakSink;

  // Our update nesting level
  uint32_t mUpdateNestLevel;

  enum ViewportType : uint8_t {

  ViewportType mViewportType;

  // Enum for how content in this document overflows viewport causing
  // out-of-reach issue. Currently it only takes horizontal overflow
  // into consideration. This enum and the corresponding field is only
  // set and read on a top level content document.
  enum class ViewportOverflowType : uint8_t {
    // Viewport doesn't have out-of-reach overflow content, either
    // because the content doesn't overflow, or the viewport doesn't
    // have "overflow: hidden".

    // All following items indicates that the content overflows the
    // scroll port which causing out-of-reach content.

    // Meta viewport is disabled or the document is in desktop mode.
    // The content does not overflow the minimum-scale size. When there
    // is no minimum scale specified, the default value used by Blink,
    // 0.25, is used for this matter.
    // The content overflows the minimum-scale size.
  ViewportOverflowType mViewportOverflowType;

  PLDHashTable* mSubDocuments;

  nsDocHeaderData* mHeaderData;

  RefPtr<PrincipalFlashClassifier> mPrincipalFlashClassifier;
  mozilla::dom::FlashClassification mFlashClassification;
  // Do not use this value directly. Call the |IsThirdParty()| method, which
  // caches its result here.
  mozilla::Maybe<bool> mIsThirdParty;

  nsRevocableEventPtr<nsRunnableMethod<nsIDocument, void, false>>

  RefPtr<nsDOMNavigationTiming> mTiming;

  // Recorded time of change to 'loading' state.
  mozilla::TimeStamp mLoadingTimeStamp;

  nsWeakPtr mAutoFocusElement;

  nsCString mScrollToRef;

  // Weak reference to the scope object (aka the script global object)
  // that, unlike mScriptGlobalObject, is never unset once set. This
  // is a weak reference to avoid leaks due to circular references.
  nsWeakPtr mScopeObject;

  // Array of intersection observers

  // Stack of full-screen elements. When we request full-screen we push the
  // full-screen element onto this stack, and when we cancel full-screen we
  // pop one off this stack, restoring the previous full-screen state
  nsTArray<nsWeakPtr> mFullScreenStack;

  // The root of the doc tree in which this document is in. This is only
  // non-null when this document is in fullscreen mode.
  nsWeakPtr mFullscreenRoot;

  RefPtr<mozilla::dom::DOMImplementation> mDOMImplementation;

  RefPtr<nsContentList> mImageMaps;

  // A set of responsive images keyed by address pointer.
  nsTHashtable<nsPtrHashKey<mozilla::dom::HTMLImageElement>> mResponsiveContent;

  // Tracking for plugins in the document.
  nsTHashtable<nsPtrHashKey<nsIObjectLoadingContent>> mPlugins;

  // Array of owning references to all children
  nsAttrAndChildArray mChildren;

  RefPtr<mozilla::dom::DocumentTimeline> mDocumentTimeline;
  mozilla::LinkedList<mozilla::dom::DocumentTimeline> mTimelines;

  RefPtr<mozilla::dom::ScriptLoader> mScriptLoader;

  nsRefPtrHashtable<nsPtrHashKey<nsIContent>, mozilla::dom::BoxObject>*

  // Tracker for animations that are waiting to start.
  // nullptr until GetOrCreatePendingAnimationTracker is called.
  RefPtr<mozilla::PendingAnimationTracker> mPendingAnimationTracker;

  // A document "without a browsing context" that owns the content of
  // HTMLTemplateElement.
  nsCOMPtr<nsIDocument> mTemplateContentsOwner;

  nsExternalResourceMap mExternalResourceMap;

  // ScreenOrientation "pending promise" as described by
  RefPtr<mozilla::dom::Promise> mOrientationPendingPromise;

  uint16_t mCurrentOrientationAngle;
  mozilla::dom::OrientationType mCurrentOrientationType;

  nsTArray<RefPtr<nsFrameLoader>> mInitializableFrameLoaders;
  nsTArray<nsCOMPtr<nsIRunnable>> mFrameLoaderFinalizers;
  RefPtr<nsRunnableMethod<nsIDocument>> mFrameLoaderRunner;

  // The layout history state that should be used by nodes in this
  // document.  We only actually store a pointer to it when:
  // 1)  We have no script global object.
  // 2)  We haven't had Destroy() called on us yet.
  nsCOMPtr<nsILayoutHistoryState> mLayoutHistoryState;

  // These member variables cache information about the viewport so we don't
  // have to recalculate it each time.
  mozilla::LayoutDeviceToScreenScale mScaleMinFloat;
  mozilla::LayoutDeviceToScreenScale mScaleMaxFloat;
  mozilla::LayoutDeviceToScreenScale mScaleFloat;
  mozilla::CSSToLayoutDeviceScale mPixelRatio;
  mozilla::CSSSize mViewportSize;

  RefPtr<mozilla::EventListenerManager> mListenerManager;

  nsCOMPtr<nsIRunnable> mMaybeEndOutermostXBLUpdateRunner;
  nsCOMPtr<nsIRequest> mOnloadBlocker;

  nsTArray<RefPtr<mozilla::StyleSheet>> mOnDemandBuiltInUASheets;
  nsTArray<RefPtr<mozilla::StyleSheet>> mAdditionalSheets[AdditionalSheetTypeCount];

  // Member to store out last-selected stylesheet set.
  nsString mLastStyleSheetSet;
  nsString mPreferredStyleSheetSet;

  RefPtr<nsDOMStyleSheetSetList> mStyleSheetSetList;

  // We lazily calculate declaration blocks for SVG elements with mapped
  // attributes in Servo mode. This list contains all elements which need lazy
  // resolution.
  nsTHashtable<nsPtrHashKey<nsSVGElement>> mLazySVGPresElements;

  // Restyle root for servo's style system.
  // We store this as an nsINode, rather than as an Element, so that we can store
  // the Document node as the restyle root if the entire document (along with all
  // document-level native-anonymous content) needs to be restyled.
  // We also track which "descendant" bits (normal/animation-only/lazy-fc) the
  // root corresponds to.
  nsCOMPtr<nsINode> mServoRestyleRoot;
  uint32_t mServoRestyleRootDirtyBits;

  // Used in conjunction with the create-an-element-for-the-token algorithm to
  // prevent custom element constructors from being able to use,
  // document.close(), and document.write() when they are invoked by the parser.
  uint32_t mThrowOnDynamicMarkupInsertionCounter;

  // Count of unload/beforeunload/pagehide operations in progress.
  uint32_t mIgnoreOpensDuringUnloadCounter;


 * 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
   * @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);

    UpdateTarget(nullptr, nullptr);

  void UpdateTarget(nsIDocument* aSubtreeOwner, nsINode* aTarget)
    if (mSubtreeOwner) {

    mTarget = aTarget;
    mSubtreeOwner = aSubtreeOwner;
    if (mSubtreeOwner) {

  nsCOMPtr<nsINode>     mTarget;
  nsCOMPtr<nsIDocument> mSubtreeOwner;

class MOZ_STACK_CLASS nsAutoSyncOperation
  explicit nsAutoSyncOperation(nsIDocument* aDocument);
  nsCOMArray<nsIDocument> mDocuments;
  uint32_t                mMicroTaskLevel;

class MOZ_RAII AutoSetThrowOnDynamicMarkupInsertionCounter final {
    explicit AutoSetThrowOnDynamicMarkupInsertionCounter(
      nsIDocument* aDocument)
      : mDocument(aDocument)

    ~AutoSetThrowOnDynamicMarkupInsertionCounter() {

    nsIDocument* mDocument;

class MOZ_RAII IgnoreOpensDuringUnload final
  explicit IgnoreOpensDuringUnload(nsIDocument* aDoc)
    : mDoc(aDoc)

  nsIDocument* mDoc;

// XXX These belong somewhere else
NS_NewHTMLDocument(nsIDocument** aInstancePtrResult, bool aLoadedAsData = false);

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

NS_NewSVGDocument(nsIDocument** aInstancePtrResult);

NS_NewImageDocument(nsIDocument** aInstancePtrResult);

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.
NS_NewDOMDocument(nsIDocument** aInstancePtrResult,
                  const nsAString& aNamespaceURI,
                  const nsAString& aQualifiedName,
                  mozilla::dom::DocumentType* aDoctype,
                  nsIURI* aDocumentURI,
                  nsIURI* aBaseURI,
                  nsIPrincipal* aPrincipal,
                  bool aLoadedAsData,
                  nsIGlobalObject* aEventObject,
                  DocumentFlavor aFlavor);

// This is used only for xbl documents created from the startup cache.
// Non-cached documents are created in the same manner as xml documents.
NS_NewXBLDocument(nsIDocument** aInstancePtrResult,
                  nsIURI* aDocumentURI,
                  nsIURI* aBaseURI,
                  nsIPrincipal* aPrincipal);

NS_NewPluginDocument(nsIDocument** aInstancePtrResult);

inline nsIDocument*
nsINode::GetOwnerDocument() const
  nsIDocument* ownerDoc = OwnerDoc();

  return ownerDoc != this ? ownerDoc : nullptr;

inline nsINode*
nsINode::OwnerDocAsNode() const
  return OwnerDoc();

// ShouldUseXBLScope is defined here as a template so that we can get the faster
// version of IsInAnonymousSubtree if we're statically known to be an
// nsIContent.  we could try defining ShouldUseXBLScope separately on nsINode
// and nsIContent, but then we couldn't put its nsINode implementation here
// (because this header does not include nsIContent) and we can't put it in
// nsIContent.h, because the definition of nsIContent::IsInAnonymousSubtree is
// in nsIContentInlines.h.  And then we get include hell from people trying to
// call nsINode::GetParentObject but not including nsIContentInlines.h and with
// no really good way to include it.
template<typename T>
inline bool ShouldUseXBLScope(const T* aNode)
  return aNode->IsInAnonymousSubtree() &&

inline mozilla::dom::ParentObject
nsINode::GetParentObject() const
  mozilla::dom::ParentObject p(OwnerDoc());
    // Note that mUseXBLScope is a no-op for chrome, and other places where we
    // don't use XBL scopes.
  p.mUseXBLScope = ShouldUseXBLScope(this);
  return p;

inline nsIDocument*
  return static_cast<nsIDocument*>(this);

inline const nsIDocument*
nsINode::AsDocument() const
  return static_cast<const nsIDocument*>(this);

#endif /* nsIDocument_h___ */