LCOV - code coverage report
Current view: directory - content/base/src - nsDocument.h (source / functions) Found Hit Coverage
Test: app.info Lines: 82 28 34.1 %
Date: 2012-06-02 Functions: 67 16 23.9 %

       1                 : /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
       2                 : /* ***** BEGIN LICENSE BLOCK *****
       3                 :  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
       4                 :  *
       5                 :  * The contents of this file are subject to the Mozilla Public License Version
       6                 :  * 1.1 (the "License"); you may not use this file except in compliance with
       7                 :  * the License. You may obtain a copy of the License at
       8                 :  * http://www.mozilla.org/MPL/
       9                 :  *
      10                 :  * Software distributed under the License is distributed on an "AS IS" basis,
      11                 :  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
      12                 :  * for the specific language governing rights and limitations under the
      13                 :  * License.
      14                 :  *
      15                 :  * The Original Code is mozilla.org code.
      16                 :  *
      17                 :  * The Initial Developer of the Original Code is
      18                 :  * Netscape Communications Corporation.
      19                 :  * Portions created by the Initial Developer are Copyright (C) 1998
      20                 :  * the Initial Developer. All Rights Reserved.
      21                 :  *
      22                 :  * Contributor(s):
      23                 :  *
      24                 :  * Alternatively, the contents of this file may be used under the terms of
      25                 :  * either of the GNU General Public License Version 2 or later (the "GPL"),
      26                 :  * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
      27                 :  * in which case the provisions of the GPL or the LGPL are applicable instead
      28                 :  * of those above. If you wish to allow use of your version of this file only
      29                 :  * under the terms of either the GPL or the LGPL, and not to allow others to
      30                 :  * use your version of this file under the terms of the MPL, indicate your
      31                 :  * decision by deleting the provisions above and replace them with the notice
      32                 :  * and other provisions required by the GPL or the LGPL. If you do not delete
      33                 :  * the provisions above, a recipient may use your version of this file under
      34                 :  * the terms of any one of the MPL, the GPL or the LGPL.
      35                 :  *
      36                 :  * ***** END LICENSE BLOCK ***** */
      37                 : 
      38                 : /*
      39                 :  * Base class for all our document implementations.
      40                 :  */
      41                 : 
      42                 : #ifndef nsDocument_h___
      43                 : #define nsDocument_h___
      44                 : 
      45                 : #include "nsCOMPtr.h"
      46                 : #include "nsAutoPtr.h"
      47                 : #include "nsCRT.h"
      48                 : #include "nsIDocument.h"
      49                 : #include "nsWeakReference.h"
      50                 : #include "nsWeakPtr.h"
      51                 : #include "nsVoidArray.h"
      52                 : #include "nsTArray.h"
      53                 : #include "nsIDOMXMLDocument.h"
      54                 : #include "nsIDOMDocumentXBL.h"
      55                 : #include "nsStubDocumentObserver.h"
      56                 : #include "nsIDOMStyleSheetList.h"
      57                 : #include "nsIScriptGlobalObject.h"
      58                 : #include "nsIDOMEventTarget.h"
      59                 : #include "nsIContent.h"
      60                 : #include "nsEventListenerManager.h"
      61                 : #include "nsIDOMNodeSelector.h"
      62                 : #include "nsIPrincipal.h"
      63                 : #include "nsIParser.h"
      64                 : #include "nsBindingManager.h"
      65                 : #include "nsINodeInfo.h"
      66                 : #include "nsHashtable.h"
      67                 : #include "nsInterfaceHashtable.h"
      68                 : #include "nsIBoxObject.h"
      69                 : #include "nsPIBoxObject.h"
      70                 : #include "nsIScriptObjectPrincipal.h"
      71                 : #include "nsIURI.h"
      72                 : #include "nsScriptLoader.h"
      73                 : #include "nsIRadioGroupContainer.h"
      74                 : #include "nsILayoutHistoryState.h"
      75                 : #include "nsIRequest.h"
      76                 : #include "nsILoadGroup.h"
      77                 : #include "nsTObserverArray.h"
      78                 : #include "nsStubMutationObserver.h"
      79                 : #include "nsIChannel.h"
      80                 : #include "nsCycleCollectionParticipant.h"
      81                 : #include "nsContentList.h"
      82                 : #include "nsGkAtoms.h"
      83                 : #include "nsIApplicationCache.h"
      84                 : #include "nsIApplicationCacheContainer.h"
      85                 : #include "nsStyleSet.h"
      86                 : #include "pldhash.h"
      87                 : #include "nsAttrAndChildArray.h"
      88                 : #include "nsDOMAttributeMap.h"
      89                 : #include "nsThreadUtils.h"
      90                 : #include "nsIContentViewer.h"
      91                 : #include "nsIDOMXPathNSResolver.h"
      92                 : #include "nsIInterfaceRequestor.h"
      93                 : #include "nsILoadContext.h"
      94                 : #include "nsIProgressEventSink.h"
      95                 : #include "nsISecurityEventSink.h"
      96                 : #include "nsIChannelEventSink.h"
      97                 : #include "imgIRequest.h"
      98                 : #include "nsIDOMDOMImplementation.h"
      99                 : #include "nsIDOMTouchEvent.h"
     100                 : #include "nsIInlineEventHandlers.h"
     101                 : #include "nsDataHashtable.h"
     102                 : #include "mozilla/TimeStamp.h"
     103                 : 
     104                 : #define XML_DECLARATION_BITS_DECLARATION_EXISTS   (1 << 0)
     105                 : #define XML_DECLARATION_BITS_ENCODING_EXISTS      (1 << 1)
     106                 : #define XML_DECLARATION_BITS_STANDALONE_EXISTS    (1 << 2)
     107                 : #define XML_DECLARATION_BITS_STANDALONE_YES       (1 << 3)
     108                 : 
     109                 : 
     110                 : class nsEventListenerManager;
     111                 : class nsDOMStyleSheetList;
     112                 : class nsDOMStyleSheetSetList;
     113                 : class nsIOutputStream;
     114                 : class nsDocument;
     115                 : class nsIDTD;
     116                 : class nsIRadioVisitor;
     117                 : class nsIFormControl;
     118                 : struct nsRadioGroupStruct;
     119                 : class nsOnloadBlocker;
     120                 : class nsUnblockOnloadEvent;
     121                 : class nsChildContentList;
     122                 : class nsXMLEventsManager;
     123                 : class nsHTMLStyleSheet;
     124                 : class nsHTMLCSSStyleSheet;
     125                 : class nsDOMNavigationTiming;
     126                 : class nsWindowSizes;
     127                 : 
     128                 : /**
     129                 :  * Right now our identifier map entries contain information for 'name'
     130                 :  * and 'id' mappings of a given string. This is so that
     131                 :  * nsHTMLDocument::ResolveName only has to do one hash lookup instead
     132                 :  * of two. It's not clear whether this still matters for performance.
     133                 :  * 
     134                 :  * We also store the document.all result list here. This is mainly so that
     135                 :  * when all elements with the given ID are removed and we remove
     136                 :  * the ID's nsIdentifierMapEntry, the document.all result is released too.
     137                 :  * Perhaps the document.all results should have their own hashtable
     138                 :  * in nsHTMLDocument.
     139                 :  */
     140                 : class nsIdentifierMapEntry : public nsStringHashKey
     141                 : {
     142                 : public:
     143                 :   typedef mozilla::dom::Element Element;
     144                 :   
     145                 :   nsIdentifierMapEntry(const nsAString& aKey) :
     146                 :     nsStringHashKey(&aKey), mNameContentList(nsnull)
     147                 :   {
     148                 :   }
     149             122 :   nsIdentifierMapEntry(const nsAString *aKey) :
     150             122 :     nsStringHashKey(aKey), mNameContentList(nsnull)
     151                 :   {
     152             122 :   }
     153                 :   nsIdentifierMapEntry(const nsIdentifierMapEntry& aOther) :
     154                 :     nsStringHashKey(&aOther.GetKey())
     155                 :   {
     156                 :     NS_ERROR("Should never be called");
     157                 :   }
     158                 :   ~nsIdentifierMapEntry();
     159                 : 
     160                 :   void SetInvalidName();
     161                 :   bool IsInvalidName();
     162                 :   void AddNameElement(nsIDocument* aDocument, Element* aElement);
     163                 :   void RemoveNameElement(Element* aElement);
     164                 :   bool IsEmpty();
     165               0 :   nsBaseContentList* GetNameContentList() {
     166               0 :     return mNameContentList;
     167                 :   }
     168                 : 
     169                 :   /**
     170                 :    * Returns the element if we know the element associated with this
     171                 :    * id. Otherwise returns null.
     172                 :    */
     173                 :   Element* GetIdElement();
     174                 :   /**
     175                 :    * Returns the list of all elements associated with this id.
     176                 :    */
     177               0 :   const nsSmallVoidArray* GetIdElements() const {
     178               0 :     return &mIdContentList;
     179                 :   }
     180                 :   /**
     181                 :    * If this entry has a non-null image element set (using SetImageElement),
     182                 :    * the image element will be returned, otherwise the same as GetIdElement().
     183                 :    */
     184                 :   Element* GetImageIdElement();
     185                 :   /**
     186                 :    * Append all the elements with this id to aElements
     187                 :    */
     188                 :   void AppendAllIdContent(nsCOMArray<nsIContent>* aElements);
     189                 :   /**
     190                 :    * This can fire ID change callbacks.
     191                 :    * @return true if the content could be added, false if we failed due
     192                 :    * to OOM.
     193                 :    */
     194                 :   bool AddIdElement(Element* aElement);
     195                 :   /**
     196                 :    * This can fire ID change callbacks.
     197                 :    */
     198                 :   void RemoveIdElement(Element* aElement);
     199                 :   /**
     200                 :    * Set the image element override for this ID. This will be returned by
     201                 :    * GetIdElement(true) if non-null.
     202                 :    */
     203                 :   void SetImageElement(Element* aElement);
     204                 : 
     205                 :   bool HasContentChangeCallback() { return mChangeCallbacks != nsnull; }
     206                 :   void AddContentChangeCallback(nsIDocument::IDTargetObserver aCallback,
     207                 :                                 void* aData, bool aForImage);
     208                 :   void RemoveContentChangeCallback(nsIDocument::IDTargetObserver aCallback,
     209                 :                                 void* aData, bool aForImage);
     210                 : 
     211                 :   void Traverse(nsCycleCollectionTraversalCallback* aCallback);
     212                 : 
     213               0 :   void SetDocAllList(nsContentList* aContentList) { mDocAllList = aContentList; }
     214               0 :   nsContentList* GetDocAllList() { return mDocAllList; }
     215                 : 
     216                 :   struct ChangeCallback {
     217                 :     nsIDocument::IDTargetObserver mCallback;
     218                 :     void* mData;
     219                 :     bool mForImage;
     220                 :   };
     221                 : 
     222               0 :   struct ChangeCallbackEntry : public PLDHashEntryHdr {
     223                 :     typedef const ChangeCallback KeyType;
     224                 :     typedef const ChangeCallback* KeyTypePointer;
     225                 : 
     226               0 :     ChangeCallbackEntry(const ChangeCallback* key) :
     227               0 :       mKey(*key) { }
     228                 :     ChangeCallbackEntry(const ChangeCallbackEntry& toCopy) :
     229                 :       mKey(toCopy.mKey) { }
     230                 : 
     231                 :     KeyType GetKey() const { return mKey; }
     232               0 :     bool KeyEquals(KeyTypePointer aKey) const {
     233                 :       return aKey->mCallback == mKey.mCallback &&
     234                 :              aKey->mData == mKey.mData &&
     235               0 :              aKey->mForImage == mKey.mForImage;
     236                 :     }
     237                 : 
     238               0 :     static KeyTypePointer KeyToPointer(KeyType& aKey) { return &aKey; }
     239               0 :     static PLDHashNumber HashKey(KeyTypePointer aKey)
     240                 :     {
     241               0 :       return mozilla::HashGeneric(aKey->mCallback, aKey->mData);
     242                 :     }
     243                 :     enum { ALLOW_MEMMOVE = true };
     244                 :     
     245                 :     ChangeCallback mKey;
     246                 :   };
     247                 : 
     248                 : private:
     249                 :   void FireChangeCallbacks(Element* aOldElement, Element* aNewElement,
     250                 :                            bool aImageOnly = false);
     251                 : 
     252                 :   // empty if there are no elements with this ID.
     253                 :   // The elements are stored as weak pointers.
     254                 :   nsSmallVoidArray mIdContentList;
     255                 :   nsRefPtr<nsBaseContentList> mNameContentList;
     256                 :   nsRefPtr<nsContentList> mDocAllList;
     257                 :   nsAutoPtr<nsTHashtable<ChangeCallbackEntry> > mChangeCallbacks;
     258                 :   nsRefPtr<Element> mImageElement;
     259                 : };
     260                 : 
     261                 : class nsDocHeaderData
     262                 : {
     263                 : public:
     264               4 :   nsDocHeaderData(nsIAtom* aField, const nsAString& aData)
     265               4 :     : mField(aField), mData(aData), mNext(nsnull)
     266                 :   {
     267               4 :   }
     268                 : 
     269               4 :   ~nsDocHeaderData(void)
     270               4 :   {
     271               4 :     delete mNext;
     272               4 :   }
     273                 : 
     274                 :   nsCOMPtr<nsIAtom> mField;
     275                 :   nsString          mData;
     276                 :   nsDocHeaderData*  mNext;
     277                 : };
     278                 : 
     279                 : class nsDOMStyleSheetList : public nsIDOMStyleSheetList,
     280                 :                             public nsStubDocumentObserver
     281                 : {
     282                 : public:
     283                 :   nsDOMStyleSheetList(nsIDocument *aDocument);
     284                 :   virtual ~nsDOMStyleSheetList();
     285                 : 
     286                 :   NS_DECL_ISUPPORTS
     287                 : 
     288                 :   NS_DECL_NSIDOMSTYLESHEETLIST
     289                 : 
     290                 :   // nsIDocumentObserver
     291                 :   NS_DECL_NSIDOCUMENTOBSERVER_STYLESHEETADDED
     292                 :   NS_DECL_NSIDOCUMENTOBSERVER_STYLESHEETREMOVED
     293                 : 
     294                 :   // nsIMutationObserver
     295                 :   NS_DECL_NSIMUTATIONOBSERVER_NODEWILLBEDESTROYED
     296                 : 
     297                 :   nsIStyleSheet* GetItemAt(PRUint32 aIndex);
     298                 : 
     299               0 :   static nsDOMStyleSheetList* FromSupports(nsISupports* aSupports)
     300                 :   {
     301               0 :     nsIDOMStyleSheetList* list = static_cast<nsIDOMStyleSheetList*>(aSupports);
     302                 : #ifdef DEBUG
     303                 :     {
     304               0 :       nsCOMPtr<nsIDOMStyleSheetList> list_qi = do_QueryInterface(aSupports);
     305                 : 
     306                 :       // If this assertion fires the QI implementation for the object in
     307                 :       // question doesn't use the nsIDOMStyleSheetList pointer as the
     308                 :       // nsISupports pointer. That must be fixed, or we'll crash...
     309               0 :       NS_ASSERTION(list_qi == list, "Uh, fix QI!");
     310                 :     }
     311                 : #endif
     312               0 :     return static_cast<nsDOMStyleSheetList*>(list);
     313                 :   }
     314                 : 
     315                 : protected:
     316                 :   PRInt32       mLength;
     317                 :   nsIDocument*  mDocument;
     318                 : };
     319                 : 
     320                 : class nsOnloadBlocker : public nsIRequest
     321                 : {
     322                 : public:
     323            1273 :   nsOnloadBlocker() {}
     324                 : 
     325                 :   NS_DECL_ISUPPORTS
     326                 :   NS_DECL_NSIREQUEST
     327                 : 
     328                 : private:
     329            1271 :   ~nsOnloadBlocker() {}
     330                 : };
     331                 : 
     332                 : class nsExternalResourceMap
     333            1271 : {
     334                 : public:
     335                 :   typedef nsIDocument::ExternalResourceLoad ExternalResourceLoad;
     336                 :   nsExternalResourceMap();
     337                 : 
     338                 :   /**
     339                 :    * Request an external resource document.  This does exactly what
     340                 :    * nsIDocument::RequestExternalResource is documented to do.
     341                 :    */
     342                 :   nsIDocument* RequestResource(nsIURI* aURI,
     343                 :                                nsINode* aRequestingNode,
     344                 :                                nsDocument* aDisplayDocument,
     345                 :                                ExternalResourceLoad** aPendingLoad);
     346                 : 
     347                 :   /**
     348                 :    * Enumerate the resource documents.  See
     349                 :    * nsIDocument::EnumerateExternalResources.
     350                 :    */
     351                 :   void EnumerateResources(nsIDocument::nsSubDocEnumFunc aCallback, void* aData);
     352                 : 
     353                 :   /**
     354                 :    * Traverse ourselves for cycle-collection
     355                 :    */
     356                 :   void Traverse(nsCycleCollectionTraversalCallback* aCallback) const;
     357                 : 
     358                 :   /**
     359                 :    * Shut ourselves down (used for cycle-collection unlink), as well
     360                 :    * as for document destruction.
     361                 :    */
     362            1271 :   void Shutdown()
     363                 :   {
     364            1271 :     mPendingLoads.Clear();
     365            1271 :     mMap.Clear();
     366            1271 :     mHaveShutDown = true;
     367            1271 :   }
     368                 : 
     369               0 :   bool HaveShutDown() const
     370                 :   {
     371               0 :     return mHaveShutDown;
     372                 :   }
     373                 : 
     374                 :   // Needs to be public so we can traverse them sanely
     375                 :   struct ExternalResource
     376               0 :   {
     377                 :     ~ExternalResource();
     378                 :     nsCOMPtr<nsIDocument> mDocument;
     379                 :     nsCOMPtr<nsIContentViewer> mViewer;
     380                 :     nsCOMPtr<nsILoadGroup> mLoadGroup;
     381                 :   };
     382                 : 
     383                 :   // Hide all our viewers
     384                 :   void HideViewers();
     385                 : 
     386                 :   // Show all our viewers
     387                 :   void ShowViewers();
     388                 : 
     389                 : protected:
     390                 :   class PendingLoad : public ExternalResourceLoad,
     391                 :                       public nsIStreamListener
     392               0 :   {
     393                 :   public:
     394               0 :     PendingLoad(nsDocument* aDisplayDocument) :
     395               0 :       mDisplayDocument(aDisplayDocument)
     396               0 :     {}
     397                 : 
     398                 :     NS_DECL_ISUPPORTS
     399                 :     NS_DECL_NSISTREAMLISTENER
     400                 :     NS_DECL_NSIREQUESTOBSERVER
     401                 : 
     402                 :     /**
     403                 :      * Start aURI loading.  This will perform the necessary security checks and
     404                 :      * so forth.
     405                 :      */
     406                 :     nsresult StartLoad(nsIURI* aURI, nsINode* aRequestingNode);
     407                 : 
     408                 :     /**
     409                 :      * Set up an nsIContentViewer based on aRequest.  This is guaranteed to
     410                 :      * put null in *aViewer and *aLoadGroup on all failures.
     411                 :      */
     412                 :     nsresult SetupViewer(nsIRequest* aRequest, nsIContentViewer** aViewer,
     413                 :                          nsILoadGroup** aLoadGroup);
     414                 : 
     415                 :   private:
     416                 :     nsRefPtr<nsDocument> mDisplayDocument;
     417                 :     nsCOMPtr<nsIStreamListener> mTargetListener;
     418                 :     nsCOMPtr<nsIURI> mURI;
     419                 :   };
     420                 :   friend class PendingLoad;
     421                 : 
     422                 :   class LoadgroupCallbacks : public nsIInterfaceRequestor
     423               0 :   {
     424                 :   public:
     425               0 :     LoadgroupCallbacks(nsIInterfaceRequestor* aOtherCallbacks)
     426               0 :       : mCallbacks(aOtherCallbacks)
     427               0 :     {}
     428                 :     NS_DECL_ISUPPORTS
     429                 :     NS_DECL_NSIINTERFACEREQUESTOR
     430                 :   private:
     431                 :     // The only reason it's safe to hold a strong ref here without leaking is
     432                 :     // that the notificationCallbacks on a loadgroup aren't the docshell itself
     433                 :     // but a shim that holds a weak reference to the docshell.
     434                 :     nsCOMPtr<nsIInterfaceRequestor> mCallbacks;
     435                 : 
     436                 :     // Use shims for interfaces that docshell implements directly so that we
     437                 :     // don't hand out references to the docshell.  The shims should all allow
     438                 :     // getInterface back on us, but other than that each one should only
     439                 :     // implement one interface.
     440                 :     
     441                 :     // XXXbz I wish we could just derive the _allcaps thing from _i
     442                 : #define DECL_SHIM(_i, _allcaps)                                              \
     443                 :     class _i##Shim : public nsIInterfaceRequestor,                           \
     444                 :                      public _i                                               \
     445                 :     {                                                                        \
     446                 :     public:                                                                  \
     447                 :       _i##Shim(nsIInterfaceRequestor* aIfreq, _i* aRealPtr)                  \
     448                 :         : mIfReq(aIfreq), mRealPtr(aRealPtr)                                 \
     449                 :       {                                                                      \
     450                 :         NS_ASSERTION(mIfReq, "Expected non-null here");                      \
     451                 :         NS_ASSERTION(mRealPtr, "Expected non-null here");                    \
     452                 :       }                                                                      \
     453                 :       NS_DECL_ISUPPORTS                                                      \
     454                 :       NS_FORWARD_NSIINTERFACEREQUESTOR(mIfReq->);                            \
     455                 :       NS_FORWARD_##_allcaps(mRealPtr->);                                     \
     456                 :     private:                                                                 \
     457                 :       nsCOMPtr<nsIInterfaceRequestor> mIfReq;                                \
     458                 :       nsCOMPtr<_i> mRealPtr;                                                 \
     459                 :     };
     460                 : 
     461               0 :     DECL_SHIM(nsILoadContext, NSILOADCONTEXT)
     462               0 :     DECL_SHIM(nsIProgressEventSink, NSIPROGRESSEVENTSINK)
     463               0 :     DECL_SHIM(nsIChannelEventSink, NSICHANNELEVENTSINK)
     464               0 :     DECL_SHIM(nsISecurityEventSink, NSISECURITYEVENTSINK)
     465               0 :     DECL_SHIM(nsIApplicationCacheContainer, NSIAPPLICATIONCACHECONTAINER)
     466                 : #undef DECL_SHIM
     467                 :   };
     468                 :   
     469                 :   /**
     470                 :    * Add an ExternalResource for aURI.  aViewer and aLoadGroup might be null
     471                 :    * when this is called if the URI didn't result in an XML document.  This
     472                 :    * function makes sure to remove the pending load for aURI, if any, from our
     473                 :    * hashtable, and to notify its observers, if any.
     474                 :    */
     475                 :   nsresult AddExternalResource(nsIURI* aURI, nsIContentViewer* aViewer,
     476                 :                                nsILoadGroup* aLoadGroup,
     477                 :                                nsIDocument* aDisplayDocument);
     478                 :   
     479                 :   nsClassHashtable<nsURIHashKey, ExternalResource> mMap;
     480                 :   nsRefPtrHashtable<nsURIHashKey, PendingLoad> mPendingLoads;
     481                 :   bool mHaveShutDown;
     482                 : };
     483                 : 
     484                 : // Base class for our document implementations.
     485                 : //
     486                 : // Note that this class *implements* nsIDOMXMLDocument, but it's not
     487                 : // really an nsIDOMXMLDocument. The reason for implementing
     488                 : // nsIDOMXMLDocument on this class is to avoid having to duplicate all
     489                 : // its inherited methods on document classes that *are*
     490                 : // nsIDOMXMLDocument's. nsDocument's QI should *not* claim to support
     491                 : // nsIDOMXMLDocument unless someone writes a real implementation of
     492                 : // the interface.
     493                 : class nsDocument : public nsIDocument,
     494                 :                    public nsIDOMXMLDocument, // inherits nsIDOMDocument
     495                 :                    public nsIDOMDocumentXBL,
     496                 :                    public nsSupportsWeakReference,
     497                 :                    public nsIScriptObjectPrincipal,
     498                 :                    public nsIRadioGroupContainer,
     499                 :                    public nsIApplicationCacheContainer,
     500                 :                    public nsStubMutationObserver,
     501                 :                    public nsIDOMDocumentTouch,
     502                 :                    public nsIInlineEventHandlers
     503                 : {
     504                 : public:
     505                 :   typedef mozilla::dom::Element Element;
     506                 : 
     507            1396 :   NS_DECL_CYCLE_COLLECTING_ISUPPORTS
     508                 : 
     509                 :   NS_DECL_SIZEOF_EXCLUDING_THIS
     510                 : 
     511                 :   using nsINode::GetScriptTypeID;
     512                 : 
     513                 :   virtual void Reset(nsIChannel *aChannel, nsILoadGroup *aLoadGroup);
     514                 :   virtual void ResetToURI(nsIURI *aURI, nsILoadGroup *aLoadGroup,
     515                 :                           nsIPrincipal* aPrincipal);
     516                 : 
     517                 :   // StartDocumentLoad is pure virtual so that subclasses must override it.
     518                 :   // The nsDocument StartDocumentLoad does some setup, but does NOT set
     519                 :   // *aDocListener; this is the job of subclasses.
     520                 :   virtual nsresult StartDocumentLoad(const char* aCommand,
     521                 :                                      nsIChannel* aChannel,
     522                 :                                      nsILoadGroup* aLoadGroup,
     523                 :                                      nsISupports* aContainer,
     524                 :                                      nsIStreamListener **aDocListener,
     525                 :                                      bool aReset = true,
     526                 :                                      nsIContentSink* aContentSink = nsnull) = 0;
     527                 : 
     528                 :   virtual void StopDocumentLoad();
     529                 : 
     530                 :   virtual void NotifyPossibleTitleChange(bool aBoundTitleElement);
     531                 : 
     532                 :   virtual void SetDocumentURI(nsIURI* aURI);
     533                 : 
     534                 :   /**
     535                 :    * Set the principal responsible for this document.
     536                 :    */
     537                 :   virtual void SetPrincipal(nsIPrincipal *aPrincipal);
     538                 : 
     539                 :   /**
     540                 :    * Get the Content-Type of this document.
     541                 :    */
     542                 :   // NS_IMETHOD GetContentType(nsAString& aContentType);
     543                 :   // Already declared in nsIDOMDocument
     544                 : 
     545                 :   /**
     546                 :    * Set the Content-Type of this document.
     547                 :    */
     548                 :   virtual void SetContentType(const nsAString& aContentType);
     549                 : 
     550                 :   virtual nsresult SetBaseURI(nsIURI* aURI);
     551                 : 
     552                 :   /**
     553                 :    * Get/Set the base target of a link in a document.
     554                 :    */
     555                 :   virtual void GetBaseTarget(nsAString &aBaseTarget);
     556                 : 
     557                 :   /**
     558                 :    * Return a standard name for the document's character set. This will
     559                 :    * trigger a startDocumentLoad if necessary to answer the question.
     560                 :    */
     561                 :   virtual void SetDocumentCharacterSet(const nsACString& aCharSetID);
     562                 : 
     563                 :   /**
     564                 :    * Add an observer that gets notified whenever the charset changes.
     565                 :    */
     566                 :   virtual nsresult AddCharSetObserver(nsIObserver* aObserver);
     567                 : 
     568                 :   /**
     569                 :    * Remove a charset observer.
     570                 :    */
     571                 :   virtual void RemoveCharSetObserver(nsIObserver* aObserver);
     572                 : 
     573                 :   virtual Element* AddIDTargetObserver(nsIAtom* aID, IDTargetObserver aObserver,
     574                 :                                        void* aData, bool aForImage);
     575                 :   virtual void RemoveIDTargetObserver(nsIAtom* aID, IDTargetObserver aObserver,
     576                 :                                       void* aData, bool aForImage);
     577                 : 
     578                 :   /**
     579                 :    * Access HTTP header data (this may also get set from other sources, like
     580                 :    * HTML META tags).
     581                 :    */
     582                 :   virtual void GetHeaderData(nsIAtom* aHeaderField, nsAString& aData) const;
     583                 :   virtual void SetHeaderData(nsIAtom* aheaderField,
     584                 :                              const nsAString& aData);
     585                 : 
     586                 :   /**
     587                 :    * Create a new presentation shell that will use aContext for
     588                 :    * its presentation context (presentation context's <b>must not</b> be
     589                 :    * shared among multiple presentation shell's).
     590                 :    */
     591                 :   virtual nsresult CreateShell(nsPresContext* aContext,
     592                 :                                nsIViewManager* aViewManager,
     593                 :                                nsStyleSet* aStyleSet,
     594                 :                                nsIPresShell** aInstancePtrResult);
     595                 :   virtual void DeleteShell();
     596                 : 
     597                 :   virtual nsresult SetSubDocumentFor(Element* aContent,
     598                 :                                      nsIDocument* aSubDoc);
     599                 :   virtual nsIDocument* GetSubDocumentFor(nsIContent* aContent) const;
     600                 :   virtual Element* FindContentForSubDocument(nsIDocument *aDocument) const;
     601                 :   virtual Element* GetRootElementInternal() const;
     602                 : 
     603                 :   /**
     604                 :    * Get the style sheets owned by this document.
     605                 :    * These are ordered, highest priority last
     606                 :    */
     607                 :   virtual PRInt32 GetNumberOfStyleSheets() const;
     608                 :   virtual nsIStyleSheet* GetStyleSheetAt(PRInt32 aIndex) const;
     609                 :   virtual PRInt32 GetIndexOfStyleSheet(nsIStyleSheet* aSheet) const;
     610                 :   virtual void AddStyleSheet(nsIStyleSheet* aSheet);
     611                 :   virtual void RemoveStyleSheet(nsIStyleSheet* aSheet);
     612                 : 
     613                 :   virtual void UpdateStyleSheets(nsCOMArray<nsIStyleSheet>& aOldSheets,
     614                 :                                  nsCOMArray<nsIStyleSheet>& aNewSheets);
     615                 :   virtual void AddStyleSheetToStyleSets(nsIStyleSheet* aSheet);
     616                 :   virtual void RemoveStyleSheetFromStyleSets(nsIStyleSheet* aSheet);
     617                 : 
     618                 :   virtual void InsertStyleSheetAt(nsIStyleSheet* aSheet, PRInt32 aIndex);
     619                 :   virtual void SetStyleSheetApplicableState(nsIStyleSheet* aSheet,
     620                 :                                             bool aApplicable);
     621                 : 
     622                 :   virtual PRInt32 GetNumberOfCatalogStyleSheets() const;
     623                 :   virtual nsIStyleSheet* GetCatalogStyleSheetAt(PRInt32 aIndex) const;
     624                 :   virtual void AddCatalogStyleSheet(nsIStyleSheet* aSheet);
     625                 :   virtual void EnsureCatalogStyleSheet(const char *aStyleSheetURI);
     626                 : 
     627               0 :   virtual nsIChannel* GetChannel() const {
     628               0 :     return mChannel;
     629                 :   }
     630                 : 
     631                 :   /**
     632                 :    * Get this document's attribute stylesheet.  May return null if
     633                 :    * there isn't one.
     634                 :    */
     635             789 :   virtual nsHTMLStyleSheet* GetAttributeStyleSheet() const {
     636             789 :     return mAttrStyleSheet;
     637                 :   }
     638                 : 
     639                 :   /**
     640                 :    * Get this document's inline style sheet.  May return null if there
     641                 :    * isn't one
     642                 :    */
     643               0 :   virtual nsHTMLCSSStyleSheet* GetInlineStyleSheet() const {
     644               0 :     return mStyleAttrStyleSheet;
     645                 :   }
     646                 :   
     647                 :   /**
     648                 :    * Set the object from which a document can get a script context.
     649                 :    * This is the context within which all scripts (during document
     650                 :    * creation and during event handling) will run.
     651                 :    */
     652                 :   virtual nsIScriptGlobalObject* GetScriptGlobalObject() const;
     653                 :   virtual void SetScriptGlobalObject(nsIScriptGlobalObject* aGlobalObject);
     654                 : 
     655                 :   virtual void SetScriptHandlingObject(nsIScriptGlobalObject* aScriptObject);
     656                 : 
     657                 :   virtual nsIScriptGlobalObject* GetScopeObject();
     658                 : 
     659                 :   /**
     660                 :    * Get the script loader for this document
     661                 :    */
     662                 :   virtual nsScriptLoader* ScriptLoader();
     663                 : 
     664                 :   /**
     665                 :    * Add/Remove an element to the document's id and name hashes
     666                 :    */
     667                 :   virtual void AddToIdTable(Element* aElement, nsIAtom* aId);
     668                 :   virtual void RemoveFromIdTable(Element* aElement, nsIAtom* aId);
     669                 :   virtual void AddToNameTable(Element* aElement, nsIAtom* aName);
     670                 :   virtual void RemoveFromNameTable(Element* aElement, nsIAtom* aName);
     671                 : 
     672                 :   /**
     673                 :    * Add a new observer of document change notifications. Whenever
     674                 :    * content is changed, appended, inserted or removed the observers are
     675                 :    * informed.
     676                 :    */
     677                 :   virtual void AddObserver(nsIDocumentObserver* aObserver);
     678                 : 
     679                 :   /**
     680                 :    * Remove an observer of document change notifications. This will
     681                 :    * return false if the observer cannot be found.
     682                 :    */
     683                 :   virtual bool RemoveObserver(nsIDocumentObserver* aObserver);
     684                 : 
     685                 :   // Observation hooks used to propagate notifications to document
     686                 :   // observers.
     687                 :   virtual void BeginUpdate(nsUpdateType aUpdateType);
     688                 :   virtual void EndUpdate(nsUpdateType aUpdateType);
     689                 :   virtual void BeginLoad();
     690                 :   virtual void EndLoad();
     691                 : 
     692                 :   virtual void SetReadyStateInternal(ReadyState rs);
     693                 :   virtual ReadyState GetReadyStateEnum();
     694                 : 
     695                 :   virtual void ContentStateChanged(nsIContent* aContent,
     696                 :                                    nsEventStates aStateMask);
     697                 :   virtual void DocumentStatesChanged(nsEventStates aStateMask);
     698                 : 
     699                 :   virtual void StyleRuleChanged(nsIStyleSheet* aStyleSheet,
     700                 :                                 nsIStyleRule* aOldStyleRule,
     701                 :                                 nsIStyleRule* aNewStyleRule);
     702                 :   virtual void StyleRuleAdded(nsIStyleSheet* aStyleSheet,
     703                 :                               nsIStyleRule* aStyleRule);
     704                 :   virtual void StyleRuleRemoved(nsIStyleSheet* aStyleSheet,
     705                 :                                 nsIStyleRule* aStyleRule);
     706                 : 
     707                 :   virtual void FlushPendingNotifications(mozFlushType aType);
     708                 :   virtual void FlushExternalResources(mozFlushType aType);
     709                 :   virtual void SetXMLDeclaration(const PRUnichar *aVersion,
     710                 :                                  const PRUnichar *aEncoding,
     711                 :                                  const PRInt32 aStandalone);
     712                 :   virtual void GetXMLDeclaration(nsAString& aVersion,
     713                 :                                  nsAString& aEncoding,
     714                 :                                  nsAString& Standalone);
     715                 :   virtual bool IsScriptEnabled();
     716                 : 
     717                 :   virtual void OnPageShow(bool aPersisted, nsIDOMEventTarget* aDispatchStartTarget);
     718                 :   virtual void OnPageHide(bool aPersisted, nsIDOMEventTarget* aDispatchStartTarget);
     719                 :   
     720                 :   virtual void WillDispatchMutationEvent(nsINode* aTarget);
     721                 :   virtual void MutationEventDispatched(nsINode* aTarget);
     722                 : 
     723                 :   // nsINode
     724                 :   virtual bool IsNodeOfType(PRUint32 aFlags) const;
     725                 :   virtual PRUint16 NodeType();
     726                 :   virtual void NodeName(nsAString& aNodeName);
     727                 :   virtual nsIContent *GetChildAt(PRUint32 aIndex) const;
     728                 :   virtual nsIContent * const * GetChildArray(PRUint32* aChildCount) const;
     729                 :   virtual PRInt32 IndexOf(nsINode* aPossibleChild) const;
     730                 :   virtual PRUint32 GetChildCount() const;
     731                 :   virtual nsresult InsertChildAt(nsIContent* aKid, PRUint32 aIndex,
     732                 :                                  bool aNotify);
     733                 :   virtual nsresult AppendChildTo(nsIContent* aKid, bool aNotify);
     734                 :   virtual nsresult RemoveChildAt(PRUint32 aIndex, bool aNotify);
     735               0 :   virtual nsresult Clone(nsINodeInfo *aNodeInfo, nsINode **aResult) const
     736                 :   {
     737               0 :     return NS_ERROR_NOT_IMPLEMENTED;
     738                 :   }
     739                 : 
     740                 :   // nsIRadioGroupContainer
     741                 :   NS_IMETHOD WalkRadioGroup(const nsAString& aName,
     742                 :                             nsIRadioVisitor* aVisitor,
     743                 :                             bool aFlushContent);
     744                 :   NS_IMETHOD SetCurrentRadioButton(const nsAString& aName,
     745                 :                                    nsIDOMHTMLInputElement* aRadio);
     746                 :   NS_IMETHOD GetCurrentRadioButton(const nsAString& aName,
     747                 :                                    nsIDOMHTMLInputElement** aRadio);
     748                 :   NS_IMETHOD GetPositionInGroup(nsIDOMHTMLInputElement *aRadio,
     749                 :                                 PRInt32 *aPositionIndex,
     750                 :                                 PRInt32 *aItemsInGroup);
     751                 :   NS_IMETHOD GetNextRadioButton(const nsAString& aName,
     752                 :                                 const bool aPrevious,
     753                 :                                 nsIDOMHTMLInputElement*  aFocusedRadio,
     754                 :                                 nsIDOMHTMLInputElement** aRadioOut);
     755                 :   NS_IMETHOD AddToRadioGroup(const nsAString& aName,
     756                 :                              nsIFormControl* aRadio);
     757                 :   NS_IMETHOD RemoveFromRadioGroup(const nsAString& aName,
     758                 :                                   nsIFormControl* aRadio);
     759                 :   virtual PRUint32 GetRequiredRadioCount(const nsAString& aName) const;
     760                 :   virtual void RadioRequiredChanged(const nsAString& aName,
     761                 :                                     nsIFormControl* aRadio);
     762                 :   virtual bool GetValueMissingState(const nsAString& aName) const;
     763                 :   virtual void SetValueMissingState(const nsAString& aName, bool aValue);
     764                 : 
     765                 :   // for radio group
     766                 :   nsresult GetRadioGroup(const nsAString& aName,
     767                 :                          nsRadioGroupStruct **aRadioGroup);
     768                 : 
     769                 :   // nsIDOMNode
     770                 :   NS_DECL_NSIDOMNODE
     771                 : 
     772                 :   // nsIDOMDocument
     773                 :   NS_DECL_NSIDOMDOCUMENT
     774                 : 
     775                 :   // nsIDOMXMLDocument
     776                 :   NS_DECL_NSIDOMXMLDOCUMENT
     777                 : 
     778                 :   // nsIDOMDocumentXBL
     779                 :   NS_DECL_NSIDOMDOCUMENTXBL
     780                 : 
     781                 :   // nsIDOMEventTarget
     782                 :   virtual nsresult PreHandleEvent(nsEventChainPreVisitor& aVisitor);
     783                 :   virtual nsEventListenerManager*
     784                 :     GetListenerManager(bool aCreateIfNotFound);
     785                 : 
     786                 :   // nsIScriptObjectPrincipal
     787                 :   virtual nsIPrincipal* GetPrincipal();
     788                 : 
     789                 :   // nsIApplicationCacheContainer
     790                 :   NS_DECL_NSIAPPLICATIONCACHECONTAINER
     791                 : 
     792                 :   // nsITouchEventReceiver
     793                 :   NS_DECL_NSITOUCHEVENTRECEIVER
     794                 : 
     795                 :   // nsIDOMDocumentTouch
     796                 :   NS_DECL_NSIDOMDOCUMENTTOUCH
     797                 : 
     798                 :   // nsIInlineEventHandlers
     799                 :   NS_DECL_NSIINLINEEVENTHANDLERS
     800                 : 
     801                 :   virtual nsresult Init();
     802                 :   
     803                 :   virtual void AddXMLEventsContent(nsIContent * aXMLEventsElement);
     804                 : 
     805                 :   virtual nsresult CreateElem(const nsAString& aName, nsIAtom *aPrefix,
     806                 :                               PRInt32 aNamespaceID,
     807                 :                               nsIContent **aResult);
     808                 : 
     809                 :   nsresult CreateElement(const nsAString& aTagName,
     810                 :                          nsIContent** aReturn);
     811                 :   nsresult CreateElementNS(const nsAString& aNamespaceURI,
     812                 :                            const nsAString& aQualifiedName,
     813                 :                            nsIContent** aReturn);
     814                 : 
     815                 :   nsresult CreateTextNode(const nsAString& aData, nsIContent** aReturn);
     816                 : 
     817                 :   virtual NS_HIDDEN_(nsresult) Sanitize();
     818                 : 
     819                 :   virtual NS_HIDDEN_(void) EnumerateSubDocuments(nsSubDocEnumFunc aCallback,
     820                 :                                                  void *aData);
     821                 : 
     822                 :   virtual NS_HIDDEN_(bool) CanSavePresentation(nsIRequest *aNewRequest);
     823                 :   virtual NS_HIDDEN_(void) Destroy();
     824                 :   virtual NS_HIDDEN_(void) RemovedFromDocShell();
     825                 :   virtual NS_HIDDEN_(already_AddRefed<nsILayoutHistoryState>) GetLayoutHistoryState() const;
     826                 : 
     827                 :   virtual NS_HIDDEN_(void) BlockOnload();
     828                 :   virtual NS_HIDDEN_(void) UnblockOnload(bool aFireSync);
     829                 : 
     830                 :   virtual NS_HIDDEN_(void) AddStyleRelevantLink(mozilla::dom::Link* aLink);
     831                 :   virtual NS_HIDDEN_(void) ForgetLink(mozilla::dom::Link* aLink);
     832                 : 
     833                 :   NS_HIDDEN_(void) ClearBoxObjectFor(nsIContent* aContent);
     834                 :   NS_IMETHOD GetBoxObjectFor(nsIDOMElement* aElement, nsIBoxObject** aResult);
     835                 : 
     836                 :   virtual NS_HIDDEN_(nsresult) GetXBLChildNodesFor(nsIContent* aContent,
     837                 :                                                    nsIDOMNodeList** aResult);
     838                 :   virtual NS_HIDDEN_(nsresult) GetContentListFor(nsIContent* aContent,
     839                 :                                                  nsIDOMNodeList** aResult);
     840                 : 
     841                 :   virtual NS_HIDDEN_(nsresult) ElementFromPointHelper(float aX, float aY,
     842                 :                                                       bool aIgnoreRootScrollFrame,
     843                 :                                                       bool aFlushLayout,
     844                 :                                                       nsIDOMElement** aReturn);
     845                 : 
     846                 :   virtual NS_HIDDEN_(nsresult) NodesFromRectHelper(float aX, float aY,
     847                 :                                                    float aTopSize, float aRightSize,
     848                 :                                                    float aBottomSize, float aLeftSize,
     849                 :                                                    bool aIgnoreRootScrollFrame,
     850                 :                                                    bool aFlushLayout,
     851                 :                                                    nsIDOMNodeList** aReturn);
     852                 : 
     853                 :   virtual NS_HIDDEN_(void) FlushSkinBindings();
     854                 : 
     855                 :   virtual NS_HIDDEN_(nsresult) InitializeFrameLoader(nsFrameLoader* aLoader);
     856                 :   virtual NS_HIDDEN_(nsresult) FinalizeFrameLoader(nsFrameLoader* aLoader);
     857                 :   virtual NS_HIDDEN_(void) TryCancelFrameLoaderInitialization(nsIDocShell* aShell);
     858                 :   virtual NS_HIDDEN_(bool) FrameLoaderScheduledToBeFinalized(nsIDocShell* aShell);
     859                 :   virtual NS_HIDDEN_(nsIDocument*)
     860                 :     RequestExternalResource(nsIURI* aURI,
     861                 :                             nsINode* aRequestingNode,
     862                 :                             ExternalResourceLoad** aPendingLoad);
     863                 :   virtual NS_HIDDEN_(void)
     864                 :     EnumerateExternalResources(nsSubDocEnumFunc aCallback, void* aData);
     865                 : 
     866                 :   nsTArray<nsCString> mFileDataUris;
     867                 : 
     868                 :   // Returns our (lazily-initialized) animation controller.
     869                 :   // If HasAnimationController is true, this is guaranteed to return non-null.
     870                 :   nsSMILAnimationController* GetAnimationController();
     871                 : 
     872                 :   void SetImagesNeedAnimating(bool aAnimating);
     873                 : 
     874                 :   virtual void SuppressEventHandling(PRUint32 aIncrease);
     875                 : 
     876                 :   virtual void UnsuppressEventHandlingAndFireEvents(bool aFireEvents);
     877                 :   
     878               0 :   void DecreaseEventSuppression() {
     879               0 :     --mEventsSuppressed;
     880               0 :     MaybeRescheduleAnimationFrameNotifications();
     881               0 :   }
     882                 : 
     883          373383 :   NS_DECL_CYCLE_COLLECTION_SKIPPABLE_SCRIPT_HOLDER_CLASS_AMBIGUOUS(nsDocument,
     884                 :                                                                    nsIDocument)
     885                 : 
     886                 :   void DoNotifyPossibleTitleChange();
     887                 : 
     888               0 :   nsExternalResourceMap& ExternalResourceMap()
     889                 :   {
     890               0 :     return mExternalResourceMap;
     891                 :   }
     892                 : 
     893            1273 :   void SetLoadedAsData(bool aLoadedAsData) { mLoadedAsData = aLoadedAsData; }
     894               0 :   void SetLoadedAsInteractiveData(bool aLoadedAsInteractiveData)
     895                 :   {
     896               0 :     mLoadedAsInteractiveData = aLoadedAsInteractiveData;
     897               0 :   }
     898                 : 
     899                 :   nsresult CloneDocHelper(nsDocument* clone) const;
     900                 : 
     901                 :   void MaybeInitializeFinalizeFrameLoaders();
     902                 : 
     903                 :   void MaybeEndOutermostXBLUpdate();
     904                 : 
     905                 :   virtual void MaybePreLoadImage(nsIURI* uri,
     906                 :                                  const nsAString &aCrossOriginAttr);
     907                 : 
     908                 :   virtual void PreloadStyle(nsIURI* uri, const nsAString& charset);
     909                 : 
     910                 :   virtual nsresult LoadChromeSheetSync(nsIURI* uri, bool isAgentSheet,
     911                 :                                        nsCSSStyleSheet** sheet);
     912                 : 
     913                 :   virtual nsISupports* GetCurrentContentSink();
     914                 : 
     915                 :   virtual nsEventStates GetDocumentState();
     916                 : 
     917                 :   virtual void RegisterFileDataUri(const nsACString& aUri);
     918                 :   virtual void UnregisterFileDataUri(const nsACString& aUri);
     919                 : 
     920                 :   // Only BlockOnload should call this!
     921                 :   void AsyncBlockOnload();
     922                 : 
     923                 :   virtual void SetScrollToRef(nsIURI *aDocumentURI);
     924                 :   virtual void ScrollToRef();
     925                 :   virtual void ResetScrolledToRefAlready();
     926                 :   virtual void SetChangeScrollPosWhenScrollingToRef(bool aValue);
     927                 : 
     928                 :   already_AddRefed<nsContentList>
     929              26 :   GetElementsByTagName(const nsAString& aTagName) {
     930              26 :     return NS_GetContentList(this, kNameSpaceID_Unknown, aTagName);
     931                 :   }
     932                 :   already_AddRefed<nsContentList>
     933                 :     GetElementsByTagNameNS(const nsAString& aNamespaceURI,
     934                 :                            const nsAString& aLocalName);
     935                 : 
     936                 :   virtual Element *GetElementById(const nsAString& aElementId);
     937                 :   virtual const nsSmallVoidArray* GetAllElementsForId(const nsAString& aElementId) const;
     938                 : 
     939                 :   virtual Element *LookupImageElement(const nsAString& aElementId);
     940                 : 
     941                 :   virtual NS_HIDDEN_(nsresult) AddImage(imgIRequest* aImage);
     942                 :   virtual NS_HIDDEN_(nsresult) RemoveImage(imgIRequest* aImage);
     943                 :   virtual NS_HIDDEN_(nsresult) SetImageLockingState(bool aLocked);
     944                 : 
     945                 :   virtual nsresult GetStateObject(nsIVariant** aResult);
     946                 : 
     947                 :   virtual nsDOMNavigationTiming* GetNavigationTiming() const;
     948                 :   virtual nsresult SetNavigationTiming(nsDOMNavigationTiming* aTiming);
     949                 : 
     950                 :   virtual Element* FindImageMap(const nsAString& aNormalizedMapName);
     951                 : 
     952                 :   virtual void NotifyAudioAvailableListener();
     953                 : 
     954               0 :   bool HasAudioAvailableListeners()
     955                 :   {
     956               0 :     return mHasAudioAvailableListener;
     957                 :   }
     958                 : 
     959                 :   virtual Element* GetFullScreenElement();
     960                 :   virtual void AsyncRequestFullScreen(Element* aElement);
     961                 :   virtual void RestorePreviousFullScreenState();
     962                 :   virtual bool IsFullScreenDoc();
     963                 :   static void ExitFullScreen();
     964                 : 
     965                 :   // This is called asynchronously by nsIDocument::AsyncRequestFullScreen()
     966                 :   // to move document into full-screen mode if allowed. aWasCallerChrome
     967                 :   // should be true when nsIDocument::AsyncRequestFullScreen() was called
     968                 :   // by chrome code.
     969                 :   void RequestFullScreen(Element* aElement, bool aWasCallerChrome);
     970                 : 
     971                 :   // Removes all elements from the full-screen stack, removing full-scren
     972                 :   // styles from the top element in the stack.
     973                 :   void ClearFullScreenStack();
     974                 : 
     975                 :   // Pushes aElement onto the full-screen stack, and removes full-screen styles
     976                 :   // from the former full-screen stack top, and its ancestors, and applies the
     977                 :   // styles to aElement. aElement becomes the new "full-screen element".
     978                 :   bool FullScreenStackPush(Element* aElement);
     979                 : 
     980                 :   // Remove the top element from the full-screen stack. Removes the full-screen
     981                 :   // styles from the former top element, and applies them to the new top
     982                 :   // element, if there is one.
     983                 :   void FullScreenStackPop();
     984                 : 
     985                 :   // Returns the top element from the full-screen stack.
     986                 :   Element* FullScreenStackTop();
     987                 : 
     988                 :   // This method may fire a DOM event; if it does so it will happen
     989                 :   // synchronously.
     990                 :   void UpdateVisibilityState();
     991                 :   // Posts an event to call UpdateVisibilityState
     992                 :   virtual void PostVisibilityUpdateEvent();
     993                 : 
     994                 :   virtual void DocSizeOfExcludingThis(nsWindowSizes* aWindowSizes) const;
     995                 :   // DocSizeOfIncludingThis is inherited from nsIDocument.
     996                 : 
     997                 : protected:
     998                 :   friend class nsNodeUtils;
     999                 : 
    1000                 :   // Returns true if a request for DOM full-screen is currently enabled in
    1001                 :   // this document. This returns true if there are no windowed plugins in this
    1002                 :   // doc tree, and if the document is visible, and if the api is not
    1003                 :   // disabled by pref. aIsCallerChrome must contain the return value of
    1004                 :   // nsContentUtils::IsCallerChrome() from the context we're checking.
    1005                 :   // If aLogFailure is true, an appropriate warning message is logged to the
    1006                 :   // console, and a "mozfullscreenerror" event is dispatched to this document.
    1007                 :   bool IsFullScreenEnabled(bool aIsCallerChrome, bool aLogFailure);
    1008                 : 
    1009                 :   /**
    1010                 :    * Check that aId is not empty and log a message to the console
    1011                 :    * service if it is.
    1012                 :    * @returns true if aId looks correct, false otherwise.
    1013                 :    */
    1014              78 :   inline bool CheckGetElementByIdArg(const nsAString& aId)
    1015                 :   {
    1016              78 :     if (aId.IsEmpty()) {
    1017               0 :       ReportEmptyGetElementByIdArg();
    1018               0 :       return false;
    1019                 :     }
    1020              78 :     return true;
    1021                 :   }
    1022                 : 
    1023                 :   void ReportEmptyGetElementByIdArg();
    1024                 : 
    1025                 :   void DispatchContentLoadedEvents();
    1026                 : 
    1027                 :   void RetrieveRelevantHeaders(nsIChannel *aChannel);
    1028                 : 
    1029                 :   static bool TryChannelCharset(nsIChannel *aChannel,
    1030                 :                                   PRInt32& aCharsetSource,
    1031                 :                                   nsACString& aCharset);
    1032                 : 
    1033                 :   // Call this before the document does something that will unbind all content.
    1034                 :   // That will stop us from doing a lot of work as each element is removed.
    1035                 :   void DestroyElementMaps();
    1036                 : 
    1037                 :   // Refreshes the hrefs of all the links in the document.
    1038                 :   void RefreshLinkHrefs();
    1039                 : 
    1040                 :   nsIContent* GetFirstBaseNodeWithHref();
    1041                 :   nsresult SetFirstBaseNodeWithHref(nsIContent *node);
    1042                 : 
    1043                 :   // Get the first <title> element with the given IsNodeOfType type, or
    1044                 :   // return null if there isn't one
    1045                 :   nsIContent* GetTitleContent(PRUint32 aNodeType);
    1046                 :   // Find the first "title" element in the given IsNodeOfType type and
    1047                 :   // append the concatenation of its text node children to aTitle. Do
    1048                 :   // nothing if there is no such element.
    1049                 :   void GetTitleFromElement(PRUint32 aNodeType, nsAString& aTitle);
    1050                 : 
    1051                 :   nsresult doCreateShell(nsPresContext* aContext,
    1052                 :                          nsIViewManager* aViewManager, nsStyleSet* aStyleSet,
    1053                 :                          nsCompatibility aCompatMode,
    1054                 :                          nsIPresShell** aInstancePtrResult);
    1055                 : 
    1056                 :   nsresult ResetStylesheetsToURI(nsIURI* aURI);
    1057                 :   void FillStyleSet(nsStyleSet* aStyleSet);
    1058                 : 
    1059                 :   // Return whether all the presshells for this document are safe to flush
    1060                 :   bool IsSafeToFlush() const;
    1061                 :   
    1062                 :   void DispatchPageTransition(nsIDOMEventTarget* aDispatchTarget,
    1063                 :                               const nsAString& aType,
    1064                 :                               bool aPersisted);
    1065                 : 
    1066                 :   virtual nsPIDOMWindow *GetWindowInternal() const;
    1067                 :   virtual nsPIDOMWindow *GetInnerWindowInternal();
    1068                 :   virtual nsIScriptGlobalObject* GetScriptHandlingObjectInternal() const;
    1069                 :   virtual bool InternalAllowXULXBL();
    1070                 : 
    1071                 : #define NS_DOCUMENT_NOTIFY_OBSERVERS(func_, params_)                        \
    1072                 :   NS_OBSERVER_ARRAY_NOTIFY_XPCOM_OBSERVERS(mObservers, nsIDocumentObserver, \
    1073                 :                                            func_, params_);
    1074                 :   
    1075                 : #ifdef DEBUG
    1076                 :   void VerifyRootContentState();
    1077                 : #endif
    1078                 : 
    1079                 :   nsDocument(const char* aContentType);
    1080                 :   virtual ~nsDocument();
    1081                 : 
    1082                 :   void EnsureOnloadBlocker();
    1083                 : 
    1084                 :   nsCString mReferrer;
    1085                 :   nsString mLastModified;
    1086                 : 
    1087                 :   nsTArray<nsIObserver*> mCharSetObservers;
    1088                 : 
    1089                 :   PLDHashTable *mSubDocuments;
    1090                 : 
    1091                 :   // Array of owning references to all children
    1092                 :   nsAttrAndChildArray mChildren;
    1093                 : 
    1094                 :   // Pointer to our parser if we're currently in the process of being
    1095                 :   // parsed into.
    1096                 :   nsCOMPtr<nsIParser> mParser;
    1097                 : 
    1098                 :   // Weak reference to our sink for in case we no longer have a parser.  This
    1099                 :   // will allow us to flush out any pending stuff from the sink even if
    1100                 :   // EndLoad() has already happened.
    1101                 :   nsWeakPtr mWeakSink;
    1102                 : 
    1103                 :   nsCOMArray<nsIStyleSheet> mStyleSheets;
    1104                 :   nsCOMArray<nsIStyleSheet> mCatalogSheets;
    1105                 : 
    1106                 :   // Array of observers
    1107                 :   nsTObserverArray<nsIDocumentObserver*> mObservers;
    1108                 : 
    1109                 :   // If document is created for example using
    1110                 :   // document.implementation.createDocument(...), mScriptObject points to
    1111                 :   // the script global object of the original document.
    1112                 :   nsWeakPtr mScriptObject;
    1113                 : 
    1114                 :   // Weak reference to the scope object (aka the script global object)
    1115                 :   // that, unlike mScriptGlobalObject, is never unset once set. This
    1116                 :   // is a weak reference to avoid leaks due to circular references.
    1117                 :   nsWeakPtr mScopeObject;
    1118                 : 
    1119                 :   // The document which requested (and was granted) full-screen. All ancestors
    1120                 :   // of this document will also be full-screen.
    1121                 :   static nsWeakPtr sFullScreenDoc;
    1122                 : 
    1123                 :   // The root document of the doctree containing the document which requested
    1124                 :   // full-screen. This root document will also be in full-screen state, as will
    1125                 :   // all the descendents down to the document which requested full-screen. This
    1126                 :   // reference allows us to reset full-screen state on all documents when a
    1127                 :   // document is hidden/navigation occurs.
    1128                 :   static nsWeakPtr sFullScreenRootDoc;
    1129                 : 
    1130                 :   // Stack of full-screen elements. When we request full-screen we push the
    1131                 :   // full-screen element onto this stack, and when we cancel full-screen we
    1132                 :   // pop one off this stack, restoring the previous full-screen state
    1133                 :   nsTArray<nsWeakPtr> mFullScreenStack;
    1134                 : 
    1135                 :   nsRefPtr<nsEventListenerManager> mListenerManager;
    1136                 :   nsCOMPtr<nsIDOMStyleSheetList> mDOMStyleSheets;
    1137                 :   nsRefPtr<nsDOMStyleSheetSetList> mStyleSheetSetList;
    1138                 :   nsRefPtr<nsScriptLoader> mScriptLoader;
    1139                 :   nsDocHeaderData* mHeaderData;
    1140                 :   /* mIdentifierMap works as follows for IDs:
    1141                 :    * 1) Attribute changes affect the table immediately (removing and adding
    1142                 :    *    entries as needed).
    1143                 :    * 2) Removals from the DOM affect the table immediately
    1144                 :    * 3) Additions to the DOM always update existing entries for names, and add
    1145                 :    *    new ones for IDs.
    1146                 :    */
    1147                 :   nsTHashtable<nsIdentifierMapEntry> mIdentifierMap;
    1148                 : 
    1149                 :   nsClassHashtable<nsStringHashKey, nsRadioGroupStruct> mRadioGroups;
    1150                 : 
    1151                 :   // Recorded time of change to 'loading' state.
    1152                 :   mozilla::TimeStamp mLoadingTimeStamp;
    1153                 : 
    1154                 :   // True if the document has been detached from its content viewer.
    1155                 :   bool mIsGoingAway:1;
    1156                 :   // True if the document is being destroyed.
    1157                 :   bool mInDestructor:1;
    1158                 : 
    1159                 :   // True if this document has ever had an HTML or SVG <title> element
    1160                 :   // bound to it
    1161                 :   bool mMayHaveTitleElement:1;
    1162                 : 
    1163                 :   bool mHasWarnedAboutBoxObjects:1;
    1164                 : 
    1165                 :   bool mDelayFrameLoaderInitialization:1;
    1166                 : 
    1167                 :   bool mSynchronousDOMContentLoaded:1;
    1168                 : 
    1169                 :   // If true, we have an input encoding.  If this is false, then the
    1170                 :   // document was created entirely in memory
    1171                 :   bool mHaveInputEncoding:1;
    1172                 : 
    1173                 :   bool mInXBLUpdate:1;
    1174                 : 
    1175                 :   // This flag is only set in nsXMLDocument, for e.g. documents used in XBL. We
    1176                 :   // don't want animations to play in such documents, so we need to store the
    1177                 :   // flag here so that we can check it in nsDocument::GetAnimationController.
    1178                 :   bool mLoadedAsInteractiveData:1;
    1179                 : 
    1180                 :   // Whether we're currently holding a lock on all of our images.
    1181                 :   bool mLockingImages:1;
    1182                 : 
    1183                 :   // Whether we currently require our images to animate
    1184                 :   bool mAnimatingImages:1;
    1185                 : 
    1186                 :   // Whether some node in this document has a listener for the
    1187                 :   // "mozaudioavailable" event.
    1188                 :   bool mHasAudioAvailableListener:1;
    1189                 : 
    1190                 :   // Whether we are currently in full-screen mode, as per the DOM API.
    1191                 :   bool mIsFullScreen:1;
    1192                 : 
    1193                 :   // Whether we're currently under a FlushPendingNotifications call to
    1194                 :   // our presshell.  This is used to handle flush reentry correctly.
    1195                 :   bool mInFlush:1;
    1196                 : 
    1197                 :   // Parser aborted. True if the parser of this document was forcibly
    1198                 :   // terminated instead of letting it finish at its own pace.
    1199                 :   bool mParserAborted:1;
    1200                 : 
    1201                 :   PRUint8 mXMLDeclarationBits;
    1202                 : 
    1203                 :   nsInterfaceHashtable<nsVoidPtrHashKey, nsPIBoxObject> *mBoxObjectTable;
    1204                 : 
    1205                 :   // The channel that got passed to StartDocumentLoad(), if any
    1206                 :   nsCOMPtr<nsIChannel> mChannel;
    1207                 :   nsRefPtr<nsHTMLStyleSheet> mAttrStyleSheet;
    1208                 :   nsRefPtr<nsHTMLCSSStyleSheet> mStyleAttrStyleSheet;
    1209                 :   nsRefPtr<nsXMLEventsManager> mXMLEventsManager;
    1210                 : 
    1211                 :   // Our update nesting level
    1212                 :   PRUint32 mUpdateNestLevel;
    1213                 : 
    1214                 :   // The application cache that this document is associated with, if
    1215                 :   // any.  This can change during the lifetime of the document.
    1216                 :   nsCOMPtr<nsIApplicationCache> mApplicationCache;
    1217                 : 
    1218                 :   nsCOMPtr<nsIContent> mFirstBaseNodeWithHref;
    1219                 : 
    1220                 :   nsEventStates mDocumentState;
    1221                 :   nsEventStates mGotDocumentState;
    1222                 : 
    1223                 :   nsRefPtr<nsDOMNavigationTiming> mTiming;
    1224                 : private:
    1225                 :   friend class nsUnblockOnloadEvent;
    1226                 :   // This needs to stay in sync with the list in GetMozVisibilityState.
    1227                 :   enum VisibilityState {
    1228                 :     eHidden = 0,
    1229                 :     eVisible,
    1230                 :     eVisibilityStateCount
    1231                 :   };
    1232                 :   // Recomputes the visibility state but doesn't set the new value.
    1233                 :   VisibilityState GetVisibilityState() const;
    1234                 : 
    1235                 :   void PostUnblockOnloadEvent();
    1236                 :   void DoUnblockOnload();
    1237                 : 
    1238                 :   nsresult CheckFrameOptions();
    1239                 :   nsresult InitCSP();
    1240                 : 
    1241                 :   /**
    1242                 :    * See if aDocument is a child of this.  If so, return the frame element in
    1243                 :    * this document that holds currentDoc (or an ancestor).
    1244                 :    */
    1245                 :   already_AddRefed<nsIDOMElement>
    1246                 :     CheckAncestryAndGetFrame(nsIDocument* aDocument) const;
    1247                 : 
    1248                 :   // Just like EnableStyleSheetsForSet, but doesn't check whether
    1249                 :   // aSheetSet is null and allows the caller to control whether to set
    1250                 :   // aSheetSet as the preferred set in the CSSLoader.
    1251                 :   void EnableStyleSheetsForSetInternal(const nsAString& aSheetSet,
    1252                 :                                        bool aUpdateCSSLoader);
    1253                 : 
    1254                 :   // Revoke any pending notifications due to mozRequestAnimationFrame calls
    1255                 :   void RevokeAnimationFrameNotifications();
    1256                 :   // Reschedule any notifications we need to handle
    1257                 :   // mozRequestAnimationFrame, if it's OK to do so.
    1258                 :   void MaybeRescheduleAnimationFrameNotifications();
    1259                 : 
    1260                 :   // These are not implemented and not supported.
    1261                 :   nsDocument(const nsDocument& aOther);
    1262                 :   nsDocument& operator=(const nsDocument& aOther);
    1263                 : 
    1264                 :   nsCOMPtr<nsISupports> mXPathEvaluatorTearoff;
    1265                 : 
    1266                 :   // The layout history state that should be used by nodes in this
    1267                 :   // document.  We only actually store a pointer to it when:
    1268                 :   // 1)  We have no script global object.
    1269                 :   // 2)  We haven't had Destroy() called on us yet.
    1270                 :   nsCOMPtr<nsILayoutHistoryState> mLayoutHistoryState;
    1271                 : 
    1272                 :   // Currently active onload blockers
    1273                 :   PRUint32 mOnloadBlockCount;
    1274                 :   // Onload blockers which haven't been activated yet
    1275                 :   PRUint32 mAsyncOnloadBlockCount;
    1276                 :   nsCOMPtr<nsIRequest> mOnloadBlocker;
    1277                 :   ReadyState mReadyState;
    1278                 : 
    1279                 :   // A hashtable of styled links keyed by address pointer.
    1280                 :   nsTHashtable<nsPtrHashKey<mozilla::dom::Link> > mStyledLinks;
    1281                 : #ifdef DEBUG
    1282                 :   // Indicates whether mStyledLinks was cleared or not.  This is used to track
    1283                 :   // state so we can provide useful assertions to consumers of ForgetLink and
    1284                 :   // AddStyleRelevantLink.
    1285                 :   bool mStyledLinksCleared;
    1286                 : #endif
    1287                 : 
    1288                 :   // Member to store out last-selected stylesheet set.
    1289                 :   nsString mLastStyleSheetSet;
    1290                 : 
    1291                 :   nsTArray<nsRefPtr<nsFrameLoader> > mInitializableFrameLoaders;
    1292                 :   nsTArray<nsRefPtr<nsFrameLoader> > mFinalizableFrameLoaders;
    1293                 :   nsRefPtr<nsRunnableMethod<nsDocument> > mFrameLoaderRunner;
    1294                 : 
    1295                 :   nsRevocableEventPtr<nsRunnableMethod<nsDocument, void, false> >
    1296                 :     mPendingTitleChangeEvent;
    1297                 : 
    1298                 :   nsExternalResourceMap mExternalResourceMap;
    1299                 : 
    1300                 :   // All images in process of being preloaded
    1301                 :   nsCOMArray<imgIRequest> mPreloadingImages;
    1302                 : 
    1303                 :   nsCOMPtr<nsIDOMDOMImplementation> mDOMImplementation;
    1304                 : 
    1305                 :   nsRefPtr<nsContentList> mImageMaps;
    1306                 : 
    1307                 :   nsCString mScrollToRef;
    1308                 :   PRUint8 mScrolledToRefAlready : 1;
    1309                 :   PRUint8 mChangeScrollPosWhenScrollingToRef : 1;
    1310                 : 
    1311                 :   // Tracking for images in the document.
    1312                 :   nsDataHashtable< nsPtrHashKey<imgIRequest>, PRUint32> mImageTracker;
    1313                 : 
    1314                 :   VisibilityState mVisibilityState;
    1315                 : 
    1316                 : #ifdef DEBUG
    1317                 : protected:
    1318                 :   bool mWillReparent;
    1319                 : #endif
    1320                 : };
    1321                 : 
    1322                 : #define NS_DOCUMENT_INTERFACE_TABLE_BEGIN(_class)                             \
    1323                 :   NS_NODE_OFFSET_AND_INTERFACE_TABLE_BEGIN(_class)                            \
    1324                 :   NS_INTERFACE_TABLE_ENTRY_AMBIGUOUS(_class, nsIDOMDocument, nsDocument)      \
    1325                 :   NS_INTERFACE_TABLE_ENTRY_AMBIGUOUS(_class, nsIDOMEventTarget, nsDocument)   \
    1326                 :   NS_INTERFACE_TABLE_ENTRY_AMBIGUOUS(_class, nsIDOMNode, nsDocument)
    1327                 : 
    1328                 : #endif /* nsDocument_h___ */

Generated by: LCOV version 1.7