michael@0: /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
michael@0: /* vim: set ts=2 sw=2 et tw=80: */
michael@0: /* This Source Code Form is subject to the terms of the Mozilla Public
michael@0:  * License, v. 2.0. If a copy of the MPL was not distributed with this
michael@0:  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
michael@0: 
michael@0: /*
michael@0:  * Base class for all our document implementations.
michael@0:  */
michael@0: 
michael@0: #ifndef nsDocument_h___
michael@0: #define nsDocument_h___
michael@0: 
michael@0: #include "nsIDocument.h"
michael@0: 
michael@0: #include "nsCOMPtr.h"
michael@0: #include "nsAutoPtr.h"
michael@0: #include "nsCRT.h"
michael@0: #include "nsWeakReference.h"
michael@0: #include "nsWeakPtr.h"
michael@0: #include "nsVoidArray.h"
michael@0: #include "nsTArray.h"
michael@0: #include "nsIDOMXMLDocument.h"
michael@0: #include "nsIDOMDocumentXBL.h"
michael@0: #include "nsStubDocumentObserver.h"
michael@0: #include "nsIScriptGlobalObject.h"
michael@0: #include "nsIContent.h"
michael@0: #include "nsIPrincipal.h"
michael@0: #include "nsIParser.h"
michael@0: #include "nsBindingManager.h"
michael@0: #include "nsINodeInfo.h"
michael@0: #include "nsInterfaceHashtable.h"
michael@0: #include "nsJSThingHashtable.h"
michael@0: #include "nsIBoxObject.h"
michael@0: #include "nsPIBoxObject.h"
michael@0: #include "nsIScriptObjectPrincipal.h"
michael@0: #include "nsIURI.h"
michael@0: #include "nsScriptLoader.h"
michael@0: #include "nsIRadioGroupContainer.h"
michael@0: #include "nsILayoutHistoryState.h"
michael@0: #include "nsIRequest.h"
michael@0: #include "nsILoadGroup.h"
michael@0: #include "nsTObserverArray.h"
michael@0: #include "nsStubMutationObserver.h"
michael@0: #include "nsIChannel.h"
michael@0: #include "nsCycleCollectionParticipant.h"
michael@0: #include "nsContentList.h"
michael@0: #include "nsGkAtoms.h"
michael@0: #include "nsIApplicationCache.h"
michael@0: #include "nsIApplicationCacheContainer.h"
michael@0: #include "nsStyleSet.h"
michael@0: #include "pldhash.h"
michael@0: #include "nsAttrAndChildArray.h"
michael@0: #include "nsDOMAttributeMap.h"
michael@0: #include "nsIContentViewer.h"
michael@0: #include "nsIDOMXPathNSResolver.h"
michael@0: #include "nsIInterfaceRequestor.h"
michael@0: #include "nsILoadContext.h"
michael@0: #include "nsIProgressEventSink.h"
michael@0: #include "nsISecurityEventSink.h"
michael@0: #include "nsIChannelEventSink.h"
michael@0: #include "imgIRequest.h"
michael@0: #include "mozilla/EventListenerManager.h"
michael@0: #include "mozilla/EventStates.h"
michael@0: #include "mozilla/MemoryReporting.h"
michael@0: #include "mozilla/dom/DOMImplementation.h"
michael@0: #include "mozilla/dom/StyleSheetList.h"
michael@0: #include "nsIDOMTouchEvent.h"
michael@0: #include "nsDataHashtable.h"
michael@0: #include "mozilla/TimeStamp.h"
michael@0: #include "mozilla/Attributes.h"
michael@0: #include "nsIDOMXPathEvaluator.h"
michael@0: #include "jsfriendapi.h"
michael@0: 
michael@0: #define XML_DECLARATION_BITS_DECLARATION_EXISTS   (1 << 0)
michael@0: #define XML_DECLARATION_BITS_ENCODING_EXISTS      (1 << 1)
michael@0: #define XML_DECLARATION_BITS_STANDALONE_EXISTS    (1 << 2)
michael@0: #define XML_DECLARATION_BITS_STANDALONE_YES       (1 << 3)
michael@0: 
michael@0: 
michael@0: class nsDOMStyleSheetSetList;
michael@0: class nsIOutputStream;
michael@0: class nsDocument;
michael@0: class nsIDTD;
michael@0: class nsIRadioVisitor;
michael@0: class nsIFormControl;
michael@0: struct nsRadioGroupStruct;
michael@0: class nsOnloadBlocker;
michael@0: class nsUnblockOnloadEvent;
michael@0: class nsChildContentList;
michael@0: class nsHTMLStyleSheet;
michael@0: class nsHTMLCSSStyleSheet;
michael@0: class nsDOMNavigationTiming;
michael@0: class nsWindowSizes;
michael@0: class nsHtml5TreeOpExecutor;
michael@0: class nsDocumentOnStack;
michael@0: class nsPointerLockPermissionRequest;
michael@0: class nsISecurityConsoleMessage;
michael@0: 
michael@0: namespace mozilla {
michael@0: class EventChainPreVisitor;
michael@0: namespace dom {
michael@0: class UndoManager;
michael@0: class LifecycleCallbacks;
michael@0: class CallbackFunction;
michael@0: }
michael@0: }
michael@0: 
michael@0: /**
michael@0:  * Right now our identifier map entries contain information for 'name'
michael@0:  * and 'id' mappings of a given string. This is so that
michael@0:  * nsHTMLDocument::ResolveName only has to do one hash lookup instead
michael@0:  * of two. It's not clear whether this still matters for performance.
michael@0:  * 
michael@0:  * We also store the document.all result list here. This is mainly so that
michael@0:  * when all elements with the given ID are removed and we remove
michael@0:  * the ID's nsIdentifierMapEntry, the document.all result is released too.
michael@0:  * Perhaps the document.all results should have their own hashtable
michael@0:  * in nsHTMLDocument.
michael@0:  */
michael@0: class nsIdentifierMapEntry : public nsStringHashKey
michael@0: {
michael@0: public:
michael@0:   typedef mozilla::dom::Element Element;
michael@0:   
michael@0:   nsIdentifierMapEntry(const nsAString& aKey) :
michael@0:     nsStringHashKey(&aKey), mNameContentList(nullptr)
michael@0:   {
michael@0:   }
michael@0:   nsIdentifierMapEntry(const nsAString *aKey) :
michael@0:     nsStringHashKey(aKey), mNameContentList(nullptr)
michael@0:   {
michael@0:   }
michael@0:   nsIdentifierMapEntry(const nsIdentifierMapEntry& aOther) :
michael@0:     nsStringHashKey(&aOther.GetKey())
michael@0:   {
michael@0:     NS_ERROR("Should never be called");
michael@0:   }
michael@0:   ~nsIdentifierMapEntry();
michael@0: 
michael@0:   void AddNameElement(nsINode* aDocument, Element* aElement);
michael@0:   void RemoveNameElement(Element* aElement);
michael@0:   bool IsEmpty();
michael@0:   nsBaseContentList* GetNameContentList() {
michael@0:     return mNameContentList;
michael@0:   }
michael@0:   bool HasNameElement() const {
michael@0:     return mNameContentList && mNameContentList->Length() != 0;
michael@0:   }
michael@0: 
michael@0:   /**
michael@0:    * Returns the element if we know the element associated with this
michael@0:    * id. Otherwise returns null.
michael@0:    */
michael@0:   Element* GetIdElement();
michael@0:   /**
michael@0:    * Returns the list of all elements associated with this id.
michael@0:    */
michael@0:   const nsSmallVoidArray* GetIdElements() const {
michael@0:     return &mIdContentList;
michael@0:   }
michael@0:   /**
michael@0:    * If this entry has a non-null image element set (using SetImageElement),
michael@0:    * the image element will be returned, otherwise the same as GetIdElement().
michael@0:    */
michael@0:   Element* GetImageIdElement();
michael@0:   /**
michael@0:    * Append all the elements with this id to aElements
michael@0:    */
michael@0:   void AppendAllIdContent(nsCOMArray<nsIContent>* aElements);
michael@0:   /**
michael@0:    * This can fire ID change callbacks.
michael@0:    * @return true if the content could be added, false if we failed due
michael@0:    * to OOM.
michael@0:    */
michael@0:   bool AddIdElement(Element* aElement);
michael@0:   /**
michael@0:    * This can fire ID change callbacks.
michael@0:    */
michael@0:   void RemoveIdElement(Element* aElement);
michael@0:   /**
michael@0:    * Set the image element override for this ID. This will be returned by
michael@0:    * GetIdElement(true) if non-null.
michael@0:    */
michael@0:   void SetImageElement(Element* aElement);
michael@0:   bool HasIdElementExposedAsHTMLDocumentProperty();
michael@0: 
michael@0:   bool HasContentChangeCallback() { return mChangeCallbacks != nullptr; }
michael@0:   void AddContentChangeCallback(nsIDocument::IDTargetObserver aCallback,
michael@0:                                 void* aData, bool aForImage);
michael@0:   void RemoveContentChangeCallback(nsIDocument::IDTargetObserver aCallback,
michael@0:                                 void* aData, bool aForImage);
michael@0: 
michael@0:   void Traverse(nsCycleCollectionTraversalCallback* aCallback);
michael@0: 
michael@0:   struct ChangeCallback {
michael@0:     nsIDocument::IDTargetObserver mCallback;
michael@0:     void* mData;
michael@0:     bool mForImage;
michael@0:   };
michael@0: 
michael@0:   struct ChangeCallbackEntry : public PLDHashEntryHdr {
michael@0:     typedef const ChangeCallback KeyType;
michael@0:     typedef const ChangeCallback* KeyTypePointer;
michael@0: 
michael@0:     ChangeCallbackEntry(const ChangeCallback* key) :
michael@0:       mKey(*key) { }
michael@0:     ChangeCallbackEntry(const ChangeCallbackEntry& toCopy) :
michael@0:       mKey(toCopy.mKey) { }
michael@0: 
michael@0:     KeyType GetKey() const { return mKey; }
michael@0:     bool KeyEquals(KeyTypePointer aKey) const {
michael@0:       return aKey->mCallback == mKey.mCallback &&
michael@0:              aKey->mData == mKey.mData &&
michael@0:              aKey->mForImage == mKey.mForImage;
michael@0:     }
michael@0: 
michael@0:     static KeyTypePointer KeyToPointer(KeyType& aKey) { return &aKey; }
michael@0:     static PLDHashNumber HashKey(KeyTypePointer aKey)
michael@0:     {
michael@0:       return mozilla::HashGeneric(aKey->mCallback, aKey->mData);
michael@0:     }
michael@0:     enum { ALLOW_MEMMOVE = true };
michael@0:     
michael@0:     ChangeCallback mKey;
michael@0:   };
michael@0: 
michael@0:   static size_t SizeOfExcludingThis(nsIdentifierMapEntry* aEntry,
michael@0:                                     mozilla::MallocSizeOf aMallocSizeOf,
michael@0:                                     void* aArg);
michael@0: 
michael@0: private:
michael@0:   void FireChangeCallbacks(Element* aOldElement, Element* aNewElement,
michael@0:                            bool aImageOnly = false);
michael@0: 
michael@0:   // empty if there are no elements with this ID.
michael@0:   // The elements are stored as weak pointers.
michael@0:   nsSmallVoidArray mIdContentList;
michael@0:   nsRefPtr<nsBaseContentList> mNameContentList;
michael@0:   nsAutoPtr<nsTHashtable<ChangeCallbackEntry> > mChangeCallbacks;
michael@0:   nsRefPtr<Element> mImageElement;
michael@0: };
michael@0: 
michael@0: namespace mozilla {
michael@0: namespace dom {
michael@0: 
michael@0: class CustomElementHashKey : public PLDHashEntryHdr
michael@0: {
michael@0: public:
michael@0:   typedef CustomElementHashKey *KeyType;
michael@0:   typedef const CustomElementHashKey *KeyTypePointer;
michael@0: 
michael@0:   CustomElementHashKey(int32_t aNamespaceID, nsIAtom *aAtom)
michael@0:     : mNamespaceID(aNamespaceID),
michael@0:       mAtom(aAtom)
michael@0:   {}
michael@0:   CustomElementHashKey(const CustomElementHashKey *aKey)
michael@0:     : mNamespaceID(aKey->mNamespaceID),
michael@0:       mAtom(aKey->mAtom)
michael@0:   {}
michael@0:   ~CustomElementHashKey()
michael@0:   {}
michael@0: 
michael@0:   KeyType GetKey() const { return const_cast<KeyType>(this); }
michael@0:   bool KeyEquals(const KeyTypePointer aKey) const
michael@0:   {
michael@0:     MOZ_ASSERT(mNamespaceID != kNameSpaceID_Unknown,
michael@0:                "This equals method is not transitive, nor symmetric. "
michael@0:                "A key with a namespace of kNamespaceID_Unknown should "
michael@0:                "not be stored in a hashtable.");
michael@0:     return (kNameSpaceID_Unknown == aKey->mNamespaceID ||
michael@0:             mNamespaceID == aKey->mNamespaceID) &&
michael@0:            aKey->mAtom == mAtom;
michael@0:   }
michael@0: 
michael@0:   static KeyTypePointer KeyToPointer(KeyType aKey) { return aKey; }
michael@0:   static PLDHashNumber HashKey(const KeyTypePointer aKey)
michael@0:   {
michael@0:     return aKey->mAtom->hash();
michael@0:   }
michael@0:   enum { ALLOW_MEMMOVE = true };
michael@0: 
michael@0: private:
michael@0:   int32_t mNamespaceID;
michael@0:   nsCOMPtr<nsIAtom> mAtom;
michael@0: };
michael@0: 
michael@0: struct LifecycleCallbackArgs
michael@0: {
michael@0:   nsString name;
michael@0:   nsString oldValue;
michael@0:   nsString newValue;
michael@0: };
michael@0: 
michael@0: struct CustomElementData;
michael@0: 
michael@0: class CustomElementCallback
michael@0: {
michael@0: public:
michael@0:   CustomElementCallback(Element* aThisObject,
michael@0:                         nsIDocument::ElementCallbackType aCallbackType,
michael@0:                         mozilla::dom::CallbackFunction* aCallback,
michael@0:                         CustomElementData* aOwnerData);
michael@0:   void Traverse(nsCycleCollectionTraversalCallback& aCb) const;
michael@0:   void Call();
michael@0:   void SetArgs(LifecycleCallbackArgs& aArgs)
michael@0:   {
michael@0:     MOZ_ASSERT(mType == nsIDocument::eAttributeChanged,
michael@0:                "Arguments are only used by attribute changed callback.");
michael@0:     mArgs = aArgs;
michael@0:   }
michael@0: 
michael@0: private:
michael@0:   // The this value to use for invocation of the callback.
michael@0:   nsRefPtr<mozilla::dom::Element> mThisObject;
michael@0:   nsRefPtr<mozilla::dom::CallbackFunction> mCallback;
michael@0:   // The type of callback (eCreated, eAttached, etc.)
michael@0:   nsIDocument::ElementCallbackType mType;
michael@0:   // Arguments to be passed to the callback,
michael@0:   // used by the attribute changed callback.
michael@0:   LifecycleCallbackArgs mArgs;
michael@0:   // CustomElementData that contains this callback in the
michael@0:   // callback queue.
michael@0:   CustomElementData* mOwnerData;
michael@0: };
michael@0: 
michael@0: // Each custom element has an associated callback queue and an element is
michael@0: // being created flag.
michael@0: struct CustomElementData
michael@0: {
michael@0:   CustomElementData(nsIAtom* aType);
michael@0:   // Objects in this array are transient and empty after each microtask
michael@0:   // checkpoint.
michael@0:   nsTArray<nsAutoPtr<CustomElementCallback>> mCallbackQueue;
michael@0:   // Custom element type, for <button is="x-button"> or <x-button>
michael@0:   // this would be x-button.
michael@0:   nsCOMPtr<nsIAtom> mType;
michael@0:   // The callback that is next to be processed upon calling RunCallbackQueue.
michael@0:   int32_t mCurrentCallback;
michael@0:   // Element is being created flag as described in the custom elements spec.
michael@0:   bool mElementIsBeingCreated;
michael@0:   // Flag to determine if the created callback has been invoked, thus it
michael@0:   // determines if other callbacks can be enqueued.
michael@0:   bool mCreatedCallbackInvoked;
michael@0:   // The microtask level associated with the callbacks in the callback queue,
michael@0:   // it is used to determine if a new queue needs to be pushed onto the
michael@0:   // processing stack.
michael@0:   int32_t mAssociatedMicroTask;
michael@0: 
michael@0:   // Empties the callback queue.
michael@0:   void RunCallbackQueue();
michael@0: };
michael@0: 
michael@0: // The required information for a custom element as defined in:
michael@0: // https://dvcs.w3.org/hg/webcomponents/raw-file/tip/spec/custom/index.html
michael@0: struct CustomElementDefinition
michael@0: {
michael@0:   CustomElementDefinition(JSObject* aPrototype,
michael@0:                           nsIAtom* aType,
michael@0:                           nsIAtom* aLocalName,
michael@0:                           mozilla::dom::LifecycleCallbacks* aCallbacks,
michael@0:                           uint32_t aNamespaceID,
michael@0:                           uint32_t aDocOrder);
michael@0: 
michael@0:   // The prototype to use for new custom elements of this type.
michael@0:   JS::Heap<JSObject *> mPrototype;
michael@0: 
michael@0:   // The type (name) for this custom element.
michael@0:   nsCOMPtr<nsIAtom> mType;
michael@0: 
michael@0:   // The localname to (e.g. <button is=type> -- this would be button).
michael@0:   nsCOMPtr<nsIAtom> mLocalName;
michael@0: 
michael@0:   // The lifecycle callbacks to call for this custom element.
michael@0:   nsAutoPtr<mozilla::dom::LifecycleCallbacks> mCallbacks;
michael@0: 
michael@0:   // Whether we're currently calling the created callback for a custom element
michael@0:   // of this type.
michael@0:   bool mElementIsBeingCreated;
michael@0: 
michael@0:   // Element namespace.
michael@0:   int32_t mNamespaceID;
michael@0: 
michael@0:   // The document custom element order.
michael@0:   uint32_t mDocOrder;
michael@0: };
michael@0: 
michael@0: class Registry : public nsISupports
michael@0: {
michael@0: public:
michael@0:   friend class ::nsDocument;
michael@0: 
michael@0:   NS_DECL_CYCLE_COLLECTING_ISUPPORTS
michael@0:   NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS(Registry)
michael@0: 
michael@0:   Registry();
michael@0:   virtual ~Registry();
michael@0: 
michael@0: protected:
michael@0:   typedef nsClassHashtable<mozilla::dom::CustomElementHashKey,
michael@0:                            mozilla::dom::CustomElementDefinition>
michael@0:     DefinitionMap;
michael@0:   typedef nsClassHashtable<mozilla::dom::CustomElementHashKey,
michael@0:                            nsTArray<nsRefPtr<mozilla::dom::Element>>>
michael@0:     CandidateMap;
michael@0: 
michael@0:   // Hashtable for custom element definitions in web components.
michael@0:   // Custom prototypes are in the document's compartment.
michael@0:   DefinitionMap mCustomDefinitions;
michael@0: 
michael@0:   // The "upgrade candidates map" from the web components spec. Maps from a
michael@0:   // namespace id and local name to a list of elements to upgrade if that
michael@0:   // element is registered as a custom element.
michael@0:   CandidateMap mCandidatesMap;
michael@0: };
michael@0: 
michael@0: } // namespace dom
michael@0: } // namespace mozilla
michael@0: 
michael@0: class nsDocHeaderData
michael@0: {
michael@0: public:
michael@0:   nsDocHeaderData(nsIAtom* aField, const nsAString& aData)
michael@0:     : mField(aField), mData(aData), mNext(nullptr)
michael@0:   {
michael@0:   }
michael@0: 
michael@0:   ~nsDocHeaderData(void)
michael@0:   {
michael@0:     delete mNext;
michael@0:   }
michael@0: 
michael@0:   nsCOMPtr<nsIAtom> mField;
michael@0:   nsString          mData;
michael@0:   nsDocHeaderData*  mNext;
michael@0: };
michael@0: 
michael@0: class nsDOMStyleSheetList : public mozilla::dom::StyleSheetList,
michael@0:                             public nsStubDocumentObserver
michael@0: {
michael@0: public:
michael@0:   nsDOMStyleSheetList(nsIDocument *aDocument);
michael@0:   virtual ~nsDOMStyleSheetList();
michael@0: 
michael@0:   NS_DECL_ISUPPORTS_INHERITED
michael@0: 
michael@0:   // nsIDocumentObserver
michael@0:   NS_DECL_NSIDOCUMENTOBSERVER_STYLESHEETADDED
michael@0:   NS_DECL_NSIDOCUMENTOBSERVER_STYLESHEETREMOVED
michael@0: 
michael@0:   // nsIMutationObserver
michael@0:   NS_DECL_NSIMUTATIONOBSERVER_NODEWILLBEDESTROYED
michael@0: 
michael@0:   virtual nsINode* GetParentObject() const MOZ_OVERRIDE
michael@0:   {
michael@0:     return mDocument;
michael@0:   }
michael@0: 
michael@0:   virtual uint32_t Length() MOZ_OVERRIDE;
michael@0:   virtual nsCSSStyleSheet* IndexedGetter(uint32_t aIndex, bool& aFound) MOZ_OVERRIDE;
michael@0: 
michael@0: protected:
michael@0:   int32_t       mLength;
michael@0:   nsIDocument*  mDocument;
michael@0: };
michael@0: 
michael@0: class nsOnloadBlocker MOZ_FINAL : public nsIRequest
michael@0: {
michael@0: public:
michael@0:   nsOnloadBlocker() {}
michael@0: 
michael@0:   NS_DECL_ISUPPORTS
michael@0:   NS_DECL_NSIREQUEST
michael@0: 
michael@0: private:
michael@0:   ~nsOnloadBlocker() {}
michael@0: };
michael@0: 
michael@0: class nsExternalResourceMap
michael@0: {
michael@0: public:
michael@0:   typedef nsIDocument::ExternalResourceLoad ExternalResourceLoad;
michael@0:   nsExternalResourceMap();
michael@0: 
michael@0:   /**
michael@0:    * Request an external resource document.  This does exactly what
michael@0:    * nsIDocument::RequestExternalResource is documented to do.
michael@0:    */
michael@0:   nsIDocument* RequestResource(nsIURI* aURI,
michael@0:                                nsINode* aRequestingNode,
michael@0:                                nsDocument* aDisplayDocument,
michael@0:                                ExternalResourceLoad** aPendingLoad);
michael@0: 
michael@0:   /**
michael@0:    * Enumerate the resource documents.  See
michael@0:    * nsIDocument::EnumerateExternalResources.
michael@0:    */
michael@0:   void EnumerateResources(nsIDocument::nsSubDocEnumFunc aCallback, void* aData);
michael@0: 
michael@0:   /**
michael@0:    * Traverse ourselves for cycle-collection
michael@0:    */
michael@0:   void Traverse(nsCycleCollectionTraversalCallback* aCallback) const;
michael@0: 
michael@0:   /**
michael@0:    * Shut ourselves down (used for cycle-collection unlink), as well
michael@0:    * as for document destruction.
michael@0:    */
michael@0:   void Shutdown()
michael@0:   {
michael@0:     mPendingLoads.Clear();
michael@0:     mMap.Clear();
michael@0:     mHaveShutDown = true;
michael@0:   }
michael@0: 
michael@0:   bool HaveShutDown() const
michael@0:   {
michael@0:     return mHaveShutDown;
michael@0:   }
michael@0: 
michael@0:   // Needs to be public so we can traverse them sanely
michael@0:   struct ExternalResource
michael@0:   {
michael@0:     ~ExternalResource();
michael@0:     nsCOMPtr<nsIDocument> mDocument;
michael@0:     nsCOMPtr<nsIContentViewer> mViewer;
michael@0:     nsCOMPtr<nsILoadGroup> mLoadGroup;
michael@0:   };
michael@0: 
michael@0:   // Hide all our viewers
michael@0:   void HideViewers();
michael@0: 
michael@0:   // Show all our viewers
michael@0:   void ShowViewers();
michael@0: 
michael@0: protected:
michael@0:   class PendingLoad : public ExternalResourceLoad,
michael@0:                       public nsIStreamListener
michael@0:   {
michael@0:   public:
michael@0:     PendingLoad(nsDocument* aDisplayDocument) :
michael@0:       mDisplayDocument(aDisplayDocument)
michael@0:     {}
michael@0: 
michael@0:     NS_DECL_ISUPPORTS
michael@0:     NS_DECL_NSISTREAMLISTENER
michael@0:     NS_DECL_NSIREQUESTOBSERVER
michael@0: 
michael@0:     /**
michael@0:      * Start aURI loading.  This will perform the necessary security checks and
michael@0:      * so forth.
michael@0:      */
michael@0:     nsresult StartLoad(nsIURI* aURI, nsINode* aRequestingNode);
michael@0: 
michael@0:     /**
michael@0:      * Set up an nsIContentViewer based on aRequest.  This is guaranteed to
michael@0:      * put null in *aViewer and *aLoadGroup on all failures.
michael@0:      */
michael@0:     nsresult SetupViewer(nsIRequest* aRequest, nsIContentViewer** aViewer,
michael@0:                          nsILoadGroup** aLoadGroup);
michael@0: 
michael@0:   private:
michael@0:     nsRefPtr<nsDocument> mDisplayDocument;
michael@0:     nsCOMPtr<nsIStreamListener> mTargetListener;
michael@0:     nsCOMPtr<nsIURI> mURI;
michael@0:   };
michael@0:   friend class PendingLoad;
michael@0: 
michael@0:   class LoadgroupCallbacks MOZ_FINAL : public nsIInterfaceRequestor
michael@0:   {
michael@0:   public:
michael@0:     LoadgroupCallbacks(nsIInterfaceRequestor* aOtherCallbacks)
michael@0:       : mCallbacks(aOtherCallbacks)
michael@0:     {}
michael@0:     NS_DECL_ISUPPORTS
michael@0:     NS_DECL_NSIINTERFACEREQUESTOR
michael@0:   private:
michael@0:     // The only reason it's safe to hold a strong ref here without leaking is
michael@0:     // that the notificationCallbacks on a loadgroup aren't the docshell itself
michael@0:     // but a shim that holds a weak reference to the docshell.
michael@0:     nsCOMPtr<nsIInterfaceRequestor> mCallbacks;
michael@0: 
michael@0:     // Use shims for interfaces that docshell implements directly so that we
michael@0:     // don't hand out references to the docshell.  The shims should all allow
michael@0:     // getInterface back on us, but other than that each one should only
michael@0:     // implement one interface.
michael@0:     
michael@0:     // XXXbz I wish we could just derive the _allcaps thing from _i
michael@0: #define DECL_SHIM(_i, _allcaps)                                              \
michael@0:     class _i##Shim MOZ_FINAL : public nsIInterfaceRequestor,                 \
michael@0:                                public _i                                     \
michael@0:     {                                                                        \
michael@0:     public:                                                                  \
michael@0:       _i##Shim(nsIInterfaceRequestor* aIfreq, _i* aRealPtr)                  \
michael@0:         : mIfReq(aIfreq), mRealPtr(aRealPtr)                                 \
michael@0:       {                                                                      \
michael@0:         NS_ASSERTION(mIfReq, "Expected non-null here");                      \
michael@0:         NS_ASSERTION(mRealPtr, "Expected non-null here");                    \
michael@0:       }                                                                      \
michael@0:       NS_DECL_ISUPPORTS                                                      \
michael@0:       NS_FORWARD_NSIINTERFACEREQUESTOR(mIfReq->)                             \
michael@0:       NS_FORWARD_##_allcaps(mRealPtr->)                                      \
michael@0:     private:                                                                 \
michael@0:       nsCOMPtr<nsIInterfaceRequestor> mIfReq;                                \
michael@0:       nsCOMPtr<_i> mRealPtr;                                                 \
michael@0:     };
michael@0: 
michael@0:     DECL_SHIM(nsILoadContext, NSILOADCONTEXT)
michael@0:     DECL_SHIM(nsIProgressEventSink, NSIPROGRESSEVENTSINK)
michael@0:     DECL_SHIM(nsIChannelEventSink, NSICHANNELEVENTSINK)
michael@0:     DECL_SHIM(nsISecurityEventSink, NSISECURITYEVENTSINK)
michael@0:     DECL_SHIM(nsIApplicationCacheContainer, NSIAPPLICATIONCACHECONTAINER)
michael@0: #undef DECL_SHIM
michael@0:   };
michael@0:   
michael@0:   /**
michael@0:    * Add an ExternalResource for aURI.  aViewer and aLoadGroup might be null
michael@0:    * when this is called if the URI didn't result in an XML document.  This
michael@0:    * function makes sure to remove the pending load for aURI, if any, from our
michael@0:    * hashtable, and to notify its observers, if any.
michael@0:    */
michael@0:   nsresult AddExternalResource(nsIURI* aURI, nsIContentViewer* aViewer,
michael@0:                                nsILoadGroup* aLoadGroup,
michael@0:                                nsIDocument* aDisplayDocument);
michael@0:   
michael@0:   nsClassHashtable<nsURIHashKey, ExternalResource> mMap;
michael@0:   nsRefPtrHashtable<nsURIHashKey, PendingLoad> mPendingLoads;
michael@0:   bool mHaveShutDown;
michael@0: };
michael@0: 
michael@0: class CSPErrorQueue
michael@0: {
michael@0:   public:
michael@0:     /**
michael@0:      * Note this was designed to be passed string literals. If you give it
michael@0:      * a dynamically allocated string, it is your responsibility to make sure
michael@0:      * it never dies and is properly freed!
michael@0:      */
michael@0:     void Add(const char* aMessageName);
michael@0:     void Flush(nsIDocument* aDocument);
michael@0: 
michael@0:     CSPErrorQueue()
michael@0:     {
michael@0:     }
michael@0: 
michael@0:     ~CSPErrorQueue()
michael@0:     {
michael@0:     }
michael@0: 
michael@0:   private:
michael@0:     nsAutoTArray<const char*,5> mErrors;
michael@0: };
michael@0: 
michael@0: // Base class for our document implementations.
michael@0: //
michael@0: // Note that this class *implements* nsIDOMXMLDocument, but it's not
michael@0: // really an nsIDOMXMLDocument. The reason for implementing
michael@0: // nsIDOMXMLDocument on this class is to avoid having to duplicate all
michael@0: // its inherited methods on document classes that *are*
michael@0: // nsIDOMXMLDocument's. nsDocument's QI should *not* claim to support
michael@0: // nsIDOMXMLDocument unless someone writes a real implementation of
michael@0: // the interface.
michael@0: class nsDocument : public nsIDocument,
michael@0:                    public nsIDOMXMLDocument, // inherits nsIDOMDocument
michael@0:                    public nsIDOMDocumentXBL,
michael@0:                    public nsSupportsWeakReference,
michael@0:                    public nsIScriptObjectPrincipal,
michael@0:                    public nsIRadioGroupContainer,
michael@0:                    public nsIApplicationCacheContainer,
michael@0:                    public nsStubMutationObserver,
michael@0:                    public nsIObserver,
michael@0:                    public nsIDOMXPathEvaluator
michael@0: {
michael@0: public:
michael@0:   typedef mozilla::dom::Element Element;
michael@0:   using nsIDocument::GetElementsByTagName;
michael@0: 
michael@0:   NS_DECL_CYCLE_COLLECTING_ISUPPORTS
michael@0: 
michael@0:   NS_DECL_SIZEOF_EXCLUDING_THIS
michael@0: 
michael@0:   virtual void Reset(nsIChannel *aChannel, nsILoadGroup *aLoadGroup) MOZ_OVERRIDE;
michael@0:   virtual void ResetToURI(nsIURI *aURI, nsILoadGroup *aLoadGroup,
michael@0:                           nsIPrincipal* aPrincipal) MOZ_OVERRIDE;
michael@0: 
michael@0:   // StartDocumentLoad is pure virtual so that subclasses must override it.
michael@0:   // The nsDocument StartDocumentLoad does some setup, but does NOT set
michael@0:   // *aDocListener; this is the job of subclasses.
michael@0:   virtual nsresult StartDocumentLoad(const char* aCommand,
michael@0:                                      nsIChannel* aChannel,
michael@0:                                      nsILoadGroup* aLoadGroup,
michael@0:                                      nsISupports* aContainer,
michael@0:                                      nsIStreamListener **aDocListener,
michael@0:                                      bool aReset = true,
michael@0:                                      nsIContentSink* aContentSink = nullptr) MOZ_OVERRIDE = 0;
michael@0: 
michael@0:   virtual void StopDocumentLoad() MOZ_OVERRIDE;
michael@0: 
michael@0:   virtual void NotifyPossibleTitleChange(bool aBoundTitleElement) MOZ_OVERRIDE;
michael@0: 
michael@0:   virtual void SetDocumentURI(nsIURI* aURI) MOZ_OVERRIDE;
michael@0: 
michael@0:   virtual void SetChromeXHRDocURI(nsIURI* aURI) MOZ_OVERRIDE;
michael@0: 
michael@0:   virtual void SetChromeXHRDocBaseURI(nsIURI* aURI) MOZ_OVERRIDE;
michael@0: 
michael@0:   /**
michael@0:    * Set the principal responsible for this document.
michael@0:    */
michael@0:   virtual void SetPrincipal(nsIPrincipal *aPrincipal) MOZ_OVERRIDE;
michael@0: 
michael@0:   /**
michael@0:    * Get the Content-Type of this document.
michael@0:    */
michael@0:   // NS_IMETHOD GetContentType(nsAString& aContentType);
michael@0:   // Already declared in nsIDOMDocument
michael@0: 
michael@0:   /**
michael@0:    * Set the Content-Type of this document.
michael@0:    */
michael@0:   virtual void SetContentType(const nsAString& aContentType) MOZ_OVERRIDE;
michael@0: 
michael@0:   virtual nsresult SetBaseURI(nsIURI* aURI) MOZ_OVERRIDE;
michael@0: 
michael@0:   /**
michael@0:    * Get/Set the base target of a link in a document.
michael@0:    */
michael@0:   virtual void GetBaseTarget(nsAString &aBaseTarget) MOZ_OVERRIDE;
michael@0: 
michael@0:   /**
michael@0:    * Return a standard name for the document's character set. This will
michael@0:    * trigger a startDocumentLoad if necessary to answer the question.
michael@0:    */
michael@0:   virtual void SetDocumentCharacterSet(const nsACString& aCharSetID) MOZ_OVERRIDE;
michael@0: 
michael@0:   /**
michael@0:    * Add an observer that gets notified whenever the charset changes.
michael@0:    */
michael@0:   virtual nsresult AddCharSetObserver(nsIObserver* aObserver) MOZ_OVERRIDE;
michael@0: 
michael@0:   /**
michael@0:    * Remove a charset observer.
michael@0:    */
michael@0:   virtual void RemoveCharSetObserver(nsIObserver* aObserver) MOZ_OVERRIDE;
michael@0: 
michael@0:   virtual Element* AddIDTargetObserver(nsIAtom* aID, IDTargetObserver aObserver,
michael@0:                                        void* aData, bool aForImage) MOZ_OVERRIDE;
michael@0:   virtual void RemoveIDTargetObserver(nsIAtom* aID, IDTargetObserver aObserver,
michael@0:                                       void* aData, bool aForImage) MOZ_OVERRIDE;
michael@0: 
michael@0:   /**
michael@0:    * Access HTTP header data (this may also get set from other sources, like
michael@0:    * HTML META tags).
michael@0:    */
michael@0:   virtual void GetHeaderData(nsIAtom* aHeaderField, nsAString& aData) const MOZ_OVERRIDE;
michael@0:   virtual void SetHeaderData(nsIAtom* aheaderField,
michael@0:                              const nsAString& aData) MOZ_OVERRIDE;
michael@0: 
michael@0:   /**
michael@0:    * Create a new presentation shell that will use aContext for
michael@0:    * its presentation context (presentation contexts <b>must not</b> be
michael@0:    * shared among multiple presentation shells).
michael@0:    */
michael@0:   virtual already_AddRefed<nsIPresShell> CreateShell(nsPresContext* aContext,
michael@0:                                                      nsViewManager* aViewManager,
michael@0:                                                      nsStyleSet* aStyleSet) MOZ_OVERRIDE;
michael@0:   virtual void DeleteShell() MOZ_OVERRIDE;
michael@0: 
michael@0:   virtual nsresult GetAllowPlugins(bool* aAllowPlugins) MOZ_OVERRIDE;
michael@0: 
michael@0:   virtual already_AddRefed<mozilla::dom::UndoManager> GetUndoManager() MOZ_OVERRIDE;
michael@0: 
michael@0:   virtual nsresult SetSubDocumentFor(Element* aContent,
michael@0:                                      nsIDocument* aSubDoc) MOZ_OVERRIDE;
michael@0:   virtual nsIDocument* GetSubDocumentFor(nsIContent* aContent) const MOZ_OVERRIDE;
michael@0:   virtual Element* FindContentForSubDocument(nsIDocument *aDocument) const MOZ_OVERRIDE;
michael@0:   virtual Element* GetRootElementInternal() const MOZ_OVERRIDE;
michael@0: 
michael@0:   /**
michael@0:    * Get the style sheets owned by this document.
michael@0:    * These are ordered, highest priority last
michael@0:    */
michael@0:   virtual int32_t GetNumberOfStyleSheets() const MOZ_OVERRIDE;
michael@0:   virtual nsIStyleSheet* GetStyleSheetAt(int32_t aIndex) const MOZ_OVERRIDE;
michael@0:   virtual int32_t GetIndexOfStyleSheet(nsIStyleSheet* aSheet) const MOZ_OVERRIDE;
michael@0:   virtual void AddStyleSheet(nsIStyleSheet* aSheet) MOZ_OVERRIDE;
michael@0:   virtual void RemoveStyleSheet(nsIStyleSheet* aSheet) MOZ_OVERRIDE;
michael@0: 
michael@0:   virtual void UpdateStyleSheets(nsCOMArray<nsIStyleSheet>& aOldSheets,
michael@0:                                  nsCOMArray<nsIStyleSheet>& aNewSheets) MOZ_OVERRIDE;
michael@0:   virtual void AddStyleSheetToStyleSets(nsIStyleSheet* aSheet);
michael@0:   virtual void RemoveStyleSheetFromStyleSets(nsIStyleSheet* aSheet);
michael@0: 
michael@0:   virtual void InsertStyleSheetAt(nsIStyleSheet* aSheet, int32_t aIndex) MOZ_OVERRIDE;
michael@0:   virtual void SetStyleSheetApplicableState(nsIStyleSheet* aSheet,
michael@0:                                             bool aApplicable) MOZ_OVERRIDE;
michael@0: 
michael@0:   virtual int32_t GetNumberOfCatalogStyleSheets() const MOZ_OVERRIDE;
michael@0:   virtual nsIStyleSheet* GetCatalogStyleSheetAt(int32_t aIndex) const MOZ_OVERRIDE;
michael@0:   virtual void AddCatalogStyleSheet(nsCSSStyleSheet* aSheet) MOZ_OVERRIDE;
michael@0:   virtual void EnsureCatalogStyleSheet(const char *aStyleSheetURI) MOZ_OVERRIDE;
michael@0: 
michael@0:   virtual nsresult LoadAdditionalStyleSheet(additionalSheetType aType, nsIURI* aSheetURI) MOZ_OVERRIDE;
michael@0:   virtual void RemoveAdditionalStyleSheet(additionalSheetType aType, nsIURI* sheetURI) MOZ_OVERRIDE;
michael@0:   virtual nsIStyleSheet* FirstAdditionalAuthorSheet() MOZ_OVERRIDE;
michael@0: 
michael@0:   virtual nsIChannel* GetChannel() const MOZ_OVERRIDE {
michael@0:     return mChannel;
michael@0:   }
michael@0: 
michael@0:   virtual void SetScriptGlobalObject(nsIScriptGlobalObject* aGlobalObject) MOZ_OVERRIDE;
michael@0: 
michael@0:   virtual void SetScriptHandlingObject(nsIScriptGlobalObject* aScriptObject) MOZ_OVERRIDE;
michael@0: 
michael@0:   virtual nsIGlobalObject* GetScopeObject() const MOZ_OVERRIDE;
michael@0:   void SetScopeObject(nsIGlobalObject* aGlobal) MOZ_OVERRIDE;
michael@0:   /**
michael@0:    * Get the script loader for this document
michael@0:    */
michael@0:   virtual nsScriptLoader* ScriptLoader() MOZ_OVERRIDE;
michael@0: 
michael@0:   /**
michael@0:    * Add/Remove an element to the document's id and name hashes
michael@0:    */
michael@0:   virtual void AddToIdTable(Element* aElement, nsIAtom* aId) MOZ_OVERRIDE;
michael@0:   virtual void RemoveFromIdTable(Element* aElement, nsIAtom* aId) MOZ_OVERRIDE;
michael@0:   virtual void AddToNameTable(Element* aElement, nsIAtom* aName) MOZ_OVERRIDE;
michael@0:   virtual void RemoveFromNameTable(Element* aElement, nsIAtom* aName) MOZ_OVERRIDE;
michael@0: 
michael@0:   /**
michael@0:    * Add a new observer of document change notifications. Whenever
michael@0:    * content is changed, appended, inserted or removed the observers are
michael@0:    * informed.
michael@0:    */
michael@0:   virtual void AddObserver(nsIDocumentObserver* aObserver) MOZ_OVERRIDE;
michael@0: 
michael@0:   /**
michael@0:    * Remove an observer of document change notifications. This will
michael@0:    * return false if the observer cannot be found.
michael@0:    */
michael@0:   virtual bool RemoveObserver(nsIDocumentObserver* aObserver) MOZ_OVERRIDE;
michael@0: 
michael@0:   // Observation hooks used to propagate notifications to document
michael@0:   // observers.
michael@0:   virtual void BeginUpdate(nsUpdateType aUpdateType) MOZ_OVERRIDE;
michael@0:   virtual void EndUpdate(nsUpdateType aUpdateType) MOZ_OVERRIDE;
michael@0:   virtual void BeginLoad() MOZ_OVERRIDE;
michael@0:   virtual void EndLoad() MOZ_OVERRIDE;
michael@0: 
michael@0:   virtual void SetReadyStateInternal(ReadyState rs) MOZ_OVERRIDE;
michael@0: 
michael@0:   virtual void ContentStateChanged(nsIContent* aContent,
michael@0:                                    mozilla::EventStates aStateMask)
michael@0:                                      MOZ_OVERRIDE;
michael@0:   virtual void DocumentStatesChanged(
michael@0:                  mozilla::EventStates aStateMask) MOZ_OVERRIDE;
michael@0: 
michael@0:   virtual void StyleRuleChanged(nsIStyleSheet* aStyleSheet,
michael@0:                                 nsIStyleRule* aOldStyleRule,
michael@0:                                 nsIStyleRule* aNewStyleRule) MOZ_OVERRIDE;
michael@0:   virtual void StyleRuleAdded(nsIStyleSheet* aStyleSheet,
michael@0:                               nsIStyleRule* aStyleRule) MOZ_OVERRIDE;
michael@0:   virtual void StyleRuleRemoved(nsIStyleSheet* aStyleSheet,
michael@0:                                 nsIStyleRule* aStyleRule) MOZ_OVERRIDE;
michael@0: 
michael@0:   virtual void FlushPendingNotifications(mozFlushType aType) MOZ_OVERRIDE;
michael@0:   virtual void FlushExternalResources(mozFlushType aType) MOZ_OVERRIDE;
michael@0:   virtual void SetXMLDeclaration(const char16_t *aVersion,
michael@0:                                  const char16_t *aEncoding,
michael@0:                                  const int32_t aStandalone) MOZ_OVERRIDE;
michael@0:   virtual void GetXMLDeclaration(nsAString& aVersion,
michael@0:                                  nsAString& aEncoding,
michael@0:                                  nsAString& Standalone) MOZ_OVERRIDE;
michael@0:   virtual bool IsScriptEnabled() MOZ_OVERRIDE;
michael@0: 
michael@0:   virtual void OnPageShow(bool aPersisted, mozilla::dom::EventTarget* aDispatchStartTarget) MOZ_OVERRIDE;
michael@0:   virtual void OnPageHide(bool aPersisted, mozilla::dom::EventTarget* aDispatchStartTarget) MOZ_OVERRIDE;
michael@0: 
michael@0:   virtual void WillDispatchMutationEvent(nsINode* aTarget) MOZ_OVERRIDE;
michael@0:   virtual void MutationEventDispatched(nsINode* aTarget) MOZ_OVERRIDE;
michael@0: 
michael@0:   // nsINode
michael@0:   virtual bool IsNodeOfType(uint32_t aFlags) const MOZ_OVERRIDE;
michael@0:   virtual nsIContent *GetChildAt(uint32_t aIndex) const MOZ_OVERRIDE;
michael@0:   virtual nsIContent * const * GetChildArray(uint32_t* aChildCount) const MOZ_OVERRIDE;
michael@0:   virtual int32_t IndexOf(const nsINode* aPossibleChild) const MOZ_OVERRIDE;
michael@0:   virtual uint32_t GetChildCount() const MOZ_OVERRIDE;
michael@0:   virtual nsresult InsertChildAt(nsIContent* aKid, uint32_t aIndex,
michael@0:                                  bool aNotify) MOZ_OVERRIDE;
michael@0:   virtual nsresult AppendChildTo(nsIContent* aKid, bool aNotify);
michael@0:   virtual void RemoveChildAt(uint32_t aIndex, bool aNotify) MOZ_OVERRIDE;
michael@0:   virtual nsresult Clone(nsINodeInfo *aNodeInfo, nsINode **aResult) const MOZ_OVERRIDE
michael@0:   {
michael@0:     return NS_ERROR_NOT_IMPLEMENTED;
michael@0:   }
michael@0: 
michael@0:   // nsIRadioGroupContainer
michael@0:   NS_IMETHOD WalkRadioGroup(const nsAString& aName,
michael@0:                             nsIRadioVisitor* aVisitor,
michael@0:                             bool aFlushContent) MOZ_OVERRIDE;
michael@0:   virtual void
michael@0:     SetCurrentRadioButton(const nsAString& aName,
michael@0:                           mozilla::dom::HTMLInputElement* aRadio) MOZ_OVERRIDE;
michael@0:   virtual mozilla::dom::HTMLInputElement*
michael@0:     GetCurrentRadioButton(const nsAString& aName) MOZ_OVERRIDE;
michael@0:   NS_IMETHOD
michael@0:     GetNextRadioButton(const nsAString& aName,
michael@0:                        const bool aPrevious,
michael@0:                        mozilla::dom::HTMLInputElement*  aFocusedRadio,
michael@0:                        mozilla::dom::HTMLInputElement** aRadioOut) MOZ_OVERRIDE;
michael@0:   virtual void AddToRadioGroup(const nsAString& aName,
michael@0:                                nsIFormControl* aRadio) MOZ_OVERRIDE;
michael@0:   virtual void RemoveFromRadioGroup(const nsAString& aName,
michael@0:                                     nsIFormControl* aRadio) MOZ_OVERRIDE;
michael@0:   virtual uint32_t GetRequiredRadioCount(const nsAString& aName) const MOZ_OVERRIDE;
michael@0:   virtual void RadioRequiredChanged(const nsAString& aName,
michael@0:                                     nsIFormControl* aRadio) MOZ_OVERRIDE;
michael@0:   virtual bool GetValueMissingState(const nsAString& aName) const MOZ_OVERRIDE;
michael@0:   virtual void SetValueMissingState(const nsAString& aName, bool aValue) MOZ_OVERRIDE;
michael@0: 
michael@0:   // for radio group
michael@0:   nsRadioGroupStruct* GetRadioGroup(const nsAString& aName) const;
michael@0:   nsRadioGroupStruct* GetOrCreateRadioGroup(const nsAString& aName);
michael@0: 
michael@0:   virtual nsViewportInfo GetViewportInfo(const mozilla::ScreenIntSize& aDisplaySize) MOZ_OVERRIDE;
michael@0: 
michael@0: private:
michael@0:   nsRadioGroupStruct* GetRadioGroupInternal(const nsAString& aName) const;
michael@0:   void SendToConsole(nsCOMArray<nsISecurityConsoleMessage>& aMessages);
michael@0: 
michael@0: public:
michael@0:   // nsIDOMNode
michael@0:   NS_FORWARD_NSIDOMNODE_TO_NSINODE_OVERRIDABLE
michael@0: 
michael@0:   // nsIDOMDocument
michael@0:   NS_DECL_NSIDOMDOCUMENT
michael@0: 
michael@0:   // nsIDOMXMLDocument
michael@0:   NS_DECL_NSIDOMXMLDOCUMENT
michael@0: 
michael@0:   // nsIDOMDocumentXBL
michael@0:   NS_DECL_NSIDOMDOCUMENTXBL
michael@0: 
michael@0:   // nsIDOMEventTarget
michael@0:   virtual nsresult PreHandleEvent(
michael@0:                      mozilla::EventChainPreVisitor& aVisitor) MOZ_OVERRIDE;
michael@0:   virtual mozilla::EventListenerManager*
michael@0:     GetOrCreateListenerManager() MOZ_OVERRIDE;
michael@0:   virtual mozilla::EventListenerManager*
michael@0:     GetExistingListenerManager() const MOZ_OVERRIDE;
michael@0: 
michael@0:   // nsIScriptObjectPrincipal
michael@0:   virtual nsIPrincipal* GetPrincipal() MOZ_OVERRIDE;
michael@0: 
michael@0:   // nsIApplicationCacheContainer
michael@0:   NS_DECL_NSIAPPLICATIONCACHECONTAINER
michael@0: 
michael@0:   // nsIObserver
michael@0:   NS_DECL_NSIOBSERVER
michael@0: 
michael@0:   NS_DECL_NSIDOMXPATHEVALUATOR
michael@0: 
michael@0:   virtual nsresult Init();
michael@0: 
michael@0:   virtual nsresult CreateElem(const nsAString& aName, nsIAtom *aPrefix,
michael@0:                               int32_t aNamespaceID,
michael@0:                               nsIContent **aResult) MOZ_OVERRIDE;
michael@0: 
michael@0:   virtual NS_HIDDEN_(void) Sanitize();
michael@0: 
michael@0:   virtual NS_HIDDEN_(void) EnumerateSubDocuments(nsSubDocEnumFunc aCallback,
michael@0:                                                  void *aData);
michael@0: 
michael@0:   virtual NS_HIDDEN_(bool) CanSavePresentation(nsIRequest *aNewRequest);
michael@0:   virtual NS_HIDDEN_(void) Destroy();
michael@0:   virtual NS_HIDDEN_(void) RemovedFromDocShell();
michael@0:   virtual NS_HIDDEN_(already_AddRefed<nsILayoutHistoryState>) GetLayoutHistoryState() const;
michael@0: 
michael@0:   virtual NS_HIDDEN_(void) BlockOnload();
michael@0:   virtual NS_HIDDEN_(void) UnblockOnload(bool aFireSync);
michael@0: 
michael@0:   virtual NS_HIDDEN_(void) AddStyleRelevantLink(mozilla::dom::Link* aLink);
michael@0:   virtual NS_HIDDEN_(void) ForgetLink(mozilla::dom::Link* aLink);
michael@0: 
michael@0:   NS_HIDDEN_(void) ClearBoxObjectFor(nsIContent* aContent);
michael@0:   already_AddRefed<nsIBoxObject> GetBoxObjectFor(mozilla::dom::Element* aElement,
michael@0:                                                  mozilla::ErrorResult& aRv) MOZ_OVERRIDE;
michael@0: 
michael@0:   virtual NS_HIDDEN_(Element*)
michael@0:     GetAnonymousElementByAttribute(nsIContent* aElement,
michael@0:                                    nsIAtom* aAttrName,
michael@0:                                    const nsAString& aAttrValue) const;
michael@0: 
michael@0:   virtual NS_HIDDEN_(Element*) ElementFromPointHelper(float aX, float aY,
michael@0:                                                       bool aIgnoreRootScrollFrame,
michael@0:                                                       bool aFlushLayout);
michael@0: 
michael@0:   virtual NS_HIDDEN_(nsresult) NodesFromRectHelper(float aX, float aY,
michael@0:                                                    float aTopSize, float aRightSize,
michael@0:                                                    float aBottomSize, float aLeftSize,
michael@0:                                                    bool aIgnoreRootScrollFrame,
michael@0:                                                    bool aFlushLayout,
michael@0:                                                    nsIDOMNodeList** aReturn);
michael@0: 
michael@0:   virtual NS_HIDDEN_(void) FlushSkinBindings();
michael@0: 
michael@0:   virtual NS_HIDDEN_(nsresult) InitializeFrameLoader(nsFrameLoader* aLoader);
michael@0:   virtual NS_HIDDEN_(nsresult) FinalizeFrameLoader(nsFrameLoader* aLoader);
michael@0:   virtual NS_HIDDEN_(void) TryCancelFrameLoaderInitialization(nsIDocShell* aShell);
michael@0:   virtual NS_HIDDEN_(bool) FrameLoaderScheduledToBeFinalized(nsIDocShell* aShell);
michael@0:   virtual NS_HIDDEN_(nsIDocument*)
michael@0:     RequestExternalResource(nsIURI* aURI,
michael@0:                             nsINode* aRequestingNode,
michael@0:                             ExternalResourceLoad** aPendingLoad);
michael@0:   virtual NS_HIDDEN_(void)
michael@0:     EnumerateExternalResources(nsSubDocEnumFunc aCallback, void* aData);
michael@0: 
michael@0:   nsTArray<nsCString> mHostObjectURIs;
michael@0: 
michael@0:   // Returns our (lazily-initialized) animation controller.
michael@0:   // If HasAnimationController is true, this is guaranteed to return non-null.
michael@0:   nsSMILAnimationController* GetAnimationController() MOZ_OVERRIDE;
michael@0: 
michael@0:   void SetImagesNeedAnimating(bool aAnimating) MOZ_OVERRIDE;
michael@0: 
michael@0:   virtual void SuppressEventHandling(SuppressionType aWhat,
michael@0:                                      uint32_t aIncrease) MOZ_OVERRIDE;
michael@0: 
michael@0:   virtual void UnsuppressEventHandlingAndFireEvents(SuppressionType aWhat,
michael@0:                                                     bool aFireEvents) MOZ_OVERRIDE;
michael@0: 
michael@0:   void DecreaseEventSuppression() {
michael@0:     MOZ_ASSERT(mEventsSuppressed);
michael@0:     --mEventsSuppressed;
michael@0:     MaybeRescheduleAnimationFrameNotifications();
michael@0:   }
michael@0: 
michael@0:   void ResumeAnimations() {
michael@0:     MOZ_ASSERT(mAnimationsPaused);
michael@0:     --mAnimationsPaused;
michael@0:     MaybeRescheduleAnimationFrameNotifications();
michael@0:   }
michael@0: 
michael@0:   virtual nsIDocument* GetTemplateContentsOwner() MOZ_OVERRIDE;
michael@0: 
michael@0:   NS_DECL_CYCLE_COLLECTION_SKIPPABLE_SCRIPT_HOLDER_CLASS_AMBIGUOUS(nsDocument,
michael@0:                                                                    nsIDocument)
michael@0: 
michael@0:   void DoNotifyPossibleTitleChange();
michael@0: 
michael@0:   nsExternalResourceMap& ExternalResourceMap()
michael@0:   {
michael@0:     return mExternalResourceMap;
michael@0:   }
michael@0: 
michael@0:   void SetLoadedAsData(bool aLoadedAsData) { mLoadedAsData = aLoadedAsData; }
michael@0:   void SetLoadedAsInteractiveData(bool aLoadedAsInteractiveData)
michael@0:   {
michael@0:     mLoadedAsInteractiveData = aLoadedAsInteractiveData;
michael@0:   }
michael@0: 
michael@0:   nsresult CloneDocHelper(nsDocument* clone) const;
michael@0: 
michael@0:   void MaybeInitializeFinalizeFrameLoaders();
michael@0: 
michael@0:   void MaybeEndOutermostXBLUpdate();
michael@0: 
michael@0:   virtual void MaybePreLoadImage(nsIURI* uri,
michael@0:                                  const nsAString &aCrossOriginAttr) MOZ_OVERRIDE;
michael@0: 
michael@0:   virtual void PreloadStyle(nsIURI* uri, const nsAString& charset,
michael@0:                             const nsAString& aCrossOriginAttr) MOZ_OVERRIDE;
michael@0: 
michael@0:   virtual nsresult LoadChromeSheetSync(nsIURI* uri, bool isAgentSheet,
michael@0:                                        nsCSSStyleSheet** sheet) MOZ_OVERRIDE;
michael@0: 
michael@0:   virtual nsISupports* GetCurrentContentSink() MOZ_OVERRIDE;
michael@0: 
michael@0:   virtual mozilla::EventStates GetDocumentState() MOZ_OVERRIDE;
michael@0: 
michael@0:   virtual void RegisterHostObjectUri(const nsACString& aUri) MOZ_OVERRIDE;
michael@0:   virtual void UnregisterHostObjectUri(const nsACString& aUri) MOZ_OVERRIDE;
michael@0: 
michael@0:   // Only BlockOnload should call this!
michael@0:   void AsyncBlockOnload();
michael@0: 
michael@0:   virtual void SetScrollToRef(nsIURI *aDocumentURI) MOZ_OVERRIDE;
michael@0:   virtual void ScrollToRef() MOZ_OVERRIDE;
michael@0:   virtual void ResetScrolledToRefAlready() MOZ_OVERRIDE;
michael@0:   virtual void SetChangeScrollPosWhenScrollingToRef(bool aValue) MOZ_OVERRIDE;
michael@0: 
michael@0:   virtual Element *GetElementById(const nsAString& aElementId) MOZ_OVERRIDE;
michael@0:   virtual const nsSmallVoidArray* GetAllElementsForId(const nsAString& aElementId) const MOZ_OVERRIDE;
michael@0: 
michael@0:   virtual Element *LookupImageElement(const nsAString& aElementId) MOZ_OVERRIDE;
michael@0:   virtual void MozSetImageElement(const nsAString& aImageElementId,
michael@0:                                   Element* aElement) MOZ_OVERRIDE;
michael@0: 
michael@0:   virtual NS_HIDDEN_(nsresult) AddImage(imgIRequest* aImage);
michael@0:   virtual NS_HIDDEN_(nsresult) RemoveImage(imgIRequest* aImage, uint32_t aFlags);
michael@0:   virtual NS_HIDDEN_(nsresult) SetImageLockingState(bool aLocked);
michael@0: 
michael@0:   // AddPlugin adds a plugin-related element to mPlugins when the element is
michael@0:   // added to the tree.
michael@0:   virtual nsresult AddPlugin(nsIObjectLoadingContent* aPlugin) MOZ_OVERRIDE;
michael@0:   // RemovePlugin removes a plugin-related element to mPlugins when the
michael@0:   // element is removed from the tree.
michael@0:   virtual void RemovePlugin(nsIObjectLoadingContent* aPlugin) MOZ_OVERRIDE;
michael@0:   // GetPlugins returns the plugin-related elements from
michael@0:   // the frame and any subframes.
michael@0:   virtual void GetPlugins(nsTArray<nsIObjectLoadingContent*>& aPlugins) MOZ_OVERRIDE;
michael@0: 
michael@0:   virtual nsresult GetStateObject(nsIVariant** aResult) MOZ_OVERRIDE;
michael@0: 
michael@0:   virtual nsDOMNavigationTiming* GetNavigationTiming() const MOZ_OVERRIDE;
michael@0:   virtual nsresult SetNavigationTiming(nsDOMNavigationTiming* aTiming) MOZ_OVERRIDE;
michael@0: 
michael@0:   virtual Element* FindImageMap(const nsAString& aNormalizedMapName) MOZ_OVERRIDE;
michael@0: 
michael@0:   virtual Element* GetFullScreenElement() MOZ_OVERRIDE;
michael@0:   virtual void AsyncRequestFullScreen(Element* aElement) MOZ_OVERRIDE;
michael@0:   virtual void RestorePreviousFullScreenState() MOZ_OVERRIDE;
michael@0:   virtual bool IsFullscreenLeaf() MOZ_OVERRIDE;
michael@0:   virtual bool IsFullScreenDoc() MOZ_OVERRIDE;
michael@0:   virtual void SetApprovedForFullscreen(bool aIsApproved) MOZ_OVERRIDE;
michael@0:   virtual nsresult RemoteFrameFullscreenChanged(nsIDOMElement* aFrameElement,
michael@0:                                                 const nsAString& aNewOrigin) MOZ_OVERRIDE;
michael@0: 
michael@0:   virtual nsresult RemoteFrameFullscreenReverted() MOZ_OVERRIDE;
michael@0:   virtual nsIDocument* GetFullscreenRoot() MOZ_OVERRIDE;
michael@0:   virtual void SetFullscreenRoot(nsIDocument* aRoot) MOZ_OVERRIDE;
michael@0: 
michael@0:   static void ExitFullscreen(nsIDocument* aDoc);
michael@0: 
michael@0:   // This is called asynchronously by nsIDocument::AsyncRequestFullScreen()
michael@0:   // to move this document into full-screen mode if allowed. aWasCallerChrome
michael@0:   // should be true when nsIDocument::AsyncRequestFullScreen() was called
michael@0:   // by chrome code. aNotifyOnOriginChange denotes whether we should send a
michael@0:   // fullscreen-origin-change notification if requesting fullscreen in this
michael@0:   // document causes the origin which is fullscreen to change. We may want to
michael@0:   // *not* send this notification if we're calling RequestFullscreen() as part
michael@0:   // of a continuation of a request in a subdocument, whereupon the caller will
michael@0:   // need to send the notification with the origin of the document which
michael@0:   // originally requested fullscreen, not *this* document's origin.
michael@0:   void RequestFullScreen(Element* aElement,
michael@0:                          bool aWasCallerChrome,
michael@0:                          bool aNotifyOnOriginChange);
michael@0: 
michael@0:   // Removes all elements from the full-screen stack, removing full-scren
michael@0:   // styles from the top element in the stack.
michael@0:   void CleanupFullscreenState();
michael@0: 
michael@0:   // Add/remove "fullscreen-approved" observer service notification listener.
michael@0:   // Chrome sends us a notification when fullscreen is approved for a
michael@0:   // document, with the notification subject as the document that was approved.
michael@0:   // We maintain this listener while in fullscreen mode.
michael@0:   nsresult AddFullscreenApprovedObserver();
michael@0:   nsresult RemoveFullscreenApprovedObserver();
michael@0: 
michael@0:   // Pushes aElement onto the full-screen stack, and removes full-screen styles
michael@0:   // from the former full-screen stack top, and its ancestors, and applies the
michael@0:   // styles to aElement. aElement becomes the new "full-screen element".
michael@0:   bool FullScreenStackPush(Element* aElement);
michael@0: 
michael@0:   // Remove the top element from the full-screen stack. Removes the full-screen
michael@0:   // styles from the former top element, and applies them to the new top
michael@0:   // element, if there is one.
michael@0:   void FullScreenStackPop();
michael@0: 
michael@0:   // Returns the top element from the full-screen stack.
michael@0:   Element* FullScreenStackTop();
michael@0: 
michael@0:   // DOM-exposed fullscreen API
michael@0:   virtual bool MozFullScreenEnabled() MOZ_OVERRIDE;
michael@0:   virtual Element* GetMozFullScreenElement(mozilla::ErrorResult& rv) MOZ_OVERRIDE;
michael@0: 
michael@0:   void RequestPointerLock(Element* aElement) MOZ_OVERRIDE;
michael@0:   bool ShouldLockPointer(Element* aElement, Element* aCurrentLock,
michael@0:                          bool aNoFocusCheck = false);
michael@0:   bool SetPointerLock(Element* aElement, int aCursorStyle);
michael@0:   static void UnlockPointer(nsIDocument* aDoc = nullptr);
michael@0: 
michael@0:   // This method may fire a DOM event; if it does so it will happen
michael@0:   // synchronously.
michael@0:   void UpdateVisibilityState();
michael@0:   // Posts an event to call UpdateVisibilityState
michael@0:   virtual void PostVisibilityUpdateEvent() MOZ_OVERRIDE;
michael@0: 
michael@0:   virtual void DocAddSizeOfExcludingThis(nsWindowSizes* aWindowSizes) const MOZ_OVERRIDE;
michael@0:   // DocAddSizeOfIncludingThis is inherited from nsIDocument.
michael@0: 
michael@0:   virtual nsIDOMNode* AsDOMNode() MOZ_OVERRIDE { return this; }
michael@0: 
michael@0:   virtual void EnqueueLifecycleCallback(nsIDocument::ElementCallbackType aType,
michael@0:                                         Element* aCustomElement,
michael@0:                                         mozilla::dom::LifecycleCallbackArgs* aArgs = nullptr,
michael@0:                                         mozilla::dom::CustomElementDefinition* aDefinition = nullptr) MOZ_OVERRIDE;
michael@0: 
michael@0:   static void ProcessTopElementQueue(bool aIsBaseQueue = false);
michael@0: 
michael@0:   void GetCustomPrototype(int32_t aNamespaceID,
michael@0:                           nsIAtom* aAtom,
michael@0:                           JS::MutableHandle<JSObject*> prototype)
michael@0:   {
michael@0:     if (!mRegistry) {
michael@0:       prototype.set(nullptr);
michael@0:       return;
michael@0:     }
michael@0: 
michael@0:     mozilla::dom::CustomElementHashKey key(aNamespaceID, aAtom);
michael@0:     mozilla::dom::CustomElementDefinition* definition;
michael@0:     if (mRegistry->mCustomDefinitions.Get(&key, &definition)) {
michael@0:       prototype.set(definition->mPrototype);
michael@0:     } else {
michael@0:       prototype.set(nullptr);
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   static bool RegisterEnabled();
michael@0: 
michael@0:   virtual nsresult RegisterUnresolvedElement(mozilla::dom::Element* aElement,
michael@0:                                              nsIAtom* aTypeName = nullptr) MOZ_OVERRIDE;
michael@0: 
michael@0:   // WebIDL bits
michael@0:   virtual mozilla::dom::DOMImplementation*
michael@0:     GetImplementation(mozilla::ErrorResult& rv) MOZ_OVERRIDE;
michael@0:   virtual void
michael@0:     RegisterElement(JSContext* aCx, const nsAString& aName,
michael@0:                     const mozilla::dom::ElementRegistrationOptions& aOptions,
michael@0:                     JS::MutableHandle<JSObject*> aRetval,
michael@0:                     mozilla::ErrorResult& rv) MOZ_OVERRIDE;
michael@0:   virtual mozilla::dom::StyleSheetList* StyleSheets() MOZ_OVERRIDE;
michael@0:   virtual void SetSelectedStyleSheetSet(const nsAString& aSheetSet) MOZ_OVERRIDE;
michael@0:   virtual void GetLastStyleSheetSet(nsString& aSheetSet) MOZ_OVERRIDE;
michael@0:   virtual mozilla::dom::DOMStringList* StyleSheetSets() MOZ_OVERRIDE;
michael@0:   virtual void EnableStyleSheetsForSet(const nsAString& aSheetSet) MOZ_OVERRIDE;
michael@0:   using nsIDocument::CreateElement;
michael@0:   using nsIDocument::CreateElementNS;
michael@0:   virtual already_AddRefed<Element> CreateElement(const nsAString& aTagName,
michael@0:                                                   const nsAString& aTypeExtension,
michael@0:                                                   mozilla::ErrorResult& rv) MOZ_OVERRIDE;
michael@0:   virtual already_AddRefed<Element> CreateElementNS(const nsAString& aNamespaceURI,
michael@0:                                                     const nsAString& aQualifiedName,
michael@0:                                                     const nsAString& aTypeExtension,
michael@0:                                                     mozilla::ErrorResult& rv) MOZ_OVERRIDE;
michael@0:   virtual void UseRegistryFromDocument(nsIDocument* aDocument) MOZ_OVERRIDE;
michael@0: 
michael@0:   virtual void UnblockDOMContentLoaded() MOZ_OVERRIDE;
michael@0: 
michael@0: protected:
michael@0:   friend class nsNodeUtils;
michael@0:   friend class nsDocumentOnStack;
michael@0: 
michael@0:   void IncreaseStackRefCnt()
michael@0:   {
michael@0:     ++mStackRefCnt;
michael@0:   }
michael@0: 
michael@0:   void DecreaseStackRefCnt()
michael@0:   {
michael@0:     if (--mStackRefCnt == 0 && mNeedsReleaseAfterStackRefCntRelease) {
michael@0:       mNeedsReleaseAfterStackRefCntRelease = false;
michael@0:       NS_RELEASE_THIS();
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   // Returns true if a request for DOM full-screen is currently enabled in
michael@0:   // this document. This returns true if there are no windowed plugins in this
michael@0:   // doc tree, and if the document is visible, and if the api is not
michael@0:   // disabled by pref. aIsCallerChrome must contain the return value of
michael@0:   // nsContentUtils::IsCallerChrome() from the context we're checking.
michael@0:   // If aLogFailure is true, an appropriate warning message is logged to the
michael@0:   // console, and a "mozfullscreenerror" event is dispatched to this document.
michael@0:   bool IsFullScreenEnabled(bool aIsCallerChrome, bool aLogFailure);
michael@0: 
michael@0:   /**
michael@0:    * Check that aId is not empty and log a message to the console
michael@0:    * service if it is.
michael@0:    * @returns true if aId looks correct, false otherwise.
michael@0:    */
michael@0:   inline bool CheckGetElementByIdArg(const nsAString& aId)
michael@0:   {
michael@0:     if (aId.IsEmpty()) {
michael@0:       ReportEmptyGetElementByIdArg();
michael@0:       return false;
michael@0:     }
michael@0:     return true;
michael@0:   }
michael@0: 
michael@0:   void ReportEmptyGetElementByIdArg();
michael@0: 
michael@0:   void DispatchContentLoadedEvents();
michael@0: 
michael@0:   void RetrieveRelevantHeaders(nsIChannel *aChannel);
michael@0: 
michael@0:   void TryChannelCharset(nsIChannel *aChannel,
michael@0:                          int32_t& aCharsetSource,
michael@0:                          nsACString& aCharset,
michael@0:                          nsHtml5TreeOpExecutor* aExecutor);
michael@0: 
michael@0:   // Call this before the document does something that will unbind all content.
michael@0:   // That will stop us from doing a lot of work as each element is removed.
michael@0:   void DestroyElementMaps();
michael@0: 
michael@0:   // Refreshes the hrefs of all the links in the document.
michael@0:   void RefreshLinkHrefs();
michael@0: 
michael@0:   nsIContent* GetFirstBaseNodeWithHref();
michael@0:   nsresult SetFirstBaseNodeWithHref(nsIContent *node);
michael@0: 
michael@0:   // Get the first <title> element with the given IsNodeOfType type, or
michael@0:   // return null if there isn't one
michael@0:   nsIContent* GetTitleContent(uint32_t aNodeType);
michael@0:   // Find the first "title" element in the given IsNodeOfType type and
michael@0:   // append the concatenation of its text node children to aTitle. Do
michael@0:   // nothing if there is no such element.
michael@0:   void GetTitleFromElement(uint32_t aNodeType, nsAString& aTitle);
michael@0: public:
michael@0:   // Get our title
michael@0:   virtual void GetTitle(nsString& aTitle) MOZ_OVERRIDE;
michael@0:   // Set our title
michael@0:   virtual void SetTitle(const nsAString& aTitle, mozilla::ErrorResult& rv) MOZ_OVERRIDE;
michael@0: 
michael@0:   static void XPCOMShutdown();
michael@0: 
michael@0:   bool mIsTopLevelContentDocument:1;
michael@0: 
michael@0:   bool IsTopLevelContentDocument();
michael@0: 
michael@0:   void SetIsTopLevelContentDocument(bool aIsTopLevelContentDocument);
michael@0: 
michael@0:   js::ExpandoAndGeneration mExpandoAndGeneration;
michael@0: 
michael@0: protected:
michael@0:   already_AddRefed<nsIPresShell> doCreateShell(nsPresContext* aContext,
michael@0:                                                nsViewManager* aViewManager,
michael@0:                                                nsStyleSet* aStyleSet,
michael@0:                                                nsCompatibility aCompatMode);
michael@0: 
michael@0:   void RemoveDocStyleSheetsFromStyleSets();
michael@0:   void RemoveStyleSheetsFromStyleSets(nsCOMArray<nsIStyleSheet>& aSheets, 
michael@0:                                       nsStyleSet::sheetType aType);
michael@0:   void ResetStylesheetsToURI(nsIURI* aURI);
michael@0:   void FillStyleSet(nsStyleSet* aStyleSet);
michael@0: 
michael@0:   // Return whether all the presshells for this document are safe to flush
michael@0:   bool IsSafeToFlush() const;
michael@0: 
michael@0:   void DispatchPageTransition(mozilla::dom::EventTarget* aDispatchTarget,
michael@0:                               const nsAString& aType,
michael@0:                               bool aPersisted);
michael@0: 
michael@0:   virtual nsPIDOMWindow *GetWindowInternal() const MOZ_OVERRIDE;
michael@0:   virtual nsIScriptGlobalObject* GetScriptHandlingObjectInternal() const MOZ_OVERRIDE;
michael@0:   virtual bool InternalAllowXULXBL() MOZ_OVERRIDE;
michael@0: 
michael@0: #define NS_DOCUMENT_NOTIFY_OBSERVERS(func_, params_)                        \
michael@0:   NS_OBSERVER_ARRAY_NOTIFY_XPCOM_OBSERVERS(mObservers, nsIDocumentObserver, \
michael@0:                                            func_, params_);
michael@0: 
michael@0: #ifdef DEBUG
michael@0:   void VerifyRootContentState();
michael@0: #endif
michael@0: 
michael@0:   nsDocument(const char* aContentType);
michael@0:   virtual ~nsDocument();
michael@0: 
michael@0:   void EnsureOnloadBlocker();
michael@0: 
michael@0:   void NotifyStyleSheetApplicableStateChanged();
michael@0: 
michael@0:   nsTArray<nsIObserver*> mCharSetObservers;
michael@0: 
michael@0:   PLDHashTable *mSubDocuments;
michael@0: 
michael@0:   // Array of owning references to all children
michael@0:   nsAttrAndChildArray mChildren;
michael@0: 
michael@0:   // Pointer to our parser if we're currently in the process of being
michael@0:   // parsed into.
michael@0:   nsCOMPtr<nsIParser> mParser;
michael@0: 
michael@0:   // Weak reference to our sink for in case we no longer have a parser.  This
michael@0:   // will allow us to flush out any pending stuff from the sink even if
michael@0:   // EndLoad() has already happened.
michael@0:   nsWeakPtr mWeakSink;
michael@0: 
michael@0:   nsCOMArray<nsIStyleSheet> mStyleSheets;
michael@0:   nsCOMArray<nsIStyleSheet> mCatalogSheets;
michael@0:   nsCOMArray<nsIStyleSheet> mAdditionalSheets[SheetTypeCount];
michael@0: 
michael@0:   // Array of observers
michael@0:   nsTObserverArray<nsIDocumentObserver*> mObservers;
michael@0: 
michael@0:   // Weak reference to the scope object (aka the script global object)
michael@0:   // that, unlike mScriptGlobalObject, is never unset once set. This
michael@0:   // is a weak reference to avoid leaks due to circular references.
michael@0:   nsWeakPtr mScopeObject;
michael@0: 
michael@0:   // Stack of full-screen elements. When we request full-screen we push the
michael@0:   // full-screen element onto this stack, and when we cancel full-screen we
michael@0:   // pop one off this stack, restoring the previous full-screen state
michael@0:   nsTArray<nsWeakPtr> mFullScreenStack;
michael@0: 
michael@0:   // The root of the doc tree in which this document is in. This is only
michael@0:   // non-null when this document is in fullscreen mode.
michael@0:   nsWeakPtr mFullscreenRoot;
michael@0: 
michael@0: private:
michael@0:   // Array representing the processing stack in the custom elements
michael@0:   // specification. The processing stack is conceptually a stack of
michael@0:   // element queues. Each queue is represented by a sequence of
michael@0:   // CustomElementData in this array, separated by nullptr that
michael@0:   // represent the boundaries of the items in the stack. The first
michael@0:   // queue in the stack is the base element queue.
michael@0:   static mozilla::Maybe<nsTArray<mozilla::dom::CustomElementData*>> sProcessingStack;
michael@0: 
michael@0:   // Flag to prevent re-entrance into base element queue as described in the
michael@0:   // custom elements speicification.
michael@0:   static bool sProcessingBaseElementQueue;
michael@0: 
michael@0:   static bool CustomElementConstructor(JSContext* aCx, unsigned aArgc, JS::Value* aVp);
michael@0: 
michael@0: public:
michael@0:   static void ProcessBaseElementQueue();
michael@0: 
michael@0:   // Modify the prototype and "is" attribute of newly created custom elements.
michael@0:   virtual void SwizzleCustomElement(Element* aElement,
michael@0:                                     const nsAString& aTypeExtension,
michael@0:                                     uint32_t aNamespaceID,
michael@0:                                     mozilla::ErrorResult& rv);
michael@0: 
michael@0:   static bool IsRegisterElementEnabled(JSContext* aCx, JSObject* aObject);
michael@0: 
michael@0:   // The "registry" from the web components spec.
michael@0:   nsRefPtr<mozilla::dom::Registry> mRegistry;
michael@0: 
michael@0:   nsRefPtr<mozilla::EventListenerManager> mListenerManager;
michael@0:   nsRefPtr<mozilla::dom::StyleSheetList> mDOMStyleSheets;
michael@0:   nsRefPtr<nsDOMStyleSheetSetList> mStyleSheetSetList;
michael@0:   nsRefPtr<nsScriptLoader> mScriptLoader;
michael@0:   nsDocHeaderData* mHeaderData;
michael@0:   /* mIdentifierMap works as follows for IDs:
michael@0:    * 1) Attribute changes affect the table immediately (removing and adding
michael@0:    *    entries as needed).
michael@0:    * 2) Removals from the DOM affect the table immediately
michael@0:    * 3) Additions to the DOM always update existing entries for names, and add
michael@0:    *    new ones for IDs.
michael@0:    */
michael@0:   nsTHashtable<nsIdentifierMapEntry> mIdentifierMap;
michael@0: 
michael@0:   nsClassHashtable<nsStringHashKey, nsRadioGroupStruct> mRadioGroups;
michael@0: 
michael@0:   // Recorded time of change to 'loading' state.
michael@0:   mozilla::TimeStamp mLoadingTimeStamp;
michael@0: 
michael@0:   // True if the document has been detached from its content viewer.
michael@0:   bool mIsGoingAway:1;
michael@0:   // True if the document is being destroyed.
michael@0:   bool mInDestructor:1;
michael@0: 
michael@0:   // True if this document has ever had an HTML or SVG <title> element
michael@0:   // bound to it
michael@0:   bool mMayHaveTitleElement:1;
michael@0: 
michael@0:   bool mHasWarnedAboutBoxObjects:1;
michael@0: 
michael@0:   bool mDelayFrameLoaderInitialization:1;
michael@0: 
michael@0:   bool mSynchronousDOMContentLoaded:1;
michael@0: 
michael@0:   bool mInXBLUpdate:1;
michael@0: 
michael@0:   // Whether we're currently holding a lock on all of our images.
michael@0:   bool mLockingImages:1;
michael@0: 
michael@0:   // Whether we currently require our images to animate
michael@0:   bool mAnimatingImages:1;
michael@0: 
michael@0:   // Whether we're currently under a FlushPendingNotifications call to
michael@0:   // our presshell.  This is used to handle flush reentry correctly.
michael@0:   bool mInFlush:1;
michael@0: 
michael@0:   // Parser aborted. True if the parser of this document was forcibly
michael@0:   // terminated instead of letting it finish at its own pace.
michael@0:   bool mParserAborted:1;
michael@0: 
michael@0:   // Whether this document has been approved for fullscreen, either by explicit
michael@0:   // approval via the fullscreen-approval UI, or because it received
michael@0:   // approval because its document's host already had the "fullscreen"
michael@0:   // permission granted when the document requested fullscreen.
michael@0:   // 
michael@0:   // Note if a document's principal doesn't have a host, the permission manager
michael@0:   // can't store permissions for it, so we can only manage approval using this
michael@0:   // flag.
michael@0:   //
michael@0:   // Note we must track this separately from the "fullscreen" permission,
michael@0:   // so that pending pointer lock requests can determine whether documents
michael@0:   // whose principal doesn't have a host (i.e. those which can't store
michael@0:   // permissions in the permission manager) have been approved for fullscreen.
michael@0:   bool mIsApprovedForFullscreen:1;
michael@0: 
michael@0:   // Whether this document has a fullscreen approved observer. Only documents
michael@0:   // which request fullscreen and which don't have a pre-existing approval for
michael@0:   // fullscreen will have an observer.
michael@0:   bool mHasFullscreenApprovedObserver:1;
michael@0: 
michael@0:   friend class nsPointerLockPermissionRequest;
michael@0:   friend class nsCallRequestFullScreen;
michael@0:   // When set, trying to lock the pointer doesn't require permission from the
michael@0:   // user.
michael@0:   bool mAllowRelocking:1;
michael@0: 
michael@0:   bool mAsyncFullscreenPending:1;
michael@0: 
michael@0:   // Keeps track of whether we have a pending
michael@0:   // 'style-sheet-applicable-state-changed' notification.
michael@0:   bool mSSApplicableStateNotificationPending:1;
michael@0: 
michael@0:   uint32_t mCancelledPointerLockRequests;
michael@0: 
michael@0:   uint8_t mXMLDeclarationBits;
michael@0: 
michael@0:   nsInterfaceHashtable<nsPtrHashKey<nsIContent>, nsPIBoxObject> *mBoxObjectTable;
michael@0: 
michael@0:   // A document "without a browsing context" that owns the content of
michael@0:   // HTMLTemplateElement.
michael@0:   nsCOMPtr<nsIDocument> mTemplateContentsOwner;
michael@0: 
michael@0:   // Our update nesting level
michael@0:   uint32_t mUpdateNestLevel;
michael@0: 
michael@0:   // The application cache that this document is associated with, if
michael@0:   // any.  This can change during the lifetime of the document.
michael@0:   nsCOMPtr<nsIApplicationCache> mApplicationCache;
michael@0: 
michael@0:   nsCOMPtr<nsIContent> mFirstBaseNodeWithHref;
michael@0: 
michael@0:   mozilla::EventStates mDocumentState;
michael@0:   mozilla::EventStates mGotDocumentState;
michael@0: 
michael@0:   nsRefPtr<nsDOMNavigationTiming> mTiming;
michael@0: private:
michael@0:   friend class nsUnblockOnloadEvent;
michael@0:   // Recomputes the visibility state but doesn't set the new value.
michael@0:   mozilla::dom::VisibilityState GetVisibilityState() const;
michael@0:   void NotifyStyleSheetAdded(nsIStyleSheet* aSheet, bool aDocumentSheet);
michael@0:   void NotifyStyleSheetRemoved(nsIStyleSheet* aSheet, bool aDocumentSheet);
michael@0: 
michael@0:   void PostUnblockOnloadEvent();
michael@0:   void DoUnblockOnload();
michael@0: 
michael@0:   nsresult CheckFrameOptions();
michael@0:   nsresult InitCSP(nsIChannel* aChannel);
michael@0: 
michael@0:   void FlushCSPWebConsoleErrorQueue()
michael@0:   {
michael@0:     mCSPWebConsoleErrorQueue.Flush(this);
michael@0:   }
michael@0: 
michael@0:   /**
michael@0:    * Find the (non-anonymous) content in this document for aFrame. It will
michael@0:    * be aFrame's content node if that content is in this document and not
michael@0:    * anonymous. Otherwise, when aFrame is in a subdocument, we use the frame
michael@0:    * element containing the subdocument containing aFrame, and/or find the
michael@0:    * nearest non-anonymous ancestor in this document.
michael@0:    * Returns null if there is no such element.
michael@0:    */
michael@0:   nsIContent* GetContentInThisDocument(nsIFrame* aFrame) const;
michael@0: 
michael@0:   // Just like EnableStyleSheetsForSet, but doesn't check whether
michael@0:   // aSheetSet is null and allows the caller to control whether to set
michael@0:   // aSheetSet as the preferred set in the CSSLoader.
michael@0:   void EnableStyleSheetsForSetInternal(const nsAString& aSheetSet,
michael@0:                                        bool aUpdateCSSLoader);
michael@0: 
michael@0:   // Revoke any pending notifications due to mozRequestAnimationFrame calls
michael@0:   void RevokeAnimationFrameNotifications();
michael@0:   // Reschedule any notifications we need to handle
michael@0:   // mozRequestAnimationFrame, if it's OK to do so.
michael@0:   void MaybeRescheduleAnimationFrameNotifications();
michael@0: 
michael@0:   // These are not implemented and not supported.
michael@0:   nsDocument(const nsDocument& aOther);
michael@0:   nsDocument& operator=(const nsDocument& aOther);
michael@0: 
michael@0:   // The layout history state that should be used by nodes in this
michael@0:   // document.  We only actually store a pointer to it when:
michael@0:   // 1)  We have no script global object.
michael@0:   // 2)  We haven't had Destroy() called on us yet.
michael@0:   nsCOMPtr<nsILayoutHistoryState> mLayoutHistoryState;
michael@0: 
michael@0:   // Currently active onload blockers
michael@0:   uint32_t mOnloadBlockCount;
michael@0:   // Onload blockers which haven't been activated yet
michael@0:   uint32_t mAsyncOnloadBlockCount;
michael@0:   nsCOMPtr<nsIRequest> mOnloadBlocker;
michael@0: 
michael@0:   // A hashtable of styled links keyed by address pointer.
michael@0:   nsTHashtable<nsPtrHashKey<mozilla::dom::Link> > mStyledLinks;
michael@0: #ifdef DEBUG
michael@0:   // Indicates whether mStyledLinks was cleared or not.  This is used to track
michael@0:   // state so we can provide useful assertions to consumers of ForgetLink and
michael@0:   // AddStyleRelevantLink.
michael@0:   bool mStyledLinksCleared;
michael@0: #endif
michael@0: 
michael@0:   // Member to store out last-selected stylesheet set.
michael@0:   nsString mLastStyleSheetSet;
michael@0: 
michael@0:   nsTArray<nsRefPtr<nsFrameLoader> > mInitializableFrameLoaders;
michael@0:   nsTArray<nsRefPtr<nsFrameLoader> > mFinalizableFrameLoaders;
michael@0:   nsRefPtr<nsRunnableMethod<nsDocument> > mFrameLoaderRunner;
michael@0: 
michael@0:   nsRevocableEventPtr<nsRunnableMethod<nsDocument, void, false> >
michael@0:     mPendingTitleChangeEvent;
michael@0: 
michael@0:   nsExternalResourceMap mExternalResourceMap;
michael@0: 
michael@0:   // All images in process of being preloaded
michael@0:   nsCOMArray<imgIRequest> mPreloadingImages;
michael@0: 
michael@0:   nsRefPtr<mozilla::dom::DOMImplementation> mDOMImplementation;
michael@0: 
michael@0:   nsRefPtr<nsContentList> mImageMaps;
michael@0: 
michael@0:   nsCString mScrollToRef;
michael@0:   uint8_t mScrolledToRefAlready : 1;
michael@0:   uint8_t mChangeScrollPosWhenScrollingToRef : 1;
michael@0: 
michael@0:   // Tracking for images in the document.
michael@0:   nsDataHashtable< nsPtrHashKey<imgIRequest>, uint32_t> mImageTracker;
michael@0: 
michael@0:   // Tracking for plugins in the document.
michael@0:   nsTHashtable< nsPtrHashKey<nsIObjectLoadingContent> > mPlugins;
michael@0: 
michael@0:   nsRefPtr<mozilla::dom::UndoManager> mUndoManager;
michael@0: 
michael@0:   enum ViewportType {
michael@0:     DisplayWidthHeight,
michael@0:     DisplayWidthHeightNoZoom,
michael@0:     Specified,
michael@0:     Unknown
michael@0:   };
michael@0: 
michael@0:   ViewportType mViewportType;
michael@0: 
michael@0:   // These member variables cache information about the viewport so we don't have to
michael@0:   // recalculate it each time.
michael@0:   bool mValidWidth, mValidHeight;
michael@0:   mozilla::LayoutDeviceToScreenScale mScaleMinFloat;
michael@0:   mozilla::LayoutDeviceToScreenScale mScaleMaxFloat;
michael@0:   mozilla::LayoutDeviceToScreenScale mScaleFloat;
michael@0:   mozilla::CSSToLayoutDeviceScale mPixelRatio;
michael@0:   bool mAutoSize, mAllowZoom, mAllowDoubleTapZoom, mValidScaleFloat, mValidMaxScale, mScaleStrEmpty, mWidthStrEmpty;
michael@0:   mozilla::CSSIntSize mViewportSize;
michael@0: 
michael@0:   nsrefcnt mStackRefCnt;
michael@0:   bool mNeedsReleaseAfterStackRefCntRelease;
michael@0: 
michael@0:   CSPErrorQueue mCSPWebConsoleErrorQueue;
michael@0: 
michael@0: #ifdef DEBUG
michael@0: protected:
michael@0:   bool mWillReparent;
michael@0: #endif
michael@0: };
michael@0: 
michael@0: class nsDocumentOnStack
michael@0: {
michael@0: public:
michael@0:   nsDocumentOnStack(nsDocument* aDoc) : mDoc(aDoc)
michael@0:   {
michael@0:     mDoc->IncreaseStackRefCnt();
michael@0:   }
michael@0:   ~nsDocumentOnStack()
michael@0:   {
michael@0:     mDoc->DecreaseStackRefCnt();
michael@0:   }
michael@0: private:
michael@0:   nsDocument* mDoc;
michael@0: };
michael@0: 
michael@0: #endif /* nsDocument_h___ */