diff options
Diffstat (limited to 'dom/base/nsIDocument.h')
| -rw-r--r-- | dom/base/nsIDocument.h | 3461 |
1 files changed, 3461 insertions, 0 deletions
diff --git a/dom/base/nsIDocument.h b/dom/base/nsIDocument.h new file mode 100644 index 000000000..5b10c9914 --- /dev/null +++ b/dom/base/nsIDocument.h @@ -0,0 +1,3461 @@ +/* -*- 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 http://mozilla.org/MPL/2.0/. */ +#ifndef nsIDocument_h___ +#define nsIDocument_h___ + +#include "mozFlushType.h" // for enum +#include "nsAutoPtr.h" // for member +#include "nsCOMArray.h" // for member +#include "nsCRT.h" // for NS_DECL_AND_IMPL_ZEROING_OPERATOR_NEW +#include "nsCompatibility.h" // for member +#include "nsCOMPtr.h" // for member +#include "nsGkAtoms.h" // for static class members +#include "nsIDocumentObserver.h" // for typedef (nsUpdateType) +#include "nsILoadGroup.h" // for member (in nsCOMPtr) +#include "nsINode.h" // for base class +#include "nsIScriptGlobalObject.h" // for member (in nsCOMPtr) +#include "nsIServiceManager.h" +#include "nsIUUIDGenerator.h" +#include "nsPIDOMWindow.h" // for use in inline functions +#include "nsPropertyTable.h" // for member +#include "nsDataHashtable.h" // for member +#include "nsURIHashKey.h" // for member +#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 "prclist.h" +#include "mozilla/UniquePtr.h" +#include "mozilla/CORSMode.h" +#include "mozilla/LinkedList.h" +#include "mozilla/StyleBackendType.h" +#include "mozilla/StyleSheet.h" +#include "mozilla/TimeStamp.h" +#include <bitset> // for member + +#ifdef MOZILLA_INTERNAL_API +#include "mozilla/dom/DocumentBinding.h" +#else +namespace mozilla { +namespace dom { +class ElementCreationOptionsOrString; +} // namespace dom +} // namespace mozilla +#endif // MOZILLA_INTERNAL_API + +class gfxUserFontSet; +class imgIRequest; +class nsAString; +class nsBindingManager; +class nsIDocShell; +class nsDocShell; +class nsDOMNavigationTiming; +class nsFrameLoader; +class nsHTMLCSSStyleSheet; +class nsHTMLDocument; +class nsHTMLStyleSheet; +class nsIAtom; +class nsIBFCacheEntry; +class nsIChannel; +class nsIContent; +class nsIContentSink; +class nsIDocShell; +class nsIDocShellTreeItem; +class nsIDocumentEncoder; +class nsIDocumentObserver; +class nsIDOMDocument; +class nsIDOMDocumentType; +class nsIDOMElement; +class nsIDOMNodeFilter; +class nsIDOMNodeList; +class nsIHTMLCollection; +class nsILayoutHistoryState; +class nsILoadContext; +class nsIObjectLoadingContent; +class nsIObserver; +class nsIPresShell; +class nsIPrincipal; +class nsIRequest; +class nsIRunnable; +class nsIStreamListener; +class nsIStructuredCloneContainer; +class nsIURI; +class nsIVariant; +class nsViewManager; +class nsPresContext; +class nsRange; +class nsScriptLoader; +class nsSMILAnimationController; +class nsTextNode; +class nsWindowSizes; +class nsDOMCaretPosition; +class nsViewportInfo; +class nsIGlobalObject; +struct nsCSSSelectorList; + +namespace mozilla { +class CSSStyleSheet; +class ErrorResult; +class EventStates; +class PendingAnimationTracker; +class StyleSetHandle; +class SVGAttrAnimationRuleProcessor; +template<typename> class OwningNonNull; + +namespace css { +class Loader; +class ImageLoader; +class Rule; +} // namespace css + +namespace dom { +class Animation; +class AnonymousContent; +class Attr; +class BoxObject; +class CDATASection; +class Comment; +struct CustomElementDefinition; +class DocGroup; +class DocumentFragment; +class DocumentTimeline; +class DocumentType; +class DOMImplementation; +class DOMIntersectionObserver; +class DOMStringList; +class Element; +struct ElementCreationOptions; +struct ElementRegistrationOptions; +class Event; +class EventTarget; +class FontFaceSet; +class FrameRequestCallback; +struct FullscreenRequest; +class ImageTracker; +class ImportManager; +class HTMLBodyElement; +struct LifecycleCallbackArgs; +class Link; +class Location; +class MediaQueryList; +class GlobalObject; +class NodeFilter; +class NodeIterator; +enum class OrientationType : uint32_t; +class ProcessingInstruction; +class Promise; +class StyleSheetList; +class SVGDocument; +class SVGSVGElement; +class Touch; +class TouchList; +class TreeWalker; +class XPathEvaluator; +class XPathExpression; +class XPathNSResolver; +class XPathResult; +template<typename> class Sequence; + +template<typename, typename> class CallbackObjectHolder; +typedef CallbackObjectHolder<NodeFilter, nsIDOMNodeFilter> NodeFilterHolder; + +} // namespace dom +} // namespace mozilla + +#define NS_IDOCUMENT_IID \ +{ 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 +}; + +// Enum for HSTS priming states +enum class HSTSPrimingState { + eNO_HSTS_PRIMING = 0, // don't do HSTS Priming + eHSTS_PRIMING_ALLOW = 1, // if HSTS priming fails, allow the load to proceed + eHSTS_PRIMING_BLOCK = 2 // if HSTS priming fails, block the load +}; + +// Document states + +// RTL locale: specific to the XUL localedir attribute +#define NS_DOCUMENT_STATE_RTL_LOCALE NS_DEFINE_EVENT_STATE_MACRO(0) +// Window activation status +#define NS_DOCUMENT_STATE_WINDOW_INACTIVE NS_DEFINE_EVENT_STATE_MACRO(1) + +// Some function forward-declarations +class nsContentList; + +//---------------------------------------------------------------------- + +// Document interface. This is implemented by all document objects in +// Gecko. +class nsIDocument : public nsINode +{ + typedef mozilla::dom::GlobalObject GlobalObject; + +public: + typedef mozilla::net::ReferrerPolicy ReferrerPolicyEnum; + typedef mozilla::dom::Element Element; + typedef mozilla::dom::FullscreenRequest FullscreenRequest; + + NS_DECLARE_STATIC_IID_ACCESSOR(NS_IDOCUMENT_IID) + NS_DECL_AND_IMPL_ZEROING_OPERATOR_NEW + +#ifdef MOZILLA_INTERNAL_API + nsIDocument(); +#endif + + // 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; + + public: + explicit PageUnloadingEventTimeStamp(nsIDocument* aDocument) + : mDocument(aDocument) + , mSet(false) + { + MOZ_ASSERT(aDocument); + if (mDocument->mPageUnloadingEventTimeStamp.IsNull()) { + mDocument->SetPageUnloadingEventTimeStamp(); + mSet = true; + } + } + + ~PageUnloadingEventTimeStamp() + { + if (mSet) { + mDocument->CleanUnloadEventsTimeStamp(); + } + } + }; + + /** + * 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; } + + /** + * Signal that the document title may have changed + * (see nsDocument::GetTitle). + * @param aBoundTitleElement true if an HTML or SVG <title> element + * has just been bound to the document. + */ + virtual void NotifyPossibleTitleChange(bool aBoundTitleElement) = 0; + + /** + * Return the URI for the document. May return null. + * + * The value returned corresponds to the "document's 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(). + * + * https://html.spec.whatwg.org/multipage/dom.html#the-document%27s-address + */ + 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. + * + * https://html.spec.whatwg.org/multipage/webappapis.html#creation-url + */ + nsIURI* GetOriginalURI() const + { + return mOriginalURI; + } + + /** + * Set the URI for the document. This also sets the document's original URI, + * if it's null. + */ + virtual void SetDocumentURI(nsIURI* aURI) = 0; + + /** + * Set the URI for the document loaded via XHR, when accessed from + * chrome privileged script. + */ + virtual void SetChromeXHRDocURI(nsIURI* aURI) = 0; + + /** + * Set the base URI for the document loaded via XHR, when accessed from + * chrome privileged script. + */ + virtual void SetChromeXHRDocBaseURI(nsIURI* aURI) = 0; + + /** + * Set referrer policy and upgrade-insecure-requests flags + */ + virtual void ApplySettingsFromCSP(bool aSpeculative) = 0; + + /** + * 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; + } + + /** + * Check to see if a subresource we want to load requires HSTS priming + * to be done. + */ + HSTSPrimingState GetHSTSPrimingStateForLocation(nsIURI* aContentLocation) const + { + HSTSPrimingState state; + if (mHSTSPrimingURIList.Get(aContentLocation, &state)) { + return state; + } + return HSTSPrimingState::eNO_HSTS_PRIMING; + } + + /** + * Add a subresource to the HSTS priming list. If this URI is + * not in the HSTS cache, it will trigger an HSTS priming request + * when we try to load it. + */ + void AddHSTSPrimingLocation(nsIURI* aContentLocation, HSTSPrimingState aState) + { + mHSTSPrimingURIList.Put(aContentLocation, aState); + } + + void ClearHSTSPrimingLocation(nsIURI* aContentLocation) + { + mHSTSPrimingURIList.Remove(aContentLocation); + } + + /** + * Set the principal responsible for this document. + */ + virtual void SetPrincipal(nsIPrincipal *aPrincipal) = 0; + + /** + * Return the LoadGroup for the document. May return null. + */ + already_AddRefed<nsILoadGroup> GetDocumentLoadGroup() const + { + nsCOMPtr<nsILoadGroup> group = do_QueryReferent(mDocumentLoadGroup); + return group.forget(); + } + + /** + * Return the 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(); + } + virtual already_AddRefed<nsIURI> GetBaseURI(bool aTryUseXHRDocBaseURI = false) const override; + + virtual void SetBaseURI(nsIURI* aURI) = 0; + + /** + * Get/Set the base target of a link in a document. + */ + virtual void GetBaseTarget(nsAString &aBaseTarget) = 0; + void SetBaseTarget(const nsString& aBaseTarget) { + mBaseTarget = aBaseTarget; + } + + /** + * Return a standard name for the document's character set. + */ + const nsCString& GetDocumentCharacterSet() const + { + return mCharacterSet; + } + + /** + * Set the document's character encoding. |aCharSetID| should be canonical. + * That is, callers are responsible for the charset alias resolution. + */ + virtual void SetDocumentCharacterSet(const nsACString& aCharSetID) = 0; + + int32_t GetDocumentCharacterSetSource() const + { + return mCharacterSetSource; + } + + // This method MUST be called before SetDocumentCharacterSet if + // you're planning to call both. + void SetDocumentCharacterSetSource(int32_t aCharsetSource) + { + mCharacterSetSource = aCharsetSource; + } + + /** + * Add an observer that gets notified whenever the charset changes. + */ + virtual nsresult AddCharSetObserver(nsIObserver* aObserver) = 0; + + /** + * Remove a charset observer. + */ + virtual void RemoveCharSetObserver(nsIObserver* aObserver) = 0; + + /** + * This gets fired when the element that an id refers to changes. + * This fires at difficult times. It is generally not safe to do anything + * which could modify the DOM in any way. Use + * nsContentUtils::AddScriptRunner. + * @return true to keep the callback in the callback set, false + * to remove it. + */ + typedef bool (* IDTargetObserver)(Element* aOldElement, + Element* aNewelement, void* aData); + + /** + * Add an IDTargetObserver for a specific ID. The IDTargetObserver + * will be fired whenever the content associated with the ID changes + * in the future. If aForImage is true, mozSetImageElement can override + * what content is associated with the ID. In that case the IDTargetObserver + * will be notified at those times when the result of LookupImageElement + * changes. + * At most one (aObserver, aData, aForImage) triple can be + * registered for each ID. + * @return the content currently associated with the ID. + */ + virtual Element* AddIDTargetObserver(nsIAtom* aID, IDTargetObserver aObserver, + void* aData, bool aForImage) = 0; + /** + * Remove the (aObserver, aData, aForImage) triple for a specific ID, if + * registered. + */ + virtual void RemoveIDTargetObserver(nsIAtom* aID, IDTargetObserver aObserver, + void* aData, bool aForImage) = 0; + + /** + * Get the Content-Type of this document. + * (This will always return NS_OK, but has this signature to be compatible + * with nsIDOMDocument::GetContentType()) + */ + NS_IMETHOD GetContentType(nsAString& aContentType) = 0; + + /** + * Set the Content-Type of this document. + */ + virtual void SetContentType(const nsAString& aContentType) = 0; + + /** + * Return the language of this document. + */ + void GetContentLanguage(nsAString& aContentLanguage) const + { + CopyASCIItoUTF16(mContentLanguage, aContentLanguage); + } + + // The states BidiEnabled and MathMLEnabled should persist across multiple views + // (screen, print) of the same document. + + /** + * Check if the document contains bidi data. + * If so, we have to apply the Unicode Bidi Algorithm. + */ + bool GetBidiEnabled() const + { + return mBidiEnabled; + } + + /** + * Indicate the document contains bidi data. + * Currently, we cannot disable bidi, because once bidi is enabled, + * it affects a frame model irreversibly, and plays even though + * the document no longer contains bidi data. + */ + void SetBidiEnabled() + { + mBidiEnabled = true; + } + + /** + * Check if the document contains (or has contained) any MathML elements. + */ + bool GetMathMLEnabled() const + { + return mMathMLEnabled; + } + + void SetMathMLEnabled() + { + mMathMLEnabled = true; + } + + /** + * Ask this document whether it's the initial document in its window. + */ + bool IsInitialDocument() const + { + return mIsInitialDocumentInWindow; + } + + /** + * Tell this document that it's the initial document in its window. See + * comments on mIsInitialDocumentInWindow for when this should be called. + */ + void SetIsInitialDocument(bool aIsInitialDocument) + { + mIsInitialDocumentInWindow = aIsInitialDocument; + } + + + /** + * Get the bidi options for this document. + * @see nsBidiUtils.h + */ + uint32_t GetBidiOptions() const + { + return mBidiOptions; + } + + /** + * Set the bidi options for this document. This just sets the bits; + * callers are expected to take action as needed if they want this + * change to actually change anything immediately. + * @see nsBidiUtils.h + */ + void SetBidiOptions(uint32_t aBidiOptions) + { + mBidiOptions = aBidiOptions; + } + + /** + * Get the has mixed active content loaded flag for this document. + */ + bool GetHasMixedActiveContentLoaded() + { + return mHasMixedActiveContentLoaded; + } + + /** + * Set the has mixed active content loaded flag for this document. + */ + void SetHasMixedActiveContentLoaded(bool aHasMixedActiveContentLoaded) + { + mHasMixedActiveContentLoaded = aHasMixedActiveContentLoaded; + } + + /** + * Get mixed active content blocked flag for this document. + */ + bool GetHasMixedActiveContentBlocked() + { + return mHasMixedActiveContentBlocked; + } + + /** + * Set the mixed active content blocked flag for this document. + */ + void SetHasMixedActiveContentBlocked(bool aHasMixedActiveContentBlocked) + { + mHasMixedActiveContentBlocked = aHasMixedActiveContentBlocked; + } + + /** + * Get the has mixed display content loaded flag for this document. + */ + bool GetHasMixedDisplayContentLoaded() + { + return mHasMixedDisplayContentLoaded; + } + + /** + * Set the has mixed display content loaded flag for this document. + */ + void SetHasMixedDisplayContentLoaded(bool aHasMixedDisplayContentLoaded) + { + mHasMixedDisplayContentLoaded = aHasMixedDisplayContentLoaded; + } + + /** + * Get mixed display content blocked flag for this document. + */ + bool GetHasMixedDisplayContentBlocked() + { + return mHasMixedDisplayContentBlocked; + } + + /** + * Set the mixed display content blocked flag for this document. + */ + void SetHasMixedDisplayContentBlocked(bool aHasMixedDisplayContentBlocked) + { + mHasMixedDisplayContentBlocked = aHasMixedDisplayContentBlocked; + } + + /** + * 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; + } + + /** + * Access HTTP header data (this may also get set from other + * sources, like HTML META tags). + */ + virtual void GetHeaderData(nsIAtom* aHeaderField, nsAString& aData) const = 0; + virtual void SetHeaderData(nsIAtom* aheaderField, const nsAString& aData) = 0; + + /** + * Create a new presentation shell that will use aContext for its + * presentation context (presentation contexts <b>must not</b> be + * shared among multiple presentation shells). The caller of this + * method is responsible for calling BeginObservingDocument() on the + * presshell if the presshell should observe document mutations. + */ + virtual already_AddRefed<nsIPresShell> CreateShell( + nsPresContext* aContext, + nsViewManager* aViewManager, + mozilla::StyleSetHandle aStyleSet) = 0; + virtual void DeleteShell() = 0; + + nsIPresShell* GetShell() const + { + return GetBFCacheEntry() ? nullptr : mPresShell; + } + + // 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; + } + + void SetBFCacheEntry(nsIBFCacheEntry* aEntry) + { + NS_ASSERTION(IsBFCachingAllowed() || !aEntry, + "You should have checked!"); + + mBFCacheEntry = aEntry; + } + + nsIBFCacheEntry* GetBFCacheEntry() const + { + return mBFCacheEntry; + } + + /** + * Return the parent document of this document. Will return null + * unless this document is within a compound document and has a + * parent. Note that this parent chain may cross chrome boundaries. + */ + nsIDocument *GetParentDocument() const + { + return mParentDocument; + } + + /** + * Set the parent document of this document. + */ + void SetParentDocument(nsIDocument* aParent) + { + mParentDocument = aParent; + } + + /** + * Are plugins allowed in this document ? + */ + virtual nsresult GetAllowPlugins (bool* aAllowPlugins) = 0; + + /** + * Set the sub document for aContent to aSubDoc. + */ + virtual nsresult SetSubDocumentFor(Element* aContent, + nsIDocument* aSubDoc) = 0; + + /** + * Get the sub document for aContent + */ + virtual nsIDocument *GetSubDocumentFor(nsIContent *aContent) const = 0; + + /** + * Find the content node for which aDocument is a sub document. + */ + virtual Element* FindContentForSubDocument(nsIDocument* aDocument) const = 0; + + /** + * Return the doctype for this document. + */ + mozilla::dom::DocumentType* GetDoctype() const; + + /** + * Return the root element for this document. + */ + Element* GetRootElement() const; + + /** + * 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. + */ + virtual nsViewportInfo GetViewportInfo(const mozilla::ScreenIntSize& aDisplaySize) = 0; + + /** + * True iff this doc will ignore manual character encoding overrides. + */ + virtual bool WillIgnoreCharsetOverride() { + return true; + } + + /** + * Return whether the document was created by a srcdoc iframe. + */ + bool IsSrcdocDocument() const { + return mIsSrcdocDocument; + } + + /** + * Sets whether the document was created by a srcdoc iframe. + */ + void SetIsSrcdocDocument(bool aIsSrcdocDocument) { + mIsSrcdocDocument = aIsSrcdocDocument; + } + + /* + * Gets the srcdoc string from within the channel (assuming both exist). + * Returns a void string if this isn't a srcdoc document or if + * the channel has not been set. + */ + nsresult GetSrcdocData(nsAString& aSrcdocData); + + bool DidDocumentOpen() { + return mDidDocumentOpen; + } + + already_AddRefed<mozilla::dom::AnonymousContent> + 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; + } + + static nsresult GenerateDocumentId(nsAString& aId); + nsresult GetOrCreateId(nsAString& aId); + void SetId(const nsAString& aId); + + 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; + } + + virtual void NotifyLayerManagerRecreated() = 0; + +protected: + virtual Element *GetRootElementInternal() const = 0; + + void SetPageUnloadingEventTimeStamp() + { + MOZ_ASSERT(!mPageUnloadingEventTimeStamp); + mPageUnloadingEventTimeStamp = mozilla::TimeStamp::NowLoRes(); + } + + void CleanUnloadEventsTimeStamp() + { + MOZ_ASSERT(mPageUnloadingEventTimeStamp); + mPageUnloadingEventTimeStamp = mozilla::TimeStamp(); + } + +private: + class SelectorCacheKey + { + public: + explicit SelectorCacheKey(const nsAString& aString) : mKey(aString) + { + MOZ_COUNT_CTOR(SelectorCacheKey); + } + + nsString mKey; + nsExpirationState mState; + + nsExpirationState* GetExpirationState() { return &mState; } + + ~SelectorCacheKey() + { + MOZ_COUNT_DTOR(SelectorCacheKey); + } + }; + + class SelectorCacheKeyDeleter; + +public: + class SelectorCache final + : public nsExpirationTracker<SelectorCacheKey, 4> + { + public: + SelectorCache(); + + // CacheList takes ownership of aSelectorList. + void CacheList(const nsAString& aSelector, nsCSSSelectorList* aSelectorList); + + virtual void NotifyExpired(SelectorCacheKey* aSelector) override; + + // We do not call MarkUsed because it would just slow down lookups and + // because we're OK expiring things after a few seconds even if they're + // being used. Returns whether we actually had an entry for aSelector. + // If we have an entry and *aList is null, that indicates that aSelector + // has already been parsed and is not a syntactically valid selector. + bool GetList(const nsAString& aSelector, nsCSSSelectorList** aList) + { + return mTable.Get(aSelector, aList); + } + + ~SelectorCache() + { + AgeAllGenerations(); + } + + private: + nsClassHashtable<nsStringHashKey, nsCSSSelectorList> mTable; + }; + + SelectorCache& GetSelectorCache() + { + return mSelectorCache; + } + // Get the root <html> element, or return null if there isn't one (e.g. + // if the root isn't <html>) + Element* GetHtmlElement() const; + // Returns the first child of GetHtmlContent which has the given tag, + // or nullptr if that doesn't exist. + Element* GetHtmlChildElement(nsIAtom* aTag); + // Get the canonical <body> element, or return null if there isn't one (e.g. + // if the root isn't <html> or if the <body> isn't there) + mozilla::dom::HTMLBodyElement* GetBodyElement(); + // Get the canonical <head> element, or return null if there isn't one (e.g. + // if the root isn't <html> or if the <head> isn't there) + Element* GetHeadElement() { + return GetHtmlChildElement(nsGkAtoms::head); + } + + /** + * Accessors to the collection of stylesheets owned by this document. + * Style sheets are ordered, most significant last. + */ + + /** + * 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. + */ + virtual void EnsureOnDemandBuiltInUASheet(mozilla::StyleSheet* aSheet) = 0; + + /** + * Get the number of (document) stylesheets + * + * @return the number of stylesheets + * @throws no exceptions + */ + virtual int32_t GetNumberOfStyleSheets() const = 0; + + /** + * Get a particular stylesheet + * @param aIndex the index the stylesheet lives at. This is zero-based + * @return the stylesheet at aIndex. Null if aIndex is out of range. + * @throws no exceptions + */ + virtual mozilla::StyleSheet* GetStyleSheetAt(int32_t aIndex) const = 0; + + /** + * Insert a sheet at a particular spot in the stylesheet list (zero-based) + * @param aSheet the sheet to insert + * @param aIndex the index to insert at. This index will be + * adjusted for the "special" sheets. + * @throws no exceptions + */ + virtual void InsertStyleSheetAt(mozilla::StyleSheet* aSheet, + int32_t aIndex) = 0; + + /** + * Get the index of a particular stylesheet. This will _always_ + * consider the "special" sheets as part of the sheet list. + * @param aSheet the sheet to get the index of + * @return aIndex the index of the sheet in the full list + */ + virtual int32_t GetIndexOfStyleSheet( + const mozilla::StyleSheet* aSheet) const = 0; + + /** + * Replace the stylesheets in aOldSheets with the stylesheets in + * aNewSheets. The two lists must have equal length, and the sheet + * at positon J in the first list will be replaced by the sheet at + * position J in the second list. Some sheets in the second list + * may be null; if so the corresponding sheets in the first list + * will simply be removed. + */ + virtual void UpdateStyleSheets( + nsTArray<RefPtr<mozilla::StyleSheet>>& aOldSheets, + nsTArray<RefPtr<mozilla::StyleSheet>>& aNewSheets) = 0; + + /** + * Add a stylesheet to the document + */ + virtual void AddStyleSheet(mozilla::StyleSheet* aSheet) = 0; + + /** + * Remove a stylesheet from the document + */ + virtual void RemoveStyleSheet(mozilla::StyleSheet* aSheet) = 0; + + /** + * Notify the document that the applicable state of the sheet changed + * and that observers should be notified and style sets updated + */ + virtual void SetStyleSheetApplicableState(mozilla::StyleSheet* aSheet, + bool aApplicable) = 0; + + enum additionalSheetType { + eAgentSheet, + eUserSheet, + eAuthorSheet, + AdditionalSheetTypeCount + }; + + virtual nsresult LoadAdditionalStyleSheet(additionalSheetType aType, + nsIURI* aSheetURI) = 0; + virtual nsresult AddAdditionalStyleSheet(additionalSheetType aType, + mozilla::StyleSheet* aSheet) = 0; + virtual void RemoveAdditionalStyleSheet(additionalSheetType aType, + nsIURI* sheetURI) = 0; + virtual mozilla::StyleSheet* GetFirstAdditionalAuthorSheet() = 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. + * + * Defined in nsIDocumentInlines.h. + */ + template<typename T> + size_t FindDocStyleSheetInsertionPoint(const nsTArray<RefPtr<T>>& aDocSheets, + T* aSheet); + + /** + * Get this document's CSSLoader. This is guaranteed to not return null. + */ + mozilla::css::Loader* CSSLoader() const { + return mCSSLoader; + } + + mozilla::StyleBackendType GetStyleBackendType() const { + if (mStyleBackendType == mozilla::StyleBackendType(0)) { + const_cast<nsIDocument*>(this)->UpdateStyleBackendType(); + } + MOZ_ASSERT(mStyleBackendType != mozilla::StyleBackendType(0)); + return mStyleBackendType; + } + + void UpdateStyleBackendType(); + + bool IsStyledByServo() const { + return GetStyleBackendType() == mozilla::StyleBackendType::Servo; + } + + /** + * Get this document's StyleImageLoader. This is guaranteed to not return null. + */ + mozilla::css::ImageLoader* StyleImageLoader() const { + return mStyleImageLoader; + } + + /** + * Get the channel that was passed to StartDocumentLoad or Reset for this + * document. Note that this may be null in some cases (eg if + * StartDocumentLoad or Reset were never called) + */ + virtual nsIChannel* GetChannel() const = 0; + + /** + * Get this document's attribute stylesheet. May return null if + * there isn't one. + */ + nsHTMLStyleSheet* GetAttributeStyleSheet() const { + return mAttrStyleSheet; + } + + /** + * Get this document's inline style sheet. May return null if there + * isn't one + */ + nsHTMLCSSStyleSheet* GetInlineStyleSheet() const { + return mStyleAttrStyleSheet; + } + + /** + * Get this document's SVG Animation rule processor. May return null + * if there isn't one. + */ + mozilla::SVGAttrAnimationRuleProcessor* + GetSVGAttrAnimationRuleProcessor() const + { + return mSVGAttrAnimationRuleProcessor; + } + + virtual void SetScriptGlobalObject(nsIScriptGlobalObject* aGlobalObject) = 0; + + /** + * Get/set the object from which the context for the event/script handling can + * be got. Normally GetScriptHandlingObject() returns the same object as + * GetScriptGlobalObject(), but if the document is loaded as data, + * non-null may be returned, even if GetScriptGlobalObject() returns null. + * aHasHadScriptHandlingObject is set true if document has had the object + * for event/script handling. Do not process any events/script if the method + * returns null, but aHasHadScriptHandlingObject is true. + */ + nsIScriptGlobalObject* + GetScriptHandlingObject(bool& aHasHadScriptHandlingObject) const + { + aHasHadScriptHandlingObject = mHasHadScriptHandlingObject; + return mScriptGlobalObject ? mScriptGlobalObject.get() : + GetScriptHandlingObjectInternal(); + } + virtual void SetScriptHandlingObject(nsIScriptGlobalObject* aScriptObject) = 0; + + /** + * Get the object that is used as the scope for all of the content + * wrappers whose owner document is this document. Unlike the script global + * object, this will only return null when the global object for this + * document is truly gone. Use this object when you're trying to find a + * content wrapper in XPConnect. + */ + virtual nsIGlobalObject* GetScopeObject() const = 0; + virtual void SetScopeObject(nsIGlobalObject* aGlobal) = 0; + + /** + * Return the window containing the document (the outer window). + */ + 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; + } + + /** + * Get the script loader for this document + */ + virtual nsScriptLoader* ScriptLoader() = 0; + + /** + * Add/Remove an element to the document's id and name hashes + */ + virtual void AddToIdTable(Element* aElement, nsIAtom* aId) = 0; + virtual void RemoveFromIdTable(Element* aElement, nsIAtom* aId) = 0; + virtual void AddToNameTable(Element* aElement, nsIAtom* aName) = 0; + virtual void RemoveFromNameTable(Element* aElement, nsIAtom* aName) = 0; + + /** + * Returns all elements in the fullscreen stack in the insertion order. + */ + virtual nsTArray<Element*> GetFullscreenStack() const = 0; + + /** + * Asynchronously requests that the document make aElement the fullscreen + * element, and move into fullscreen mode. The current fullscreen element + * (if any) is pushed onto the fullscreen element stack, and it can be + * returned to fullscreen status by calling RestorePreviousFullScreenState(). + * + * Note that requesting fullscreen in a document also makes the element which + * contains this document in this document's parent document fullscreen. i.e. + * the <iframe> or <browser> that contains this document is also mode + * fullscreen. This happens recursively in all ancestor documents. + */ + virtual void AsyncRequestFullScreen( + mozilla::UniquePtr<FullscreenRequest>&& aRequest) = 0; + + /** + * Called when a frame in a child process has entered fullscreen or when a + * fullscreen frame in a child process changes to another origin. + * aFrameElement is the frame element which contains the child-process + * fullscreen document. + */ + virtual nsresult + RemoteFrameFullscreenChanged(nsIDOMElement* aFrameElement) = 0; + + /** + * Called when a frame in a remote child document has rolled back fullscreen + * so that all its fullscreen element stacks are empty; we must continue the + * rollback in this parent process' doc tree branch which is fullscreen. + * Note that only one branch of the document tree can have its documents in + * fullscreen state at one time. We're in inconsistent state if a + * fullscreen document has a parent and that parent isn't fullscreen. We + * preserve this property across process boundaries. + */ + virtual nsresult RemoteFrameFullscreenReverted() = 0; + + /** + * Restores the previous full-screen element to full-screen status. If there + * is no former full-screen element, this exits full-screen, moving the + * top-level browser window out of full-screen mode. + */ + virtual void RestorePreviousFullScreenState() = 0; + + /** + * Returns true if this document is a fullscreen leaf document, i.e. it + * is in fullscreen mode and has no fullscreen children. + */ + virtual bool IsFullscreenLeaf() = 0; + + /** + * Returns the document which is at the root of this document's branch + * in the in-process document tree. Returns nullptr if the document isn't + * fullscreen. + */ + virtual nsIDocument* GetFullscreenRoot() = 0; + + /** + * Sets the fullscreen root to aRoot. This stores a weak reference to aRoot + * in this document. + */ + virtual void SetFullscreenRoot(nsIDocument* aRoot) = 0; + + /** + * 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); + + virtual void RequestPointerLock(Element* aElement) = 0; + + static void UnlockPointer(nsIDocument* aDoc = nullptr); + + // ScreenOrientation related APIs + + virtual void SetCurrentOrientation(mozilla::dom::OrientationType aType, + uint16_t aAngle) = 0; + virtual uint16_t CurrentOrientationAngle() const = 0; + virtual mozilla::dom::OrientationType CurrentOrientationType() const = 0; + virtual void SetOrientationPendingPromise(mozilla::dom::Promise* aPromise) = 0; + virtual mozilla::dom::Promise* GetOrientationPendingPromise() const = 0; + + //---------------------------------------------------------------------- + + // Document notification API's + + /** + * Add a new observer of document change notifications. Whenever + * content is changed, appended, inserted or removed the observers are + * informed. An observer that is already observing the document must + * not be added without being removed first. + */ + virtual void AddObserver(nsIDocumentObserver* aObserver) = 0; + + /** + * Remove an observer of document change notifications. This will + * return false if the observer cannot be found. + */ + virtual bool RemoveObserver(nsIDocumentObserver* aObserver) = 0; + + // Observation hooks used to propagate notifications to document observers. + // BeginUpdate must be called before any batch of modifications of the + // content model or of style data, EndUpdate must be called afterward. + // To make this easy and painless, use the mozAutoDocUpdate helper class. + virtual void BeginUpdate(nsUpdateType aUpdateType) = 0; + virtual void EndUpdate(nsUpdateType aUpdateType) = 0; + virtual void BeginLoad() = 0; + virtual void EndLoad() = 0; + + enum ReadyState { READYSTATE_UNINITIALIZED = 0, READYSTATE_LOADING = 1, READYSTATE_INTERACTIVE = 3, READYSTATE_COMPLETE = 4}; + virtual void SetReadyStateInternal(ReadyState rs) = 0; + ReadyState GetReadyStateEnum() + { + return mReadyState; + } + + // notify that a content node changed state. This must happen under + // a scriptblocker but NOT within a begin/end update. + virtual void ContentStateChanged(nsIContent* aContent, + mozilla::EventStates aStateMask) = 0; + + // Notify that a document state has changed. + // This should only be called by callers whose state is also reflected in the + // implementation of nsDocument::GetDocumentState. + virtual void DocumentStatesChanged(mozilla::EventStates aStateMask) = 0; + + // Observation hooks for style data to propagate notifications + // to document observers + virtual void StyleRuleChanged(mozilla::StyleSheet* aStyleSheet, + mozilla::css::Rule* aStyleRule) = 0; + virtual void StyleRuleAdded(mozilla::StyleSheet* aStyleSheet, + mozilla::css::Rule* aStyleRule) = 0; + virtual void StyleRuleRemoved(mozilla::StyleSheet* aStyleSheet, + mozilla::css::Rule* aStyleRule) = 0; + + /** + * Flush notifications for this document and its parent documents + * (since those may affect the layout of this one). + */ + virtual void FlushPendingNotifications(mozFlushType aType) = 0; + + /** + * Calls FlushPendingNotifications on any external resources this document + * has. If this document has no external resources or is an external resource + * itself this does nothing. This should only be called with + * aType >= Flush_Style. + */ + virtual void FlushExternalResources(mozFlushType aType) = 0; + + nsBindingManager* BindingManager() const + { + return mNodeInfoManager->GetBindingManager(); + } + + /** + * Only to be used inside Gecko, you can't really do anything with the + * pointer outside Gecko anyway. + */ + nsNodeInfoManager* NodeInfoManager() const + { + return mNodeInfoManager; + } + + /** + * Reset the document using the given channel and loadgroup. This works + * like ResetToURI, but also sets the document's channel to aChannel. + * The principal of the document will be set from the channel. + */ + virtual void Reset(nsIChannel* aChannel, nsILoadGroup* aLoadGroup) = 0; + + /** + * Reset this document to aURI, aLoadGroup, and aPrincipal. aURI must not be + * null. If aPrincipal is null, a codebase principal based on aURI will be + * used. + */ + virtual void ResetToURI(nsIURI *aURI, nsILoadGroup* aLoadGroup, + nsIPrincipal* aPrincipal) = 0; + + /** + * Set the container (docshell) for this document. Virtual so that + * docshell can call it. + */ + virtual void SetContainer(nsDocShell* aContainer); + + /** + * Get the container (docshell) for this document. + */ + virtual nsISupports* GetContainer() const; + + /** + * Get the container's load context for this document. + */ + nsILoadContext* GetLoadContext() const; + + /** + * Get docshell the for this document. + */ + nsIDocShell* GetDocShell() const; + + /** + * Set and get XML declaration. If aVersion is null there is no declaration. + * aStandalone takes values -1, 0 and 1 indicating respectively that there + * was no standalone parameter in the declaration, that it was given as no, + * or that it was given as yes. + */ + virtual void SetXMLDeclaration(const char16_t *aVersion, + const char16_t *aEncoding, + const int32_t aStandalone) = 0; + virtual void GetXMLDeclaration(nsAString& aVersion, + nsAString& aEncoding, + nsAString& Standalone) = 0; + + /** + * 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() + { + return IsXULDocument() || AllowXULXBL(); + } + + virtual bool IsScriptEnabled() = 0; + + /** + * Create an element with the specified name, prefix and namespace ID. + * Returns null if element name parsing failed. + */ + virtual already_AddRefed<Element> CreateElem(const nsAString& aName, + nsIAtom* aPrefix, + int32_t aNamespaceID, + const nsAString* aIs = nullptr) = 0; + + /** + * Get the security info (i.e. SSL state etc) that the document got + * from the channel/document that created the content of the + * document. + * + * @see nsIChannel + */ + nsISupports *GetSecurityInfo() + { + return mSecurityInfo; + } + + /** + * Get the channel that failed to load and resulted in an error page, if it + * exists. This is only relevant to error pages. + */ + virtual nsIChannel* GetFailedChannel() const = 0; + + /** + * Set the channel that failed to load and resulted in an error page. + * This is only relevant to error pages. + */ + virtual void SetFailedChannel(nsIChannel* aChannel) = 0; + + /** + * Returns the default namespace ID used for elements created in this + * document. + */ + int32_t GetDefaultNamespaceID() const + { + return mDefaultElementType; + } + + void DeleteAllProperties(); + void DeleteAllPropertiesFor(nsINode* aNode); + + nsPropertyTable* PropertyTable(uint16_t aCategory) { + if (aCategory == 0) + return &mPropertyTable; + return GetExtraPropertyTable(aCategory); + } + uint32_t GetPropertyTableCount() + { return mExtraPropertyTables.Length() + 1; } + + /** + * Sets the ID used to identify this part of the multipart document + */ + void SetPartID(uint32_t aID) { + mPartID = aID; + } + + /** + * Return the ID used to identify this part of the multipart document + */ + uint32_t GetPartID() const { + return mPartID; + } + + /** + * Sanitize the document by resetting all input elements and forms that have + * autocomplete=off to their default values. + */ + virtual void Sanitize() = 0; + + /** + * Enumerate all subdocuments. + * The enumerator callback should return true to continue enumerating, or + * false to stop. This will never get passed a null aDocument. + */ + typedef bool (*nsSubDocEnumFunc)(nsIDocument *aDocument, void *aData); + virtual void EnumerateSubDocuments(nsSubDocEnumFunc aCallback, + void *aData) = 0; + + /** + * Check whether it is safe to cache the presentation of this document + * and all of its subdocuments. This method checks the following conditions + * recursively: + * - Some document types, such as plugin documents, cannot be safely cached. + * - If there are any pending requests, we don't allow the presentation + * to be cached. Ideally these requests would be suspended and resumed, + * but that is difficult in some cases, such as XMLHttpRequest. + * - If there are any beforeunload or unload listeners, we must fire them + * for correctness, but this likely puts the document into a state where + * it would not function correctly if restored. + * + * |aNewRequest| should be the request for a new document which will + * replace this document in the docshell. The new document's request + * will be ignored when checking for active requests. If there is no + * request associated with the new document, this parameter may be null. + */ + virtual bool CanSavePresentation(nsIRequest *aNewRequest) = 0; + + /** + * Notify the document that its associated ContentViewer is being destroyed. + * This releases circular references so that the document can go away. + * Destroy() is only called on documents that have a content viewer. + */ + virtual void Destroy() = 0; + + /** + * Notify the document that its associated ContentViewer is no longer + * the current viewer for the docshell. The document might still + * be rendered in "zombie state" until the next document is ready. + * The document should save form control state. + */ + virtual void RemovedFromDocShell() = 0; + + /** + * Get the layout history state that should be used to save and restore state + * for nodes in this document. This may return null; if that happens state + * saving and restoration is not possible. + */ + virtual already_AddRefed<nsILayoutHistoryState> GetLayoutHistoryState() const = 0; + + /** + * Methods that can be used to prevent onload firing while an event that + * should block onload is posted. onload is guaranteed to not fire until + * either all calls to BlockOnload() have been matched by calls to + * UnblockOnload() or the load has been stopped altogether (by the user + * pressing the Stop button, say). + */ + virtual void BlockOnload() = 0; + /** + * @param aFireSync whether to fire onload synchronously. If false, + * onload will fire asynchronously after all onload blocks have been + * removed. It will NOT fire from inside UnblockOnload. If true, + * onload may fire from inside UnblockOnload. + */ + virtual void UnblockOnload(bool aFireSync) = 0; + + void BlockDOMContentLoaded() + { + ++mBlockDOMContentLoaded; + } + + virtual void UnblockDOMContentLoaded() = 0; + + /** + * Notification that the page has been shown, for documents which are loaded + * into a DOM window. This corresponds to the completion of document load, + * or to the page's presentation being restored into an existing DOM window. + * This notification fires applicable DOM events to the content window. See + * 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) = 0; + + /** + * Notification that the page has been hidden, for documents which are loaded + * into a DOM window. This corresponds to the unloading of the document, or + * to the document's presentation being saved but removed from an existing + * DOM window. This notification fires applicable DOM events to the content + * window. See 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. + */ + virtual void OnPageHide(bool aPersisted, + mozilla::dom::EventTarget* aDispatchStartTarget) = 0; + + /* + * We record the set of links in the document that are relevant to + * style. + */ + /** + * Notification that an element is a link that is relevant to style. + */ + virtual void AddStyleRelevantLink(mozilla::dom::Link* aLink) = 0; + /** + * Notification that an element is a link and its URI might have been + * changed or the element removed. If the element is still a link relevant + * to style, then someone must ensure that AddStyleRelevantLink is + * (eventually) called on it again. + */ + virtual void ForgetLink(mozilla::dom::Link* aLink) = 0; + + /** + * Resets and removes a box object from the document's box object cache + * + * @param aElement canonical nsIContent pointer of the box object's element + */ + virtual void ClearBoxObjectFor(nsIContent *aContent) = 0; + + /** + * Get the box object for an element. This is not exposed through a + * scriptable interface except for XUL documents. + */ + virtual already_AddRefed<mozilla::dom::BoxObject> + GetBoxObjectFor(mozilla::dom::Element* aElement, + mozilla::ErrorResult& aRv) = 0; + + /** + * Support for window.matchMedia() + */ + + already_AddRefed<mozilla::dom::MediaQueryList> + MatchMedia(const nsAString& aMediaQueryList); + + const PRCList* MediaQueryLists() const { + 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; + } + + /** + * See GetAnonymousElementByAttribute on nsIDOMDocumentXBL. + */ + virtual Element* + GetAnonymousElementByAttribute(nsIContent* aElement, + nsIAtom* aAttrName, + const nsAString& aAttrValue) const = 0; + + /** + * Helper for nsIDOMDocument::elementFromPoint implementation that allows + * ignoring the scroll frame and/or avoiding layout flushes. + * + * @see nsIDOMWindowUtils::elementFromPoint + */ + virtual Element* ElementFromPointHelper(float aX, float aY, + bool aIgnoreRootScrollFrame, + bool aFlushLayout) = 0; + + enum ElementsFromPointFlags { + IGNORE_ROOT_SCROLL_FRAME = 1, + FLUSH_LAYOUT = 2, + IS_ELEMENT_FROM_POINT = 4 + }; + + virtual void ElementsFromPointHelper(float aX, float aY, + uint32_t aFlags, + nsTArray<RefPtr<mozilla::dom::Element>>& aElements) = 0; + + virtual nsresult NodesFromRectHelper(float aX, float aY, + float aTopSize, float aRightSize, + float aBottomSize, float aLeftSize, + bool aIgnoreRootScrollFrame, + bool aFlushLayout, + nsIDOMNodeList** aReturn) = 0; + + /** + * See FlushSkinBindings on nsBindingManager + */ + virtual void FlushSkinBindings() = 0; + + /** + * To batch DOMSubtreeModified, document needs to be informed when + * a mutation event might be dispatched, even if the event isn't actually + * created because there are no listeners for it. + * + * @param aTarget is the target for the mutation event. + */ + void MayDispatchMutationEvent(nsINode* aTarget) + { + if (mSubtreeModifiedDepth > 0) { + mSubtreeModifiedTargets.AppendObject(aTarget); + } + } + + /** + * Marks as not-going-to-be-collected for the given generation of + * cycle collection. + */ + void MarkUncollectableForCCGeneration(uint32_t aGeneration) + { + mMarkedCCGeneration = aGeneration; + } + + /** + * Gets the cycle collector generation this document is marked for. + */ + uint32_t GetMarkedCCGeneration() + { + return mMarkedCCGeneration; + } + + bool IsLoadedAsData() + { + return mLoadedAsData; + } + + bool IsLoadedAsInteractiveData() + { + return mLoadedAsInteractiveData; + } + + bool MayStartLayout() + { + return mMayStartLayout; + } + + void SetMayStartLayout(bool aMayStartLayout) + { + mMayStartLayout = aMayStartLayout; + } + + already_AddRefed<nsIDocumentEncoder> GetCachedEncoder(); + + void SetCachedEncoder(already_AddRefed<nsIDocumentEncoder> aEncoder); + + // In case of failure, the document really can't initialize the frame loader. + virtual nsresult InitializeFrameLoader(nsFrameLoader* aLoader) = 0; + // In case of failure, the caller must handle the error, for example by + // finalizing frame loader asynchronously. + virtual nsresult FinalizeFrameLoader(nsFrameLoader* aLoader, nsIRunnable* aFinalizer) = 0; + // Removes the frame loader of aShell from the initialization list. + virtual void TryCancelFrameLoaderInitialization(nsIDocShell* aShell) = 0; + + /** + * Check whether this document is a root document that is not an + * external resource. + */ + bool IsRootDisplayDocument() const + { + return !mParentDocument && !mDisplayDocument; + } + + bool IsBeingUsedAsImage() const { + return mIsBeingUsedAsImage; + } + + void SetIsBeingUsedAsImage() { + mIsBeingUsedAsImage = true; + } + + bool IsResourceDoc() const { + return IsBeingUsedAsImage() || // Are we a helper-doc for an SVG image? + 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() && + !GetWindow(), + "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"); + MOZ_ASSERT(!aDisplayDocument->GetDisplayDocument(), + "Display documents should not nest"); + mDisplayDocument = aDisplayDocument; + mHasDisplayDocument = !!aDisplayDocument; + } + + /** + * A class that represents an external resource load that has begun but + * doesn't have a document yet. Observers can be registered on this object, + * and will be notified after the document is created. Observers registered + * after the document has been created will NOT be notified. When observers + * are notified, the subject will be the newly-created document, the topic + * will be "external-resource-document-created", and the data will be null. + * If document creation fails for some reason, observers will still be + * notified, with a null document pointer. + */ + class ExternalResourceLoad : public nsISupports + { + public: + virtual ~ExternalResourceLoad() {} + + void AddObserver(nsIObserver* aObserver) { + MOZ_ASSERT(aObserver, "Must have observer"); + mObservers.AppendElement(aObserver); + } + + const nsTArray< nsCOMPtr<nsIObserver> > & Observers() { + return mObservers; + } + protected: + AutoTArray< nsCOMPtr<nsIObserver>, 8 > mObservers; + }; + + /** + * Request an external resource document for aURI. This will return the + * resource document if available. If one is not available yet, it will + * start loading as needed, and the pending load object will be returned in + * aPendingLoad so that the caller can register an observer to wait for the + * load. If this function returns null and doesn't return a pending load, + * that means that there is no resource document for this URI and won't be + * one in the future. + * + * @param aURI the URI to get + * @param aRequestingNode the node making the request + * @param aPendingLoad the pending load for this request, if any + */ + virtual nsIDocument* + RequestExternalResource(nsIURI* aURI, + nsINode* aRequestingNode, + ExternalResourceLoad** aPendingLoad) = 0; + + /** + * Enumerate the external resource documents associated with this document. + * The enumerator callback should return true to continue enumerating, or + * false to stop. This callback will never get passed a null aDocument. + */ + virtual void EnumerateExternalResources(nsSubDocEnumFunc aCallback, + void* aData) = 0; + + /** + * Return whether the document is currently showing (in the sense of + * OnPageShow() having been called already and OnPageHide() not having been + * called yet. + */ + bool IsShowing() const { return mIsShowing; } + /** + * Return whether the document is currently visible (in the sense of + * OnPageHide having been called and OnPageShow not yet having been called) + */ + bool IsVisible() const { return mVisible; } + + /** + * Return whether the document and all its ancestors are visible in the sense of + * pageshow / hide. + */ + bool IsVisibleConsideringAncestors() const; + + /** + * Return true when this document is active, i.e., 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; + } + + /** + * 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. + virtual nsSMILAnimationController* GetAnimationController() = 0; + + // 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. + virtual mozilla::PendingAnimationTracker* GetPendingAnimationTracker() = 0; + + // 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. + virtual mozilla::PendingAnimationTracker* + GetOrCreatePendingAnimationTracker() = 0; + + enum SuppressionType { + eAnimationsOnly = 0x1, + + // Note that suppressing events also suppresses animation frames, so + // there's no need to split out events in its own bitmask. + eEvents = 0x3, + }; + + /** + * Prevents user initiated events from being dispatched to the document and + * subdocuments. + */ + virtual void SuppressEventHandling(SuppressionType aWhat, + uint32_t aIncrease = 1) = 0; + + /** + * Unsuppress event handling. + * @param aFireEvents If true, delayed events (focus/blur) will be fired + * asynchronously. + */ + virtual void UnsuppressEventHandlingAndFireEvents(SuppressionType aWhat, + bool aFireEvents) = 0; + + uint32_t EventHandlingSuppressed() const { return mEventsSuppressed; } + uint32_t AnimationsPaused() const { return mAnimationsPaused; } + + bool IsEventHandlingEnabled() { + return !EventHandlingSuppressed() && mScriptGlobalObject; + } + + /** + * Increment the number of external scripts being evaluated. + */ + void BeginEvaluatingExternalScript() { ++mExternalScriptsBeingEvaluated; } + + /** + * Decrement the number of external scripts being evaluated. + */ + void EndEvaluatingExternalScript() { --mExternalScriptsBeingEvaluated; } + + bool IsDNSPrefetchAllowed() const { return mAllowDNSPrefetch; } + + /** + * Returns true if this document is allowed to contain XUL element and + * use non-builtin XBL bindings. + */ + bool AllowXULXBL() { + return mAllowXULXBL == eTriTrue ? true : + mAllowXULXBL == eTriFalse ? false : + InternalAllowXULXBL(); + } + + void ForceEnableXULXBL() { + mAllowXULXBL = eTriTrue; + } + + /** + * Returns the template content owner document that owns the content of + * HTMLTemplateElement. + */ + virtual nsIDocument* GetTemplateContentsOwner() = 0; + + /** + * 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. + */ + + virtual void PreloadPictureOpened() = 0; + + virtual void PreloadPictureClosed() = 0; + + virtual void PreloadPictureImageSource(const nsAString& aSrcsetAttr, + const nsAString& aSizesAttr, + const nsAString& aTypeAttr, + const nsAString& aMediaAttr) = 0; + + /** + * 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. + */ + virtual already_AddRefed<nsIURI> + ResolvePreloadImage(nsIURI *aBaseURI, + const nsAString& aSrcAttr, + const nsAString& aSrcsetAttr, + const nsAString& aSizesAttr) = 0; + /** + * Called by nsParser to preload images. Can be removed and code moved + * to nsPreloadURIs::PreloadURIs() in file nsParser.cpp whenever the + * parser-module is linked with gklayout-module. aCrossOriginAttr should + * be a void string if the attr is not present. + */ + virtual void MaybePreLoadImage(nsIURI* uri, + const nsAString& aCrossOriginAttr, + ReferrerPolicyEnum aReferrerPolicy) = 0; + + /** + * Called by images to forget an image preload when they start doing + * the real load. + */ + virtual void ForgetImagePreload(nsIURI* aURI) = 0; + + /** + * Called by nsParser to preload style sheets. Can also be merged into the + * parser if and when the parser is merged with libgklayout. aCrossOriginAttr + * should be a void string if the attr is not present. + */ + virtual void PreloadStyle(nsIURI* aURI, const nsAString& aCharset, + const nsAString& aCrossOriginAttr, + ReferrerPolicyEnum aReferrerPolicy, + const nsAString& aIntegrity) = 0; + + /** + * Called by the chrome registry to load style sheets. Can be put + * back there if and when when that module is merged with libgklayout. + * + * This always does a synchronous load. If aIsAgentSheet is true, + * it also uses the system principal and enables unsafe rules. + * DO NOT USE FOR UNTRUSTED CONTENT. + */ + virtual nsresult LoadChromeSheetSync(nsIURI* aURI, bool aIsAgentSheet, + RefPtr<mozilla::StyleSheet>* aSheet) = 0; + + /** + * Returns true if the locale used for the document specifies a direction of + * right to left. For chrome documents, this comes from the chrome registry. + * This is used to determine the current state for the :-moz-locale-dir pseudoclass + * so once can know whether a document is expected to be rendered left-to-right + * or right-to-left. + */ + virtual bool IsDocumentRightToLeft() { return false; } + + /** + * Called by Parser for link rel=preconnect + */ + virtual void MaybePreconnect(nsIURI* uri, + mozilla::CORSMode aCORSMode) = 0; + + enum DocumentTheme { + Doc_Theme_Uninitialized, // not determined yet + Doc_Theme_None, + Doc_Theme_Neutral, + Doc_Theme_Dark, + Doc_Theme_Bright + }; + + /** + * Set the document's pending state object (as serialized using structured + * clone). + */ + void SetStateObject(nsIStructuredCloneContainer *scContainer); + + /** + * Returns Doc_Theme_None if there is no lightweight theme specified, + * Doc_Theme_Dark for a dark theme, Doc_Theme_Bright for a light theme, and + * Doc_Theme_Neutral for any other theme. This is used to determine the state + * of the pseudoclasses :-moz-lwtheme and :-moz-lwtheme-text. + */ + virtual int GetDocumentLWTheme() { return Doc_Theme_None; } + + /** + * Returns the document state. + * Document state bits have the form NS_DOCUMENT_STATE_* and are declared in + * nsIDocument.h. + */ + virtual mozilla::EventStates GetDocumentState() = 0; + + virtual nsISupports* GetCurrentContentSink() = 0; + + virtual void SetScrollToRef(nsIURI *aDocumentURI) = 0; + virtual void ScrollToRef() = 0; + virtual void ResetScrolledToRefAlready() = 0; + virtual void SetChangeScrollPosWhenScrollingToRef(bool aValue) = 0; + + /** + * This method is similar to GetElementById() from nsIDOMDocument but it + * returns a mozilla::dom::Element instead of a nsIDOMElement. + * It prevents converting nsIDOMElement to mozilla::dom::Element which is + * already converted from mozilla::dom::Element. + */ + virtual Element* GetElementById(const nsAString& aElementId) = 0; + + /** + * This method returns _all_ the elements in this document which + * have id aElementId, if there are any. Otherwise it returns null. + */ + virtual const nsTArray<Element*>* GetAllElementsForId(const nsAString& aElementId) const = 0; + + /** + * Lookup an image element using its associated ID, which is usually provided + * by |-moz-element()|. Similar to GetElementById, with the difference that + * elements set using mozSetImageElement have higher priority. + * @param aId the ID associated the element we want to lookup + * @return the element associated with |aId| + */ + virtual Element* LookupImageElement(const nsAString& aElementId) = 0; + + virtual mozilla::dom::DocumentTimeline* Timeline() = 0; + virtual mozilla::LinkedList<mozilla::dom::DocumentTimeline>& Timelines() = 0; + + virtual void GetAnimations( + nsTArray<RefPtr<mozilla::dom::Animation>>& aAnimations) = 0; + + 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(); + + virtual nsresult AddPlugin(nsIObjectLoadingContent* aPlugin) = 0; + virtual void RemovePlugin(nsIObjectLoadingContent* aPlugin) = 0; + virtual void GetPlugins(nsTArray<nsIObjectLoadingContent*>& aPlugins) = 0; + + virtual nsresult AddResponsiveContent(nsIContent* aContent) = 0; + virtual void RemoveResponsiveContent(nsIContent* aContent) = 0; + virtual void NotifyMediaFeatureValuesChanged() = 0; + + virtual nsresult GetStateObject(nsIVariant** aResult) = 0; + + virtual nsDOMNavigationTiming* GetNavigationTiming() const = 0; + + virtual nsresult SetNavigationTiming(nsDOMNavigationTiming* aTiming) = 0; + + virtual Element* FindImageMap(const nsAString& aNormalizedMapName) = 0; + + // Add aLink to the set of links that need their status resolved. + void RegisterPendingLinkUpdate(mozilla::dom::Link* aLink); + + // Remove aLink from the set of links that need their status resolved. + // This function must be called when links are removed from the document. + void UnregisterPendingLinkUpdate(mozilla::dom::Link* aElement); + + // Update state on links in mLinksToUpdate. This function must + // be called prior to selector matching. + void FlushPendingLinkUpdates(); + +#define DEPRECATED_OPERATION(_op) e##_op, + enum DeprecatedOperations { +#include "nsDeprecatedOperationList.h" + eDeprecatedOperationCount + }; +#undef DEPRECATED_OPERATION + bool HasWarnedAbout(DeprecatedOperations aOperation) const; + void WarnOnceAbout(DeprecatedOperations aOperation, + bool asError = false) const; + +#define DOCUMENT_WARNING(_op) e##_op, + enum DocumentWarnings { +#include "nsDocumentWarningList.h" + eDocumentWarningCount + }; +#undef DOCUMENT_WARNING + bool HasWarnedAbout(DocumentWarnings aWarning) const; + void WarnOnceAbout(DocumentWarnings aWarning, + bool asError = false, + const char16_t **aParams = nullptr, + uint32_t aParamsLength = 0) const; + + virtual void PostVisibilityUpdateEvent() = 0; + + bool IsSyntheticDocument() const { return mIsSyntheticDocument; } + + void SetNeedLayoutFlush() { + mNeedLayoutFlush = true; + if (mDisplayDocument) { + mDisplayDocument->SetNeedLayoutFlush(); + } + } + + void SetNeedStyleFlush() { + mNeedStyleFlush = true; + if (mDisplayDocument) { + mDisplayDocument->SetNeedStyleFlush(); + } + } + + // Note: nsIDocument is a sub-class of nsINode, which has a + // SizeOfExcludingThis function. However, because nsIDocument objects can + // only appear at the top of the DOM tree, we have a specialized measurement + // function which returns multiple sizes. + virtual void DocAddSizeOfExcludingThis(nsWindowSizes* aWindowSizes) const; + // DocAddSizeOfIncludingThis doesn't need to be overridden by sub-classes + // because nsIDocument inherits from nsINode; see the comment above the + // declaration of nsINode::SizeOfIncludingThis. + virtual void DocAddSizeOfIncludingThis(nsWindowSizes* aWindowSizes) const; + + bool MayHaveDOMMutationObservers() + { + return mMayHaveDOMMutationObservers; + } + + void SetMayHaveDOMMutationObservers() + { + mMayHaveDOMMutationObservers = true; + } + + bool MayHaveAnimationObservers() + { + return mMayHaveAnimationObservers; + } + + void SetMayHaveAnimationObservers() + { + mMayHaveAnimationObservers = true; + } + + bool IsInSyncOperation() + { + return mInSyncOperationCount != 0; + } + + void SetIsInSyncOperation(bool aSync) + { + if (aSync) { + ++mInSyncOperationCount; + } else { + --mInSyncOperationCount; + } + } + + bool CreatingStaticClone() const + { + return mCreatingStaticClone; + } + + /** + * Creates a new element in the HTML namespace with a local name given by + * aTag. + */ + already_AddRefed<Element> CreateHTMLElement(nsIAtom* aTag); + + // WebIDL API + nsIGlobalObject* GetParentObject() const + { + return GetScopeObject(); + } + static already_AddRefed<nsIDocument> + Constructor(const GlobalObject& aGlobal, + mozilla::ErrorResult& rv); + virtual mozilla::dom::DOMImplementation* + GetImplementation(mozilla::ErrorResult& rv) = 0; + 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::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 { + eCreated, + eAttached, + eDetached, + eAttributeChanged + }; + + nsIDocument* GetTopLevelContentDocument(); + + virtual void + RegisterElement(JSContext* aCx, const nsAString& aName, + const mozilla::dom::ElementRegistrationOptions& aOptions, + JS::MutableHandle<JSObject*> aRetval, + mozilla::ErrorResult& rv) = 0; + virtual already_AddRefed<mozilla::dom::CustomElementRegistry> + GetCustomElementRegistry() = 0; + + already_AddRefed<nsContentList> + GetElementsByTagName(const nsAString& aTagName) + { + return NS_GetContentList(this, kNameSpaceID_Unknown, aTagName); + } + already_AddRefed<nsContentList> + GetElementsByTagNameNS(const nsAString& aNamespaceURI, + const nsAString& aLocalName, + mozilla::ErrorResult& aResult); + already_AddRefed<nsContentList> + GetElementsByClassName(const nsAString& aClasses); + // GetElementById defined above + virtual already_AddRefed<Element> + CreateElement(const nsAString& aTagName, + const mozilla::dom::ElementCreationOptionsOrString& aOptions, + mozilla::ErrorResult& rv) = 0; + virtual already_AddRefed<Element> + CreateElementNS(const nsAString& aNamespaceURI, + const nsAString& aQualifiedName, + const mozilla::dom::ElementCreationOptionsOrString& aOptions, + mozilla::ErrorResult& rv) = 0; + already_AddRefed<mozilla::dom::DocumentFragment> + CreateDocumentFragment() const; + already_AddRefed<nsTextNode> CreateTextNode(const nsAString& aData) const; + already_AddRefed<mozilla::dom::Comment> + CreateComment(const nsAString& aData) const; + already_AddRefed<mozilla::dom::ProcessingInstruction> + CreateProcessingInstruction(const nsAString& target, const nsAString& data, + mozilla::ErrorResult& rv) const; + already_AddRefed<nsINode> + ImportNode(nsINode& aNode, bool aDeep, mozilla::ErrorResult& rv) const; + nsINode* AdoptNode(nsINode& aNode, mozilla::ErrorResult& rv); + already_AddRefed<mozilla::dom::Event> + CreateEvent(const nsAString& aEventType, mozilla::ErrorResult& rv) const; + already_AddRefed<nsRange> CreateRange(mozilla::ErrorResult& rv); + already_AddRefed<mozilla::dom::NodeIterator> + CreateNodeIterator(nsINode& aRoot, uint32_t aWhatToShow, + mozilla::dom::NodeFilter* aFilter, + mozilla::ErrorResult& rv) const; + already_AddRefed<mozilla::dom::NodeIterator> + CreateNodeIterator(nsINode& aRoot, uint32_t aWhatToShow, + mozilla::dom::NodeFilterHolder aFilter, + mozilla::ErrorResult& rv) const; + already_AddRefed<mozilla::dom::TreeWalker> + CreateTreeWalker(nsINode& aRoot, uint32_t aWhatToShow, + mozilla::dom::NodeFilter* aFilter, mozilla::ErrorResult& rv) const; + already_AddRefed<mozilla::dom::TreeWalker> + CreateTreeWalker(nsINode& aRoot, uint32_t aWhatToShow, + mozilla::dom::NodeFilterHolder aFilter, + mozilla::ErrorResult& rv) const; + + // Deprecated WebIDL bits + already_AddRefed<mozilla::dom::CDATASection> + CreateCDATASection(const nsAString& aData, mozilla::ErrorResult& rv); + already_AddRefed<mozilla::dom::Attr> + CreateAttribute(const nsAString& aName, mozilla::ErrorResult& rv); + already_AddRefed<mozilla::dom::Attr> + CreateAttributeNS(const nsAString& aNamespaceURI, + const nsAString& aQualifiedName, + mozilla::ErrorResult& rv); + void GetInputEncoding(nsAString& aInputEncoding) const; + already_AddRefed<mozilla::dom::Location> GetLocation() const; + void GetReferrer(nsAString& aReferrer) const; + void GetLastModified(nsAString& aLastModified) const; + void GetReadyState(nsAString& aReadyState) const; + // Not const because otherwise the compiler can't figure out whether to call + // this GetTitle or the nsAString version from non-const methods, since + // neither is an exact match. + virtual void GetTitle(nsString& aTitle) = 0; + virtual void SetTitle(const nsAString& aTitle, mozilla::ErrorResult& rv) = 0; + void GetDir(nsAString& aDirection) const; + void SetDir(const nsAString& aDirection); + nsPIDOMWindowOuter* GetDefaultView() const + { + return GetWindow(); + } + Element* GetActiveElement(); + bool HasFocus(mozilla::ErrorResult& rv) const; + // Event handlers are all on nsINode already + bool MozSyntheticDocument() const + { + return IsSyntheticDocument(); + } + Element* GetCurrentScript(); + void ReleaseCapture() const; + virtual void MozSetImageElement(const nsAString& aImageElementId, + Element* aElement) = 0; + nsIURI* GetDocumentURIObject() const; + // Not const because all the full-screen goop is not const + virtual bool FullscreenEnabled() = 0; + virtual Element* GetFullscreenElement() = 0; + bool Fullscreen() + { + return !!GetFullscreenElement(); + } + void ExitFullscreen(); + Element* GetPointerLockElement(); + void ExitPointerLock() + { + UnlockPointer(this); + } +#ifdef MOZILLA_INTERNAL_API + bool Hidden() const + { + return mVisibilityState != mozilla::dom::VisibilityState::Visible; + } + mozilla::dom::VisibilityState VisibilityState() const + { + return mVisibilityState; + } +#endif + virtual mozilla::dom::StyleSheetList* StyleSheets() = 0; + void GetSelectedStyleSheetSet(nsAString& aSheetSet); + virtual void SetSelectedStyleSheetSet(const nsAString& aSheetSet) = 0; + virtual void GetLastStyleSheetSet(nsString& aSheetSet) = 0; + void GetPreferredStyleSheetSet(nsAString& aSheetSet); + virtual mozilla::dom::DOMStringList* StyleSheetSets() = 0; + virtual void EnableStyleSheetsForSet(const nsAString& aSheetSet) = 0; + Element* ElementFromPoint(float aX, float aY); + void ElementsFromPoint(float aX, + float aY, + nsTArray<RefPtr<mozilla::dom::Element>>& aElements); + + /** + * Retrieve the location of the caret position (DOM node and character + * offset within that node), given a point. + * + * @param aX Horizontal point at which to determine the caret position, in + * page coordinates. + * @param aY Vertical point at which to determine the caret position, in + * page coordinates. + */ + already_AddRefed<nsDOMCaretPosition> + CaretPositionFromPoint(float aX, float aY); + + Element* GetScrollingElement(); + + // 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); + void LoadBindingDocument(const nsAString& aURI, + const mozilla::Maybe<nsIPrincipal*>& aSubjectPrincipal, + mozilla::ErrorResult& rv); + mozilla::dom::XPathExpression* + CreateExpression(const nsAString& aExpression, + mozilla::dom::XPathNSResolver* aResolver, + mozilla::ErrorResult& rv); + nsINode* CreateNSResolver(nsINode& aNodeResolver); + already_AddRefed<mozilla::dom::XPathResult> + 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 + already_AddRefed<mozilla::dom::Touch> + CreateTouch(nsGlobalWindow* aView, mozilla::dom::EventTarget* aTarget, + int32_t aIdentifier, int32_t aPageX, int32_t aPageY, + int32_t aScreenX, int32_t aScreenY, int32_t aClientX, + int32_t aClientY, int32_t aRadiusX, int32_t aRadiusY, + float aRotationAngle, float aForce); + already_AddRefed<mozilla::dom::TouchList> CreateTouchList(); + already_AddRefed<mozilla::dom::TouchList> + CreateTouchList(mozilla::dom::Touch& aTouch, + const mozilla::dom::Sequence<mozilla::OwningNonNull<mozilla::dom::Touch> >& aTouches); + already_AddRefed<mozilla::dom::TouchList> + 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<nsIURI> GetMozDocumentURIIfNotForErrorPages(); + + // ParentNode + nsIHTMLCollection* Children(); + uint32_t ChildElementCount(); + + virtual nsHTMLDocument* AsHTMLDocument() { return nullptr; } + virtual mozilla::dom::SVGDocument* AsSVGDocument() { return nullptr; } + + // The root document of the import tree. If this document is not an import + // this will return the document itself. + virtual nsIDocument* MasterDocument() = 0; + virtual void SetMasterDocument(nsIDocument* master) = 0; + virtual bool IsMasterDocument() = 0; + virtual mozilla::dom::ImportManager* ImportManager() = 0; + // We keep track of the order of sub imports were added to the document. + virtual bool HasSubImportLink(nsINode* aLink) = 0; + virtual uint32_t IndexOfSubImportLink(nsINode* aLink) = 0; + virtual void AddSubImportLink(nsINode* aLink) = 0; + virtual nsINode* GetSubImportLink(uint32_t aIdx) = 0; + + /* + * 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) { + return; + } + + nsWeakPtr weakNode = do_GetWeakReference(node); + + if (weakNode) { + mBlockedTrackingNodes.AppendElement(weakNode); + } + } + + gfxUserFontSet* GetUserFontSet(bool aFlushUserFontSet = true); + void FlushUserFontSet(); + void RebuildUserFontSet(); // asynchronously + mozilla::dom::FontFaceSet* GetFonts() { return mFontFaceSet; } + + // FontFaceSource + mozilla::dom::FontFaceSet* Fonts(); + + bool DidFireDOMContentLoaded() const { return mDidFireDOMContentLoaded; } + + void SetDocumentUseCounter(mozilla::UseCounter aUseCounter) + { + if (!mUseCounters[aUseCounter]) { + mUseCounters[aUseCounter] = true; + } + } + + void SetPageUseCounter(mozilla::UseCounter aUseCounter); + + void SetDocumentAndPageUseCounter(mozilla::UseCounter aUseCounter) + { + SetDocumentUseCounter(aUseCounter); + SetPageUseCounter(aUseCounter); + } + + void PropagateUseCounters(nsIDocument* aParentDocument); + + void SetUserHasInteracted(bool aUserHasInteracted) + { + mUserHasInteracted = aUserHasInteracted; + } + + bool UserHasInteracted() + { + return mUserHasInteracted; + } + + bool HasScriptsBlockedBySandbox(); + + bool InlineScriptAllowedByCSP(); + + void ReportHasScrollLinkedEffect(); + bool HasScrollLinkedEffect() const + { + return mHasScrollLinkedEffect; + } + + mozilla::dom::DocGroup* GetDocGroup(); + + virtual void AddIntersectionObserver( + mozilla::dom::DOMIntersectionObserver* aObserver) = 0; + virtual void RemoveIntersectionObserver( + mozilla::dom::DOMIntersectionObserver* aObserver) = 0; + + virtual void UpdateIntersectionObservations() = 0; + virtual void ScheduleIntersectionObserverNotification() = 0; + virtual void NotifyIntersectionObservers() = 0; + +protected: + 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]; + } + +private: + mutable std::bitset<eDeprecatedOperationCount> mDeprecationWarnedAbout; + mutable std::bitset<eDocumentWarningCount> mDocWarningWarnedAbout; + SelectorCache mSelectorCache; + +protected: + ~nsIDocument(); + nsPropertyTable* GetExtraPropertyTable(uint16_t aCategory); + + // Never ever call this. Only call GetWindow! + virtual nsPIDOMWindowOuter* GetWindowInternal() const = 0; + + // Never ever call this. Only call GetScriptHandlingObject! + virtual nsIScriptGlobalObject* GetScriptHandlingObjectInternal() const = 0; + + // Never ever call this. Only call AllowXULXBL! + virtual bool InternalAllowXULXBL() = 0; + + /** + * These methods should be called before and after dispatching + * a mutation event. + * To make this easy and painless, use the mozAutoSubtreeModified helper class. + */ + virtual void WillDispatchMutationEvent(nsINode* aTarget) = 0; + virtual void MutationEventDispatched(nsINode* aTarget) = 0; + friend class mozAutoSubtreeModified; + + virtual Element* GetNameSpaceElement() override + { + return GetRootElement(); + } + + void SetContentTypeInternal(const nsACString& aType); + + nsCString GetContentTypeInternal() const + { + return mContentType; + } + + mozilla::dom::XPathEvaluator* XPathEvaluator(); + + void HandleRebuildUserFontSet() { + mPostedFlushUserFontSet = false; + FlushUserFontSet(); + } + + const nsString& GetId() const + { + return mId; + } + + // 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); + + nsCString mReferrer; + nsString mLastModified; + + nsCOMPtr<nsIURI> mDocumentURI; + nsCOMPtr<nsIURI> mOriginalURI; + nsCOMPtr<nsIURI> mChromeXHRDocURI; + nsCOMPtr<nsIURI> mDocumentBaseURI; + nsCOMPtr<nsIURI> mChromeXHRDocBaseURI; + + nsWeakPtr mDocumentLoadGroup; + + bool mReferrerPolicySet; + ReferrerPolicyEnum mReferrerPolicy; + + bool mBlockAllMixedContent; + bool mBlockAllMixedContentPreloads; + bool mUpgradeInsecureRequests; + bool mUpgradeInsecurePreloads; + + // if nsMixedContentBlocker requires sending an HSTS priming request, + // temporarily store that in the document so that it can be propogated to the + // LoadInfo and eventually the HTTP Channel + nsDataHashtable<nsURIHashKey, HSTSPrimingState> mHSTSPrimingURIList; + + mozilla::WeakPtr<nsDocShell> mDocumentContainer; + + nsCString mCharacterSet; + int32_t mCharacterSetSource; + + // This is just a weak pointer; the parent document owns its children. + nsIDocument* mParentDocument; + + // A reference to the element last returned from GetRootElement(). + mozilla::dom::Element* mCachedRootElement; + + // This is a weak reference, but we hold a strong reference to mNodeInfo, + // which in turn holds a strong reference to this mNodeInfoManager. + nsNodeInfoManager* mNodeInfoManager; + RefPtr<mozilla::css::Loader> mCSSLoader; + RefPtr<mozilla::css::ImageLoader> mStyleImageLoader; + RefPtr<nsHTMLStyleSheet> mAttrStyleSheet; + RefPtr<nsHTMLCSSStyleSheet> mStyleAttrStyleSheet; + RefPtr<mozilla::SVGAttrAnimationRuleProcessor> mSVGAttrAnimationRuleProcessor; + + // Tracking for images in the document. + RefPtr<mozilla::dom::ImageTracker> mImageTracker; + + // The set of all object, embed, applet, 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; + + // The set of all links that need their status resolved. Links must add themselves + // to this set by calling RegisterPendingLinkUpdate when added to a document and must + // remove themselves by calling UnregisterPendingLinkUpdate when removed from a document. + nsTHashtable<nsPtrHashKey<mozilla::dom::Link> > mLinksToUpdate; + + // SMIL Animation Controller, lazily-initialized in GetAnimationController + RefPtr<nsSMILAnimationController> mAnimationController; + + // Table of element properties for this document. + nsPropertyTable mPropertyTable; + nsTArray<nsAutoPtr<nsPropertyTable> > mExtraPropertyTables; + + // Our cached .children collection + nsCOMPtr<nsIHTMLCollection> mChildrenCollection; + + // container for per-context fonts (downloadable, SVG, etc.) + RefPtr<mozilla::dom::FontFaceSet> mFontFaceSet; + + // Compatibility mode + nsCompatibility mCompatMode; + + // Our readyState + ReadyState mReadyState; + +#ifdef MOZILLA_INTERNAL_API + // Our visibility state + mozilla::dom::VisibilityState mVisibilityState; + static_assert(sizeof(mozilla::dom::VisibilityState) == sizeof(uint32_t), "Error size of mVisibilityState and mDummy"); +#else + uint32_t mDummy; +#endif + + // Whether this document has (or will have, once we have a pres shell) a + // Gecko- or Servo-backed style system. + mozilla::StyleBackendType mStyleBackendType; + + // 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; + + // 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 if this document has links whose state needs updating + bool mHasLinksToUpdate : 1; + + // True if a layout flush might not be a no-op + bool mNeedLayoutFlush : 1; + + // True if a style flush might not be a no-op + bool mNeedStyleFlush : 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 document.open. 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; + + // Do we currently have an event posted to call FlushUserFontSet? + bool mPostedFlushUserFontSet : 1; + + // True is document has ever been in a foreground window. + bool mEverInForeground : 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; + + enum Type { + eUnknown, // should never be used + eHTML, + eXHTML, + eGenericXML, + eSVG, + eXUL + }; + + Type mType; + + uint8_t mDefaultElementType; + + enum Tri { + eTriUnset = 0, + eTriFalse, + eTriTrue + }; + + Tri mAllowXULXBL; + +#ifdef DEBUG + /** + * This is true while FlushPendingLinkUpdates executes. Calls to + * [Un]RegisterPendingLinkUpdate will assert when this is true. + */ + bool mIsLinkUpdateRegistrationsForbidden; +#endif + + // The document's script global object, the object from which the + // document can get its script context and scope. This is the + // *inner* window object. + nsCOMPtr<nsIScriptGlobalObject> mScriptGlobalObject; + + // If mIsStaticDocument is true, mOriginalDocument points to the original + // document. + nsCOMPtr<nsIDocument> mOriginalDocument; + + // The bidi options for this document. What this bitfield means is + // defined in nsBidiUtils.h + uint32_t mBidiOptions; + + // The sandbox flags on the document. These reflect the value of the sandbox attribute of the + // associated IFRAME or CSP-protectable content, if existent. These are set at load time and + // are immutable - see nsSandboxFlags.h for the possible flags. + uint32_t mSandboxFlags; + + nsCString mContentLanguage; + + // The channel that got passed to nsDocument::StartDocumentLoad(), if any. + nsCOMPtr<nsIChannel> mChannel; +private: + nsCString mContentType; + nsString mId; +protected: + + // 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; + + // If we're an external resource document, this will be non-null and will + // point to our "display document": the one that all resource lookups should + // go to. + nsCOMPtr<nsIDocument> mDisplayDocument; + + uint32_t mEventsSuppressed; + + uint32_t mAnimationsPaused; + + /** + * The number number of external scripts (ones with the src attribute) that + * have this document as their owner and that are being evaluated right now. + */ + uint32_t mExternalScriptsBeingEvaluated; + + /** + * The current frame request callback handle + */ + int32_t mFrameRequestCallbackCounter; + + // 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; + + RefPtr<mozilla::dom::XPathEvaluator> mXPathEvaluator; + + nsTArray<RefPtr<mozilla::dom::AnonymousContent>> mAnonymousContents; + + uint32_t mBlockDOMContentLoaded; + + // Our live MediaQueryLists + PRCList mDOMMediaQueryLists; + + // 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; + + mozilla::TimeStamp mPageUnloadingEventTimeStamp; + + RefPtr<mozilla::dom::DocGroup> mDocGroup; +}; + +NS_DEFINE_STATIC_IID_ACCESSOR(nsIDocument, NS_IDOCUMENT_IID) + +/** + * mozAutoSubtreeModified batches DOM mutations so that a DOMSubtreeModified + * event is dispatched, if necessary, when the outermost mozAutoSubtreeModified + * object is deleted. + */ +class MOZ_STACK_CLASS mozAutoSubtreeModified +{ +public: + /** + * @param aSubTreeOwner The document in which a subtree will be modified. + * @param aTarget The target of the possible DOMSubtreeModified event. + * Can be nullptr, in which case mozAutoSubtreeModified + * is just used to batch DOM mutations. + */ + mozAutoSubtreeModified(nsIDocument* aSubtreeOwner, nsINode* aTarget) + { + UpdateTarget(aSubtreeOwner, aTarget); + } + + ~mozAutoSubtreeModified() + { + UpdateTarget(nullptr, nullptr); + } + + void UpdateTarget(nsIDocument* aSubtreeOwner, nsINode* aTarget) + { + if (mSubtreeOwner) { + mSubtreeOwner->MutationEventDispatched(mTarget); + } + + mTarget = aTarget; + mSubtreeOwner = aSubtreeOwner; + if (mSubtreeOwner) { + mSubtreeOwner->WillDispatchMutationEvent(mTarget); + } + } + +private: + nsCOMPtr<nsINode> mTarget; + nsCOMPtr<nsIDocument> mSubtreeOwner; +}; + +class MOZ_STACK_CLASS nsAutoSyncOperation +{ +public: + explicit nsAutoSyncOperation(nsIDocument* aDocument); + ~nsAutoSyncOperation(); +private: + nsCOMArray<nsIDocument> mDocuments; + uint32_t mMicroTaskLevel; +}; + +// XXX These belong somewhere else +nsresult +NS_NewHTMLDocument(nsIDocument** aInstancePtrResult, bool aLoadedAsData = false); + +nsresult +NS_NewXMLDocument(nsIDocument** aInstancePtrResult, bool aLoadedAsData = false, + bool aIsPlainDocument = false); + +nsresult +NS_NewSVGDocument(nsIDocument** aInstancePtrResult); + +nsresult +NS_NewImageDocument(nsIDocument** aInstancePtrResult); + +nsresult +NS_NewVideoDocument(nsIDocument** aInstancePtrResult); + +// Note: it's the caller's responsibility to create or get aPrincipal as needed +// -- this method will not attempt to get a principal based on aDocumentURI. +// Also, both aDocumentURI and aBaseURI must not be null. +nsresult +NS_NewDOMDocument(nsIDOMDocument** aInstancePtrResult, + const nsAString& aNamespaceURI, + const nsAString& aQualifiedName, + nsIDOMDocumentType* aDoctype, + 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. +nsresult +NS_NewXBLDocument(nsIDOMDocument** aInstancePtrResult, + nsIURI* aDocumentURI, + nsIURI* aBaseURI, + nsIPrincipal* aPrincipal); + +nsresult +NS_NewPluginDocument(nsIDocument** aInstancePtrResult); + +inline nsIDocument* +nsINode::GetOwnerDocument() const +{ + nsIDocument* ownerDoc = OwnerDoc(); + + return ownerDoc != this ? ownerDoc : nullptr; +} + +inline nsINode* +nsINode::OwnerDocAsNode() const +{ + return OwnerDoc(); +} + +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 = IsInAnonymousSubtree() && !IsAnonymousContentInSVGUseSubtree(); + return p; +} + +#endif /* nsIDocument_h___ */ |