LCOV - code coverage report
Current view: directory - objdir/dist/include - nsIDocument.h (source / functions) Found Hit Coverage
Test: app.info Lines: 237 96 40.5 %
Date: 2012-06-02 Functions: 100 36 36.0 %

       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                 :  *   Ms2ger <ms2ger@gmail.com>
      24                 :  *
      25                 :  * Alternatively, the contents of this file may be used under the terms of
      26                 :  * either of the GNU General Public License Version 2 or later (the "GPL"),
      27                 :  * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
      28                 :  * in which case the provisions of the GPL or the LGPL are applicable instead
      29                 :  * of those above. If you wish to allow use of your version of this file only
      30                 :  * under the terms of either the GPL or the LGPL, and not to allow others to
      31                 :  * use your version of this file under the terms of the MPL, indicate your
      32                 :  * decision by deleting the provisions above and replace them with the notice
      33                 :  * and other provisions required by the GPL or the LGPL. If you do not delete
      34                 :  * the provisions above, a recipient may use your version of this file under
      35                 :  * the terms of any one of the MPL, the GPL or the LGPL.
      36                 :  *
      37                 :  * ***** END LICENSE BLOCK ***** */
      38                 : #ifndef nsIDocument_h___
      39                 : #define nsIDocument_h___
      40                 : 
      41                 : #include "nsINode.h"
      42                 : #include "nsStringGlue.h"
      43                 : #include "nsIDocumentObserver.h" // for nsUpdateType
      44                 : #include "nsCOMPtr.h"
      45                 : #include "nsCOMArray.h"
      46                 : #include "nsIURI.h"
      47                 : #include "nsWeakPtr.h"
      48                 : #include "nsIWeakReferenceUtils.h"
      49                 : #include "nsILoadGroup.h"
      50                 : #include "nsCRT.h"
      51                 : #include "mozFlushType.h"
      52                 : #include "nsIAtom.h"
      53                 : #include "nsCompatibility.h"
      54                 : #include "nsTObserverArray.h"
      55                 : #include "nsTHashtable.h"
      56                 : #include "nsHashKeys.h"
      57                 : #include "nsNodeInfoManager.h"
      58                 : #include "nsIStreamListener.h"
      59                 : #include "nsIVariant.h"
      60                 : #include "nsIObserver.h"
      61                 : #include "nsGkAtoms.h"
      62                 : #include "nsAutoPtr.h"
      63                 : #include "nsPIDOMWindow.h"
      64                 : #include "nsSMILAnimationController.h"
      65                 : #include "nsIScriptGlobalObject.h"
      66                 : #include "nsIDocumentEncoder.h"
      67                 : #include "nsIFrameRequestCallback.h"
      68                 : #include "nsEventStates.h"
      69                 : #include "nsIStructuredCloneContainer.h"
      70                 : #include "nsIBFCacheEntry.h"
      71                 : 
      72                 : class nsIContent;
      73                 : class nsPresContext;
      74                 : class nsIPresShell;
      75                 : class nsIDocShell;
      76                 : class nsStyleSet;
      77                 : class nsIStyleSheet;
      78                 : class nsIStyleRule;
      79                 : class nsCSSStyleSheet;
      80                 : class nsIViewManager;
      81                 : class nsIDOMEvent;
      82                 : class nsIDOMEventTarget;
      83                 : class nsDeviceContext;
      84                 : class nsIParser;
      85                 : class nsIDOMNode;
      86                 : class nsIDOMElement;
      87                 : class nsIDOMDocumentFragment;
      88                 : class nsILineBreaker;
      89                 : class nsIWordBreaker;
      90                 : class nsISelection;
      91                 : class nsIChannel;
      92                 : class nsIPrincipal;
      93                 : class nsIDOMDocument;
      94                 : class nsIDOMDocumentType;
      95                 : class nsScriptLoader;
      96                 : class nsIContentSink;
      97                 : class nsHTMLStyleSheet;
      98                 : class nsHTMLCSSStyleSheet;
      99                 : class nsILayoutHistoryState;
     100                 : class nsIVariant;
     101                 : class nsIDOMUserDataHandler;
     102                 : template<class E> class nsCOMArray;
     103                 : class nsIDocumentObserver;
     104                 : class nsBindingManager;
     105                 : class nsIDOMNodeList;
     106                 : class mozAutoSubtreeModified;
     107                 : struct JSObject;
     108                 : class nsFrameLoader;
     109                 : class nsIBoxObject;
     110                 : class imgIRequest;
     111                 : class nsISHEntry;
     112                 : class nsDOMNavigationTiming;
     113                 : class nsWindowSizes;
     114                 : 
     115                 : namespace mozilla {
     116                 : namespace css {
     117                 : class Loader;
     118                 : } // namespace css
     119                 : 
     120                 : namespace dom {
     121                 : class Link;
     122                 : class Element;
     123                 : } // namespace dom
     124                 : } // namespace mozilla
     125                 : 
     126                 : #define NS_IDOCUMENT_IID \
     127                 : { 0x283ec27d, 0x5b23, 0x49b2, \
     128                 :   { 0x94, 0xd9, 0x9, 0xb5, 0xdb, 0x45, 0x30, 0x73 } }
     129                 : 
     130                 : 
     131                 : // Flag for AddStyleSheet().
     132                 : #define NS_STYLESHEET_FROM_CATALOG                (1 << 0)
     133                 : 
     134                 : // Enum for requesting a particular type of document when creating a doc
     135                 : enum DocumentFlavor {
     136                 :   DocumentFlavorLegacyGuess, // compat with old code until made HTML5-compliant
     137                 :   DocumentFlavorHTML, // HTMLDocument with HTMLness bit set to true
     138                 :   DocumentFlavorSVG // SVGDocument
     139                 : };
     140                 : 
     141                 : // Document states
     142                 : 
     143                 : // RTL locale: specific to the XUL localedir attribute
     144                 : #define NS_DOCUMENT_STATE_RTL_LOCALE              NS_DEFINE_EVENT_STATE_MACRO(0)
     145                 : // Window activation status
     146                 : #define NS_DOCUMENT_STATE_WINDOW_INACTIVE         NS_DEFINE_EVENT_STATE_MACRO(1)
     147                 : 
     148                 : //----------------------------------------------------------------------
     149                 : 
     150                 : // Document interface.  This is implemented by all document objects in
     151                 : // Gecko.
     152                 : class nsIDocument : public nsINode
     153                 : {
     154                 : public:
     155                 :   typedef mozilla::dom::Element Element;
     156                 : 
     157                 :   NS_DECLARE_STATIC_IID_ACCESSOR(NS_IDOCUMENT_IID)
     158            5088 :   NS_DECL_AND_IMPL_ZEROING_OPERATOR_NEW
     159                 : 
     160                 : #ifdef MOZILLA_INTERNAL_API
     161            1273 :   nsIDocument()
     162                 :     : nsINode(nsnull),
     163            1273 :       mCharacterSet(NS_LITERAL_CSTRING("ISO-8859-1")),
     164                 :       mNodeInfoManager(nsnull),
     165                 :       mCompatMode(eCompatibility_FullStandards),
     166                 :       mIsInitialDocumentInWindow(false),
     167                 :       mMayStartLayout(true),
     168                 :       mVisible(true),
     169                 :       mRemovedFromDocShell(false),
     170                 :       // mAllowDNSPrefetch starts true, so that we can always reliably && it
     171                 :       // with various values that might disable it.  Since we never prefetch
     172                 :       // unless we get a window, and in that case the docshell value will get
     173                 :       // &&-ed in, this is safe.
     174                 :       mAllowDNSPrefetch(true),
     175                 :       mIsBeingUsedAsImage(false),
     176                 :       mHasLinksToUpdate(false),
     177            2546 :       mPartID(0)
     178                 :   {
     179            1273 :     SetInDocument();
     180            1273 :   }
     181                 : #endif
     182                 :   
     183                 :   /**
     184                 :    * Let the document know that we're starting to load data into it.
     185                 :    * @param aCommand The parser command. Must not be null.
     186                 :    *                 XXXbz It's odd to have that here.
     187                 :    * @param aChannel The channel the data will come from. The channel must be
     188                 :    *                 able to report its Content-Type.
     189                 :    * @param aLoadGroup The loadgroup this document should use from now on.
     190                 :    *                   Note that the document might not be the only thing using
     191                 :    *                   this loadgroup.
     192                 :    * @param aContainer The container this document is in.  This may be null.
     193                 :    *                   XXXbz maybe we should make it more explicit (eg make the
     194                 :    *                   container an nsIWebNavigation or nsIDocShell or
     195                 :    *                   something)?
     196                 :    * @param [out] aDocListener the listener to pump data from the channel into.
     197                 :    *                           Generally this will be the parser this document
     198                 :    *                           sets up, or some sort of data-handler for media
     199                 :    *                           documents.
     200                 :    * @param aReset whether the document should call Reset() on itself.  If this
     201                 :    *               is false, the document will NOT set its principal to the
     202                 :    *               channel's owner, will not clear any event listeners that are
     203                 :    *               already set on it, etc.
     204                 :    * @param aSink The content sink to use for the data.  If this is null and
     205                 :    *              the document needs a content sink, it will create one based
     206                 :    *              on whatever it knows about the data it's going to load.
     207                 :    *              This MUST be null if the underlying document is an HTML
     208                 :    *              document. Even in the XML case, please don't add new calls
     209                 :    *              with non-null sink.
     210                 :    *
     211                 :    * Once this has been called, the document will return false for
     212                 :    * MayStartLayout() until SetMayStartLayout(true) is called on it.  Making
     213                 :    * sure this happens is the responsibility of the caller of
     214                 :    * StartDocumentLoad().
     215                 :    */  
     216                 :   virtual nsresult StartDocumentLoad(const char* aCommand,
     217                 :                                      nsIChannel* aChannel,
     218                 :                                      nsILoadGroup* aLoadGroup,
     219                 :                                      nsISupports* aContainer,
     220                 :                                      nsIStreamListener **aDocListener,
     221                 :                                      bool aReset,
     222                 :                                      nsIContentSink* aSink = nsnull) = 0;
     223                 :   virtual void StopDocumentLoad() = 0;
     224                 : 
     225                 :   /**
     226                 :    * Signal that the document title may have changed
     227                 :    * (see nsDocument::GetTitle).
     228                 :    * @param aBoundTitleElement true if an HTML or SVG <title> element
     229                 :    * has just been bound to the document.
     230                 :    */
     231                 :   virtual void NotifyPossibleTitleChange(bool aBoundTitleElement) = 0;
     232                 : 
     233                 :   /**
     234                 :    * Return the URI for the document. May return null.
     235                 :    *
     236                 :    * The value returned corresponds to the "document's current address" in
     237                 :    * HTML5.  As such, it may change over the lifetime of the document, for
     238                 :    * instance as a result of a call to pushState() or replaceState().
     239                 :    */
     240             349 :   nsIURI* GetDocumentURI() const
     241                 :   {
     242             349 :     return mDocumentURI;
     243                 :   }
     244                 : 
     245                 :   /**
     246                 :    * Return the original URI of the document.  This is the same as the
     247                 :    * document's URI unless history.pushState() or replaceState() is invoked on
     248                 :    * the document.
     249                 :    *
     250                 :    * This method corresponds to the "document's address" in HTML5 and, once
     251                 :    * set, doesn't change over the lifetime of the document.
     252                 :    */
     253               0 :   nsIURI* GetOriginalURI() const
     254                 :   {
     255               0 :     return mOriginalURI;
     256                 :   }
     257                 : 
     258                 :   /**
     259                 :    * Set the URI for the document.  This also sets the document's original URI,
     260                 :    * if it's null.
     261                 :    */
     262                 :   virtual void SetDocumentURI(nsIURI* aURI) = 0;
     263                 : 
     264                 :   /**
     265                 :    * Set the principal responsible for this document.
     266                 :    */
     267                 :   virtual void SetPrincipal(nsIPrincipal *aPrincipal) = 0;
     268                 : 
     269                 :   /**
     270                 :    * Return the LoadGroup for the document. May return null.
     271                 :    */
     272               0 :   already_AddRefed<nsILoadGroup> GetDocumentLoadGroup() const
     273                 :   {
     274               0 :     nsILoadGroup *group = nsnull;
     275               0 :     if (mDocumentLoadGroup)
     276               0 :       CallQueryReferent(mDocumentLoadGroup.get(), &group);
     277                 : 
     278               0 :     return group;
     279                 :   }
     280                 : 
     281                 :   /**
     282                 :    * Return the base URI for relative URIs in the document (the document uri
     283                 :    * unless it's overridden by SetBaseURI, HTML <base> tags, etc.).  The
     284                 :    * returned URI could be null if there is no document URI.
     285                 :    */
     286            3484 :   nsIURI* GetDocBaseURI() const
     287                 :   {
     288            3484 :     return mDocumentBaseURI ? mDocumentBaseURI : mDocumentURI;
     289                 :   }
     290               0 :   virtual already_AddRefed<nsIURI> GetBaseURI() const
     291                 :   {
     292               0 :     nsCOMPtr<nsIURI> uri = GetDocBaseURI();
     293                 : 
     294               0 :     return uri.forget();
     295                 :   }
     296                 : 
     297                 :   virtual nsresult SetBaseURI(nsIURI* aURI) = 0;
     298                 : 
     299                 :   /**
     300                 :    * Get/Set the base target of a link in a document.
     301                 :    */
     302                 :   virtual void GetBaseTarget(nsAString &aBaseTarget) = 0;
     303               0 :   void SetBaseTarget(const nsString& aBaseTarget) {
     304               0 :     mBaseTarget = aBaseTarget;
     305               0 :   }
     306                 : 
     307                 :   /**
     308                 :    * Return a standard name for the document's character set.
     309                 :    */
     310             528 :   const nsCString& GetDocumentCharacterSet() const
     311                 :   {
     312             528 :     return mCharacterSet;
     313                 :   }
     314                 : 
     315                 :   /**
     316                 :    * Set the document's character encoding. |aCharSetID| should be canonical. 
     317                 :    * That is, callers are responsible for the charset alias resolution. 
     318                 :    */
     319                 :   virtual void SetDocumentCharacterSet(const nsACString& aCharSetID) = 0;
     320                 : 
     321               0 :   PRInt32 GetDocumentCharacterSetSource() const
     322                 :   {
     323               0 :     return mCharacterSetSource;
     324                 :   }
     325                 : 
     326                 :   // This method MUST be called before SetDocumentCharacterSet if
     327                 :   // you're planning to call both.
     328               0 :   void SetDocumentCharacterSetSource(PRInt32 aCharsetSource)
     329                 :   {
     330               0 :     mCharacterSetSource = aCharsetSource;
     331               0 :   }
     332                 : 
     333                 :   /**
     334                 :    * Add an observer that gets notified whenever the charset changes.
     335                 :    */
     336                 :   virtual nsresult AddCharSetObserver(nsIObserver* aObserver) = 0;
     337                 : 
     338                 :   /**
     339                 :    * Remove a charset observer.
     340                 :    */
     341                 :   virtual void RemoveCharSetObserver(nsIObserver* aObserver) = 0;
     342                 : 
     343                 :   /**
     344                 :    * This gets fired when the element that an id refers to changes.
     345                 :    * This fires at difficult times. It is generally not safe to do anything
     346                 :    * which could modify the DOM in any way. Use
     347                 :    * nsContentUtils::AddScriptRunner.
     348                 :    * @return true to keep the callback in the callback set, false
     349                 :    * to remove it.
     350                 :    */
     351                 :   typedef bool (* IDTargetObserver)(Element* aOldElement,
     352                 :                                       Element* aNewelement, void* aData);
     353                 : 
     354                 :   /**
     355                 :    * Add an IDTargetObserver for a specific ID. The IDTargetObserver
     356                 :    * will be fired whenever the content associated with the ID changes
     357                 :    * in the future. If aForImage is true, mozSetImageElement can override
     358                 :    * what content is associated with the ID. In that case the IDTargetObserver
     359                 :    * will be notified at those times when the result of LookupImageElement
     360                 :    * changes.
     361                 :    * At most one (aObserver, aData, aForImage) triple can be
     362                 :    * registered for each ID.
     363                 :    * @return the content currently associated with the ID.
     364                 :    */
     365                 :   virtual Element* AddIDTargetObserver(nsIAtom* aID, IDTargetObserver aObserver,
     366                 :                                        void* aData, bool aForImage) = 0;
     367                 :   /**
     368                 :    * Remove the (aObserver, aData, aForImage) triple for a specific ID, if
     369                 :    * registered.
     370                 :    */
     371                 :   virtual void RemoveIDTargetObserver(nsIAtom* aID, IDTargetObserver aObserver,
     372                 :                                       void* aData, bool aForImage) = 0;
     373                 : 
     374                 :   /**
     375                 :    * Get the Content-Type of this document.
     376                 :    * (This will always return NS_OK, but has this signature to be compatible
     377                 :    *  with nsIDOMDocument::GetContentType())
     378                 :    */
     379                 :   NS_IMETHOD GetContentType(nsAString& aContentType) = 0;
     380                 : 
     381                 :   /**
     382                 :    * Set the Content-Type of this document.
     383                 :    */
     384                 :   virtual void SetContentType(const nsAString& aContentType) = 0;
     385                 : 
     386                 :   /**
     387                 :    * Return the language of this document.
     388                 :    */
     389               0 :   void GetContentLanguage(nsAString& aContentLanguage) const
     390                 :   {
     391               0 :     CopyASCIItoUTF16(mContentLanguage, aContentLanguage);
     392               0 :   }
     393                 : 
     394                 :   // The states BidiEnabled and MathMLEnabled should persist across multiple views
     395                 :   // (screen, print) of the same document.
     396                 : 
     397                 :   /**
     398                 :    * Check if the document contains bidi data.
     399                 :    * If so, we have to apply the Unicode Bidi Algorithm.
     400                 :    */
     401               5 :   bool GetBidiEnabled() const
     402                 :   {
     403               5 :     return mBidiEnabled;
     404                 :   }
     405                 : 
     406                 :   /**
     407                 :    * Indicate the document contains bidi data.
     408                 :    * Currently, we cannot disable bidi, because once bidi is enabled,
     409                 :    * it affects a frame model irreversibly, and plays even though
     410                 :    * the document no longer contains bidi data.
     411                 :    */
     412               4 :   void SetBidiEnabled()
     413                 :   {
     414               4 :     mBidiEnabled = true;
     415               4 :   }
     416                 :   
     417                 :   /**
     418                 :    * Check if the document contains (or has contained) any MathML elements.
     419                 :    */
     420               0 :   bool GetMathMLEnabled() const
     421                 :   {
     422               0 :     return mMathMLEnabled;
     423                 :   }
     424                 :   
     425               0 :   void SetMathMLEnabled()
     426                 :   {
     427               0 :     mMathMLEnabled = true;
     428               0 :   }
     429                 : 
     430                 :   /**
     431                 :    * Ask this document whether it's the initial document in its window.
     432                 :    */
     433               0 :   bool IsInitialDocument() const
     434                 :   {
     435               0 :     return mIsInitialDocumentInWindow;
     436                 :   }
     437                 :   
     438                 :   /**
     439                 :    * Tell this document that it's the initial document in its window.  See
     440                 :    * comments on mIsInitialDocumentInWindow for when this should be called.
     441                 :    */
     442               0 :   void SetIsInitialDocument(bool aIsInitialDocument)
     443                 :   {
     444               0 :     mIsInitialDocumentInWindow = aIsInitialDocument;
     445               0 :   }
     446                 :   
     447                 : 
     448                 :   /**
     449                 :    * Get the bidi options for this document.
     450                 :    * @see nsBidiUtils.h
     451                 :    */
     452               0 :   PRUint32 GetBidiOptions() const
     453                 :   {
     454               0 :     return mBidiOptions;
     455                 :   }
     456                 : 
     457                 :   /**
     458                 :    * Set the bidi options for this document.  This just sets the bits;
     459                 :    * callers are expected to take action as needed if they want this
     460                 :    * change to actually change anything immediately.
     461                 :    * @see nsBidiUtils.h
     462                 :    */
     463               0 :   void SetBidiOptions(PRUint32 aBidiOptions)
     464                 :   {
     465               0 :     mBidiOptions = aBidiOptions;
     466               0 :   }
     467                 :   
     468                 :   /**
     469                 :    * Access HTTP header data (this may also get set from other
     470                 :    * sources, like HTML META tags).
     471                 :    */
     472                 :   virtual void GetHeaderData(nsIAtom* aHeaderField, nsAString& aData) const = 0;
     473                 :   virtual void SetHeaderData(nsIAtom* aheaderField, const nsAString& aData) = 0;
     474                 : 
     475                 :   /**
     476                 :    * Create a new presentation shell that will use aContext for its
     477                 :    * presentation context (presentation contexts <b>must not</b> be
     478                 :    * shared among multiple presentation shells). The caller of this
     479                 :    * method is responsible for calling BeginObservingDocument() on the
     480                 :    * presshell if the presshell should observe document mutations.
     481                 :    */
     482                 :   virtual nsresult CreateShell(nsPresContext* aContext,
     483                 :                                nsIViewManager* aViewManager,
     484                 :                                nsStyleSet* aStyleSet,
     485                 :                                nsIPresShell** aInstancePtrResult) = 0;
     486                 :   virtual void DeleteShell() = 0;
     487                 : 
     488          232533 :   nsIPresShell* GetShell() const
     489                 :   {
     490          232533 :     return GetBFCacheEntry() ? nsnull : mPresShell;
     491                 :   }
     492                 : 
     493               0 :   void SetBFCacheEntry(nsIBFCacheEntry* aEntry)
     494                 :   {
     495               0 :     mBFCacheEntry = aEntry;
     496               0 :   }
     497                 : 
     498          232533 :   nsIBFCacheEntry* GetBFCacheEntry() const
     499                 :   {
     500          232533 :     return mBFCacheEntry;
     501                 :   }
     502                 : 
     503                 :   /**
     504                 :    * Return the parent document of this document. Will return null
     505                 :    * unless this document is within a compound document and has a
     506                 :    * parent. Note that this parent chain may cross chrome boundaries.
     507                 :    */
     508               0 :   nsIDocument *GetParentDocument() const
     509                 :   {
     510               0 :     return mParentDocument;
     511                 :   }
     512                 : 
     513                 :   /**
     514                 :    * Set the parent document of this document.
     515                 :    */
     516               0 :   void SetParentDocument(nsIDocument* aParent)
     517                 :   {
     518               0 :     mParentDocument = aParent;
     519               0 :   }
     520                 : 
     521                 :   /**
     522                 :    * Set the sub document for aContent to aSubDoc.
     523                 :    */
     524                 :   virtual nsresult SetSubDocumentFor(Element* aContent,
     525                 :                                      nsIDocument* aSubDoc) = 0;
     526                 : 
     527                 :   /**
     528                 :    * Get the sub document for aContent
     529                 :    */
     530                 :   virtual nsIDocument *GetSubDocumentFor(nsIContent *aContent) const = 0;
     531                 : 
     532                 :   /**
     533                 :    * Find the content node for which aDocument is a sub document.
     534                 :    */
     535                 :   virtual Element* FindContentForSubDocument(nsIDocument* aDocument) const = 0;
     536                 : 
     537                 :   /**
     538                 :    * Return the root element for this document.
     539                 :    */
     540                 :   Element *GetRootElement() const;
     541                 : 
     542                 : protected:
     543                 :   virtual Element *GetRootElementInternal() const = 0;
     544                 : 
     545                 : public:
     546                 :   // Get the root <html> element, or return null if there isn't one (e.g.
     547                 :   // if the root isn't <html>)
     548                 :   Element* GetHtmlElement();
     549                 :   // Returns the first child of GetHtmlContent which has the given tag,
     550                 :   // or nsnull if that doesn't exist.
     551                 :   Element* GetHtmlChildElement(nsIAtom* aTag);
     552                 :   // Get the canonical <body> element, or return null if there isn't one (e.g.
     553                 :   // if the root isn't <html> or if the <body> isn't there)
     554               0 :   Element* GetBodyElement() {
     555               0 :     return GetHtmlChildElement(nsGkAtoms::body);
     556                 :   }
     557                 :   // Get the canonical <head> element, or return null if there isn't one (e.g.
     558                 :   // if the root isn't <html> or if the <head> isn't there)
     559               0 :   Element* GetHeadElement() {
     560               0 :     return GetHtmlChildElement(nsGkAtoms::head);
     561                 :   }
     562                 :   
     563                 :   /**
     564                 :    * Accessors to the collection of stylesheets owned by this document.
     565                 :    * Style sheets are ordered, most significant last.
     566                 :    */
     567                 : 
     568                 :   /**
     569                 :    * Get the number of stylesheets
     570                 :    *
     571                 :    * @return the number of stylesheets
     572                 :    * @throws no exceptions
     573                 :    */
     574                 :   virtual PRInt32 GetNumberOfStyleSheets() const = 0;
     575                 :   
     576                 :   /**
     577                 :    * Get a particular stylesheet
     578                 :    * @param aIndex the index the stylesheet lives at.  This is zero-based
     579                 :    * @return the stylesheet at aIndex.  Null if aIndex is out of range.
     580                 :    * @throws no exceptions
     581                 :    */
     582                 :   virtual nsIStyleSheet* GetStyleSheetAt(PRInt32 aIndex) const = 0;
     583                 :   
     584                 :   /**
     585                 :    * Insert a sheet at a particular spot in the stylesheet list (zero-based)
     586                 :    * @param aSheet the sheet to insert
     587                 :    * @param aIndex the index to insert at.  This index will be
     588                 :    *   adjusted for the "special" sheets.
     589                 :    * @throws no exceptions
     590                 :    */
     591                 :   virtual void InsertStyleSheetAt(nsIStyleSheet* aSheet, PRInt32 aIndex) = 0;
     592                 : 
     593                 :   /**
     594                 :    * Get the index of a particular stylesheet.  This will _always_
     595                 :    * consider the "special" sheets as part of the sheet list.
     596                 :    * @param aSheet the sheet to get the index of
     597                 :    * @return aIndex the index of the sheet in the full list
     598                 :    */
     599                 :   virtual PRInt32 GetIndexOfStyleSheet(nsIStyleSheet* aSheet) const = 0;
     600                 : 
     601                 :   /**
     602                 :    * Replace the stylesheets in aOldSheets with the stylesheets in
     603                 :    * aNewSheets. The two lists must have equal length, and the sheet
     604                 :    * at positon J in the first list will be replaced by the sheet at
     605                 :    * position J in the second list.  Some sheets in the second list
     606                 :    * may be null; if so the corresponding sheets in the first list
     607                 :    * will simply be removed.
     608                 :    */
     609                 :   virtual void UpdateStyleSheets(nsCOMArray<nsIStyleSheet>& aOldSheets,
     610                 :                                  nsCOMArray<nsIStyleSheet>& aNewSheets) = 0;
     611                 : 
     612                 :   /**
     613                 :    * Add a stylesheet to the document
     614                 :    */
     615                 :   virtual void AddStyleSheet(nsIStyleSheet* aSheet) = 0;
     616                 : 
     617                 :   /**
     618                 :    * Remove a stylesheet from the document
     619                 :    */
     620                 :   virtual void RemoveStyleSheet(nsIStyleSheet* aSheet) = 0;
     621                 : 
     622                 :   /**
     623                 :    * Notify the document that the applicable state of the sheet changed
     624                 :    * and that observers should be notified and style sets updated
     625                 :    */
     626                 :   virtual void SetStyleSheetApplicableState(nsIStyleSheet* aSheet,
     627                 :                                             bool aApplicable) = 0;  
     628                 : 
     629                 :   /**
     630                 :    * Just like the style sheet API, but for "catalog" sheets,
     631                 :    * extra sheets inserted at the UA level.
     632                 :    */
     633                 :   virtual PRInt32 GetNumberOfCatalogStyleSheets() const = 0;
     634                 :   virtual nsIStyleSheet* GetCatalogStyleSheetAt(PRInt32 aIndex) const = 0;
     635                 :   virtual void AddCatalogStyleSheet(nsIStyleSheet* aSheet) = 0;
     636                 :   virtual void EnsureCatalogStyleSheet(const char *aStyleSheetURI) = 0;
     637                 : 
     638                 :   /**
     639                 :    * Get this document's CSSLoader.  This is guaranteed to not return null.
     640                 :    */
     641            3184 :   mozilla::css::Loader* CSSLoader() const {
     642            3184 :     return mCSSLoader;
     643                 :   }
     644                 : 
     645                 :   /**
     646                 :    * Get the channel that was passed to StartDocumentLoad or Reset for this
     647                 :    * document.  Note that this may be null in some cases (eg if
     648                 :    * StartDocumentLoad or Reset were never called)
     649                 :    */
     650                 :   virtual nsIChannel* GetChannel() const = 0;
     651                 : 
     652                 :   /**
     653                 :    * Get this document's attribute stylesheet.  May return null if
     654                 :    * there isn't one.
     655                 :    */
     656                 :   virtual nsHTMLStyleSheet* GetAttributeStyleSheet() const = 0;
     657                 : 
     658                 :   /**
     659                 :    * Get this document's inline style sheet.  May return null if there
     660                 :    * isn't one
     661                 :    */
     662                 :   virtual nsHTMLCSSStyleSheet* GetInlineStyleSheet() const = 0;
     663                 : 
     664                 :   /**
     665                 :    * Get/set the object from which a document can get a script context
     666                 :    * and scope. This is the context within which all scripts (during
     667                 :    * document creation and during event handling) will run. Note that
     668                 :    * this is the *inner* window object.
     669                 :    */
     670                 :   virtual nsIScriptGlobalObject* GetScriptGlobalObject() const = 0;
     671                 :   virtual void SetScriptGlobalObject(nsIScriptGlobalObject* aGlobalObject) = 0;
     672                 : 
     673                 :   /**
     674                 :    * Get/set the object from which the context for the event/script handling can
     675                 :    * be got. Normally GetScriptHandlingObject() returns the same object as
     676                 :    * GetScriptGlobalObject(), but if the document is loaded as data,
     677                 :    * non-null may be returned, even if GetScriptGlobalObject() returns null.
     678                 :    * aHasHadScriptHandlingObject is set true if document has had the object
     679                 :    * for event/script handling. Do not process any events/script if the method
     680                 :    * returns null, but aHasHadScriptHandlingObject is true.
     681                 :    */
     682                 :   nsIScriptGlobalObject*
     683           18124 :     GetScriptHandlingObject(bool& aHasHadScriptHandlingObject) const
     684                 :   {
     685           18124 :     aHasHadScriptHandlingObject = mHasHadScriptHandlingObject;
     686               0 :     return mScriptGlobalObject ? mScriptGlobalObject.get() :
     687           18124 :                                  GetScriptHandlingObjectInternal();
     688                 :   }
     689                 :   virtual void SetScriptHandlingObject(nsIScriptGlobalObject* aScriptObject) = 0;
     690                 : 
     691                 :   /**
     692                 :    * Get the object that is used as the scope for all of the content
     693                 :    * wrappers whose owner document is this document. Unlike the script global
     694                 :    * object, this will only return null when the global object for this
     695                 :    * document is truly gone. Use this object when you're trying to find a
     696                 :    * content wrapper in XPConnect.
     697                 :    */
     698                 :   virtual nsIScriptGlobalObject* GetScopeObject() = 0;
     699                 : 
     700                 :   /**
     701                 :    * Return the window containing the document (the outer window).
     702                 :    */
     703            7456 :   nsPIDOMWindow *GetWindow() const
     704                 :   {
     705            7456 :     return mWindow ? mWindow->GetOuterWindow() : GetWindowInternal();
     706                 :   }
     707                 : 
     708                 :   /**
     709                 :    * Return the inner window used as the script compilation scope for
     710                 :    * this document. If you're not absolutely sure you need this, use
     711                 :    * GetWindow().
     712                 :    */
     713            3638 :   nsPIDOMWindow* GetInnerWindow()
     714                 :   {
     715            3638 :     return mRemovedFromDocShell ? GetInnerWindowInternal() : mWindow;
     716                 :   }
     717                 : 
     718                 :   /**
     719                 :    * Return the outer window ID.
     720                 :    */
     721                 :   PRUint64 OuterWindowID() const
     722                 :   {
     723                 :     nsPIDOMWindow *window = GetWindow();
     724                 :     return window ? window->WindowID() : 0;
     725                 :   }
     726                 : 
     727                 :   /**
     728                 :    * Return the inner window ID.
     729                 :    */
     730               5 :   PRUint64 InnerWindowID()
     731                 :   {
     732               5 :     nsPIDOMWindow *window = GetInnerWindow();
     733               5 :     return window ? window->WindowID() : 0;
     734                 :   }
     735                 : 
     736                 :   /**
     737                 :    * Get the script loader for this document
     738                 :    */ 
     739                 :   virtual nsScriptLoader* ScriptLoader() = 0;
     740                 : 
     741                 :   /**
     742                 :    * Add/Remove an element to the document's id and name hashes
     743                 :    */
     744                 :   virtual void AddToIdTable(Element* aElement, nsIAtom* aId) = 0;
     745                 :   virtual void RemoveFromIdTable(Element* aElement, nsIAtom* aId) = 0;
     746                 :   virtual void AddToNameTable(Element* aElement, nsIAtom* aName) = 0;
     747                 :   virtual void RemoveFromNameTable(Element* aElement, nsIAtom* aName) = 0;
     748                 : 
     749                 :   /**
     750                 :    * Returns the element which either requested DOM full-screen mode, or
     751                 :    * contains the element which requested DOM full-screen mode if the
     752                 :    * requestee is in a subdocument. Note this element must be *in*
     753                 :    * this document.
     754                 :    */
     755                 :   virtual Element* GetFullScreenElement() = 0;
     756                 : 
     757                 :   /**
     758                 :    * Asynchronously requests that the document make aElement the full-screen
     759                 :    * element, and move into full-screen mode. The current full-screen element
     760                 :    * (if any) is pushed onto the full-screen element stack, and it can be
     761                 :    * returned to full-screen status by calling RestorePreviousFullScreenState().
     762                 :    */
     763                 :   virtual void AsyncRequestFullScreen(Element* aElement) = 0;
     764                 : 
     765                 :   /**
     766                 :    * Restores the previous full-screen element to full-screen status. If there
     767                 :    * is no former full-screen element, this exits full-screen, moving the
     768                 :    * top-level browser window out of full-screen mode.
     769                 :    */
     770                 :   virtual void RestorePreviousFullScreenState() = 0;
     771                 : 
     772                 :   /**
     773                 :    * Returns true if this document is in full-screen mode.
     774                 :    */
     775                 :   virtual bool IsFullScreenDoc() = 0;
     776                 : 
     777                 :   /**
     778                 :    * Exits all documents from DOM full-screen mode, and moves the top-level
     779                 :    * browser window out of full-screen mode. If aRunAsync is true, this runs
     780                 :    * asynchronously.
     781                 :    */
     782                 :   static void ExitFullScreen(bool aRunAsync);
     783                 : 
     784                 :   //----------------------------------------------------------------------
     785                 : 
     786                 :   // Document notification API's
     787                 : 
     788                 :   /**
     789                 :    * Add a new observer of document change notifications. Whenever
     790                 :    * content is changed, appended, inserted or removed the observers are
     791                 :    * informed.  An observer that is already observing the document must
     792                 :    * not be added without being removed first.
     793                 :    */
     794                 :   virtual void AddObserver(nsIDocumentObserver* aObserver) = 0;
     795                 : 
     796                 :   /**
     797                 :    * Remove an observer of document change notifications. This will
     798                 :    * return false if the observer cannot be found.
     799                 :    */
     800                 :   virtual bool RemoveObserver(nsIDocumentObserver* aObserver) = 0;
     801                 : 
     802                 :   // Observation hooks used to propagate notifications to document observers.
     803                 :   // BeginUpdate must be called before any batch of modifications of the
     804                 :   // content model or of style data, EndUpdate must be called afterward.
     805                 :   // To make this easy and painless, use the mozAutoDocUpdate helper class.
     806                 :   virtual void BeginUpdate(nsUpdateType aUpdateType) = 0;
     807                 :   virtual void EndUpdate(nsUpdateType aUpdateType) = 0;
     808                 :   virtual void BeginLoad() = 0;
     809                 :   virtual void EndLoad() = 0;
     810                 : 
     811                 :   enum ReadyState { READYSTATE_UNINITIALIZED = 0, READYSTATE_LOADING = 1, READYSTATE_INTERACTIVE = 3, READYSTATE_COMPLETE = 4};
     812                 :   virtual void SetReadyStateInternal(ReadyState rs) = 0;
     813                 :   virtual ReadyState GetReadyStateEnum() = 0;
     814                 : 
     815                 :   // notify that a content node changed state.  This must happen under
     816                 :   // a scriptblocker but NOT within a begin/end update.
     817                 :   virtual void ContentStateChanged(nsIContent* aContent,
     818                 :                                    nsEventStates aStateMask) = 0;
     819                 : 
     820                 :   // Notify that a document state has changed.
     821                 :   // This should only be called by callers whose state is also reflected in the
     822                 :   // implementation of nsDocument::GetDocumentState.
     823                 :   virtual void DocumentStatesChanged(nsEventStates aStateMask) = 0;
     824                 : 
     825                 :   // Observation hooks for style data to propagate notifications
     826                 :   // to document observers
     827                 :   virtual void StyleRuleChanged(nsIStyleSheet* aStyleSheet,
     828                 :                                 nsIStyleRule* aOldStyleRule,
     829                 :                                 nsIStyleRule* aNewStyleRule) = 0;
     830                 :   virtual void StyleRuleAdded(nsIStyleSheet* aStyleSheet,
     831                 :                               nsIStyleRule* aStyleRule) = 0;
     832                 :   virtual void StyleRuleRemoved(nsIStyleSheet* aStyleSheet,
     833                 :                                 nsIStyleRule* aStyleRule) = 0;
     834                 : 
     835                 :   /**
     836                 :    * Flush notifications for this document and its parent documents
     837                 :    * (since those may affect the layout of this one).
     838                 :    */
     839                 :   virtual void FlushPendingNotifications(mozFlushType aType) = 0;
     840                 : 
     841                 :   /**
     842                 :    * Calls FlushPendingNotifications on any external resources this document
     843                 :    * has. If this document has no external resources or is an external resource
     844                 :    * itself this does nothing. This should only be called with
     845                 :    * aType >= Flush_Style.
     846                 :    */
     847                 :   virtual void FlushExternalResources(mozFlushType aType) = 0;
     848                 : 
     849          368881 :   nsBindingManager* BindingManager() const
     850                 :   {
     851          368881 :     return mNodeInfoManager->GetBindingManager();
     852                 :   }
     853                 : 
     854                 :   /**
     855                 :    * Only to be used inside Gecko, you can't really do anything with the
     856                 :    * pointer outside Gecko anyway.
     857                 :    */
     858            1518 :   nsNodeInfoManager* NodeInfoManager() const
     859                 :   {
     860            1518 :     return mNodeInfoManager;
     861                 :   }
     862                 : 
     863                 :   /**
     864                 :    * Reset the document using the given channel and loadgroup.  This works
     865                 :    * like ResetToURI, but also sets the document's channel to aChannel.
     866                 :    * The principal of the document will be set from the channel.
     867                 :    */
     868                 :   virtual void Reset(nsIChannel* aChannel, nsILoadGroup* aLoadGroup) = 0;
     869                 : 
     870                 :   /**
     871                 :    * Reset this document to aURI, aLoadGroup, and aPrincipal.  aURI must not be
     872                 :    * null.  If aPrincipal is null, a codebase principal based on aURI will be
     873                 :    * used.
     874                 :    */
     875                 :   virtual void ResetToURI(nsIURI *aURI, nsILoadGroup* aLoadGroup,
     876                 :                           nsIPrincipal* aPrincipal) = 0;
     877                 : 
     878                 :   /**
     879                 :    * Set the container (docshell) for this document. Virtual so that
     880                 :    * docshell can call it.
     881                 :    */
     882                 :   virtual void SetContainer(nsISupports *aContainer);
     883                 : 
     884                 :   /**
     885                 :    * Get the container (docshell) for this document.
     886                 :    */
     887               0 :   already_AddRefed<nsISupports> GetContainer() const
     888                 :   {
     889               0 :     nsISupports* container = nsnull;
     890               0 :     if (mDocumentContainer)
     891               0 :       CallQueryReferent(mDocumentContainer.get(), &container);
     892                 : 
     893               0 :     return container;
     894                 :   }
     895                 : 
     896                 :   /**
     897                 :    * Set and get XML declaration. If aVersion is null there is no declaration.
     898                 :    * aStandalone takes values -1, 0 and 1 indicating respectively that there
     899                 :    * was no standalone parameter in the declaration, that it was given as no,
     900                 :    * or that it was given as yes.
     901                 :    */
     902                 :   virtual void SetXMLDeclaration(const PRUnichar *aVersion,
     903                 :                                  const PRUnichar *aEncoding,
     904                 :                                  const PRInt32 aStandalone) = 0;
     905                 :   virtual void GetXMLDeclaration(nsAString& aVersion,
     906                 :                                  nsAString& aEncoding,
     907                 :                                  nsAString& Standalone) = 0;
     908                 : 
     909           12179 :   bool IsHTML() const
     910                 :   {
     911           12179 :     return mIsRegularHTML;
     912                 :   }
     913               0 :   bool IsXUL() const
     914                 :   {
     915               0 :     return mIsXUL;
     916                 :   }
     917                 : 
     918                 :   virtual bool IsScriptEnabled() = 0;
     919                 : 
     920                 :   virtual void AddXMLEventsContent(nsIContent * aXMLEventsElement) = 0;
     921                 : 
     922                 :   /**
     923                 :    * Create an element with the specified name, prefix and namespace ID.
     924                 :    */
     925                 :   virtual nsresult CreateElem(const nsAString& aName, nsIAtom *aPrefix,
     926                 :                               PRInt32 aNamespaceID,
     927                 :                               nsIContent** aResult) = 0;
     928                 : 
     929                 :   /**
     930                 :    * Get the security info (i.e. SSL state etc) that the document got
     931                 :    * from the channel/document that created the content of the
     932                 :    * document.
     933                 :    *
     934                 :    * @see nsIChannel
     935                 :    */
     936               0 :   nsISupports *GetSecurityInfo()
     937                 :   {
     938               0 :     return mSecurityInfo;
     939                 :   }
     940                 : 
     941                 :   /**
     942                 :    * Returns the default namespace ID used for elements created in this
     943                 :    * document.
     944                 :    */
     945               8 :   PRInt32 GetDefaultNamespaceID() const
     946                 :   {
     947               8 :     return mDefaultElementType;
     948                 :   }
     949                 : 
     950                 :   void DeleteAllProperties();
     951                 :   void DeleteAllPropertiesFor(nsINode* aNode);
     952                 : 
     953            1541 :   nsPropertyTable* PropertyTable(PRUint16 aCategory) {
     954            1541 :     if (aCategory == 0)
     955            1271 :       return &mPropertyTable;
     956             270 :     return GetExtraPropertyTable(aCategory);
     957                 :   }
     958            2550 :   PRUint32 GetPropertyTableCount()
     959            2550 :   { return mExtraPropertyTables.Length() + 1; }
     960                 : 
     961                 :   /**
     962                 :    * Sets the ID used to identify this part of the multipart document
     963                 :    */
     964               0 :   void SetPartID(PRUint32 aID) {
     965               0 :     mPartID = aID;
     966               0 :   }
     967                 : 
     968                 :   /**
     969                 :    * Return the ID used to identify this part of the multipart document
     970                 :    */
     971               0 :   PRUint32 GetPartID() const {
     972               0 :     return mPartID;
     973                 :   }
     974                 : 
     975                 :   /**
     976                 :    * Sanitize the document by resetting all input elements and forms that have
     977                 :    * autocomplete=off to their default values.
     978                 :    */
     979                 :   virtual nsresult Sanitize() = 0;
     980                 : 
     981                 :   /**
     982                 :    * Enumerate all subdocuments.
     983                 :    * The enumerator callback should return true to continue enumerating, or
     984                 :    * false to stop.  This will never get passed a null aDocument.
     985                 :    */
     986                 :   typedef bool (*nsSubDocEnumFunc)(nsIDocument *aDocument, void *aData);
     987                 :   virtual void EnumerateSubDocuments(nsSubDocEnumFunc aCallback,
     988                 :                                      void *aData) = 0;
     989                 : 
     990                 :   /**
     991                 :    * Check whether it is safe to cache the presentation of this document
     992                 :    * and all of its subdocuments. This method checks the following conditions
     993                 :    * recursively:
     994                 :    *  - Some document types, such as plugin documents, cannot be safely cached.
     995                 :    *  - If there are any pending requests, we don't allow the presentation
     996                 :    *    to be cached.  Ideally these requests would be suspended and resumed,
     997                 :    *    but that is difficult in some cases, such as XMLHttpRequest.
     998                 :    *  - If there are any beforeunload or unload listeners, we must fire them
     999                 :    *    for correctness, but this likely puts the document into a state where
    1000                 :    *    it would not function correctly if restored.
    1001                 :    *
    1002                 :    * |aNewRequest| should be the request for a new document which will
    1003                 :    * replace this document in the docshell.  The new document's request
    1004                 :    * will be ignored when checking for active requests.  If there is no
    1005                 :    * request associated with the new document, this parameter may be null.
    1006                 :    */
    1007                 :   virtual bool CanSavePresentation(nsIRequest *aNewRequest) = 0;
    1008                 : 
    1009                 :   /**
    1010                 :    * Notify the document that its associated ContentViewer is being destroyed.
    1011                 :    * This releases circular references so that the document can go away.
    1012                 :    * Destroy() is only called on documents that have a content viewer.
    1013                 :    */
    1014                 :   virtual void Destroy() = 0;
    1015                 : 
    1016                 :   /**
    1017                 :    * Notify the document that its associated ContentViewer is no longer
    1018                 :    * the current viewer for the docshell. The document might still
    1019                 :    * be rendered in "zombie state" until the next document is ready.
    1020                 :    * The document should save form control state.
    1021                 :    */
    1022                 :   virtual void RemovedFromDocShell() = 0;
    1023                 :   
    1024                 :   /**
    1025                 :    * Get the layout history state that should be used to save and restore state
    1026                 :    * for nodes in this document.  This may return null; if that happens state
    1027                 :    * saving and restoration is not possible.
    1028                 :    */
    1029                 :   virtual already_AddRefed<nsILayoutHistoryState> GetLayoutHistoryState() const = 0;
    1030                 : 
    1031                 :   /**
    1032                 :    * Methods that can be used to prevent onload firing while an event that
    1033                 :    * should block onload is posted.  onload is guaranteed to not fire until
    1034                 :    * either all calls to BlockOnload() have been matched by calls to
    1035                 :    * UnblockOnload() or the load has been stopped altogether (by the user
    1036                 :    * pressing the Stop button, say).
    1037                 :    */
    1038                 :   virtual void BlockOnload() = 0;
    1039                 :   /**
    1040                 :    * @param aFireSync whether to fire onload synchronously.  If false,
    1041                 :    * onload will fire asynchronously after all onload blocks have been
    1042                 :    * removed.  It will NOT fire from inside UnblockOnload.  If true,
    1043                 :    * onload may fire from inside UnblockOnload.
    1044                 :    */
    1045                 :   virtual void UnblockOnload(bool aFireSync) = 0;
    1046                 : 
    1047                 :   /**
    1048                 :    * Notification that the page has been shown, for documents which are loaded
    1049                 :    * into a DOM window.  This corresponds to the completion of document load,
    1050                 :    * or to the page's presentation being restored into an existing DOM window.
    1051                 :    * This notification fires applicable DOM events to the content window.  See
    1052                 :    * nsIDOMPageTransitionEvent.idl for a description of the |aPersisted|
    1053                 :    * parameter. If aDispatchStartTarget is null, the pageshow event is
    1054                 :    * dispatched on the ScriptGlobalObject for this document, otherwise it's
    1055                 :    * dispatched on aDispatchStartTarget.
    1056                 :    * Note: if aDispatchStartTarget isn't null, the showing state of the
    1057                 :    * document won't be altered.
    1058                 :    */
    1059                 :   virtual void OnPageShow(bool aPersisted,
    1060                 :                           nsIDOMEventTarget* aDispatchStartTarget) = 0;
    1061                 : 
    1062                 :   /**
    1063                 :    * Notification that the page has been hidden, for documents which are loaded
    1064                 :    * into a DOM window.  This corresponds to the unloading of the document, or
    1065                 :    * to the document's presentation being saved but removed from an existing
    1066                 :    * DOM window.  This notification fires applicable DOM events to the content
    1067                 :    * window.  See nsIDOMPageTransitionEvent.idl for a description of the
    1068                 :    * |aPersisted| parameter. If aDispatchStartTarget is null, the pagehide
    1069                 :    * event is dispatched on the ScriptGlobalObject for this document,
    1070                 :    * otherwise it's dispatched on aDispatchStartTarget.
    1071                 :    * Note: if aDispatchStartTarget isn't null, the showing state of the
    1072                 :    * document won't be altered.
    1073                 :    */
    1074                 :   virtual void OnPageHide(bool aPersisted,
    1075                 :                           nsIDOMEventTarget* aDispatchStartTarget) = 0;
    1076                 :   
    1077                 :   /*
    1078                 :    * We record the set of links in the document that are relevant to
    1079                 :    * style.
    1080                 :    */
    1081                 :   /**
    1082                 :    * Notification that an element is a link that is relevant to style.
    1083                 :    */
    1084                 :   virtual void AddStyleRelevantLink(mozilla::dom::Link* aLink) = 0;
    1085                 :   /**
    1086                 :    * Notification that an element is a link and its URI might have been
    1087                 :    * changed or the element removed. If the element is still a link relevant
    1088                 :    * to style, then someone must ensure that AddStyleRelevantLink is
    1089                 :    * (eventually) called on it again.
    1090                 :    */
    1091                 :   virtual void ForgetLink(mozilla::dom::Link* aLink) = 0;
    1092                 : 
    1093                 :   /**
    1094                 :    * Resets and removes a box object from the document's box object cache
    1095                 :    *
    1096                 :    * @param aElement canonical nsIContent pointer of the box object's element
    1097                 :    */
    1098                 :   virtual void ClearBoxObjectFor(nsIContent *aContent) = 0;
    1099                 : 
    1100                 :   /**
    1101                 :    * Get the box object for an element. This is not exposed through a
    1102                 :    * scriptable interface except for XUL documents.
    1103                 :    */
    1104                 :   NS_IMETHOD GetBoxObjectFor(nsIDOMElement* aElement, nsIBoxObject** aResult) = 0;
    1105                 : 
    1106                 :   /**
    1107                 :    * Get the compatibility mode for this document
    1108                 :    */
    1109             220 :   nsCompatibility GetCompatibilityMode() const {
    1110             220 :     return mCompatMode;
    1111                 :   }
    1112                 :   
    1113                 :   /**
    1114                 :    * Check whether we've ever fired a DOMTitleChanged event for this
    1115                 :    * document.
    1116                 :    */
    1117            1038 :   bool HaveFiredDOMTitleChange() const {
    1118            1038 :     return mHaveFiredTitleChange;
    1119                 :   }
    1120                 : 
    1121                 :   /**
    1122                 :    * See GetXBLChildNodesFor on nsBindingManager
    1123                 :    */
    1124                 :   virtual nsresult GetXBLChildNodesFor(nsIContent* aContent,
    1125                 :                                        nsIDOMNodeList** aResult) = 0;
    1126                 : 
    1127                 :   /**
    1128                 :    * See GetContentListFor on nsBindingManager
    1129                 :    */
    1130                 :   virtual nsresult GetContentListFor(nsIContent* aContent,
    1131                 :                                      nsIDOMNodeList** aResult) = 0;
    1132                 : 
    1133                 :   /**
    1134                 :    * Helper for nsIDOMDocument::elementFromPoint implementation that allows
    1135                 :    * ignoring the scroll frame and/or avoiding layout flushes.
    1136                 :    *
    1137                 :    * @see nsIDOMWindowUtils::elementFromPoint
    1138                 :    */
    1139                 :   virtual nsresult ElementFromPointHelper(float aX, float aY,
    1140                 :                                           bool aIgnoreRootScrollFrame,
    1141                 :                                           bool aFlushLayout,
    1142                 :                                           nsIDOMElement** aReturn) = 0;
    1143                 : 
    1144                 :   virtual nsresult NodesFromRectHelper(float aX, float aY,
    1145                 :                                        float aTopSize, float aRightSize,
    1146                 :                                        float aBottomSize, float aLeftSize,
    1147                 :                                        bool aIgnoreRootScrollFrame,
    1148                 :                                        bool aFlushLayout,
    1149                 :                                        nsIDOMNodeList** aReturn) = 0;
    1150                 : 
    1151                 :   /**
    1152                 :    * See FlushSkinBindings on nsBindingManager
    1153                 :    */
    1154                 :   virtual void FlushSkinBindings() = 0;
    1155                 : 
    1156                 :   /**
    1157                 :    * To batch DOMSubtreeModified, document needs to be informed when
    1158                 :    * a mutation event might be dispatched, even if the event isn't actually
    1159                 :    * created because there are no listeners for it.
    1160                 :    *
    1161                 :    * @param aTarget is the target for the mutation event.
    1162                 :    */
    1163            3616 :   void MayDispatchMutationEvent(nsINode* aTarget)
    1164                 :   {
    1165            3616 :     if (mSubtreeModifiedDepth > 0) {
    1166              89 :       mSubtreeModifiedTargets.AppendObject(aTarget);
    1167                 :     }
    1168            3616 :   }
    1169                 : 
    1170                 :   /**
    1171                 :    * Marks as not-going-to-be-collected for the given generation of
    1172                 :    * cycle collection.
    1173                 :    */
    1174             118 :   void MarkUncollectableForCCGeneration(PRUint32 aGeneration)
    1175                 :   {
    1176             118 :     mMarkedCCGeneration = aGeneration;
    1177             118 :   }
    1178                 : 
    1179                 :   /**
    1180                 :    * Gets the cycle collector generation this document is marked for.
    1181                 :    */
    1182          547052 :   PRUint32 GetMarkedCCGeneration()
    1183                 :   {
    1184          547052 :     return mMarkedCCGeneration;
    1185                 :   }
    1186                 : 
    1187               0 :   bool IsLoadedAsData()
    1188                 :   {
    1189               0 :     return mLoadedAsData;
    1190                 :   }
    1191                 : 
    1192               0 :   bool MayStartLayout()
    1193                 :   {
    1194               0 :     return mMayStartLayout;
    1195                 :   }
    1196                 : 
    1197            1050 :   void SetMayStartLayout(bool aMayStartLayout)
    1198                 :   {
    1199            1050 :     mMayStartLayout = aMayStartLayout;
    1200            1050 :   }
    1201                 : 
    1202               0 :   already_AddRefed<nsIDocumentEncoder> GetCachedEncoder()
    1203                 :   {
    1204               0 :     return mCachedEncoder.forget();
    1205                 :   }
    1206                 : 
    1207               0 :   void SetCachedEncoder(already_AddRefed<nsIDocumentEncoder> aEncoder)
    1208                 :   {
    1209               0 :     mCachedEncoder = aEncoder;
    1210               0 :   }
    1211                 : 
    1212                 :   // In case of failure, the document really can't initialize the frame loader.
    1213                 :   virtual nsresult InitializeFrameLoader(nsFrameLoader* aLoader) = 0;
    1214                 :   // In case of failure, the caller must handle the error, for example by
    1215                 :   // finalizing frame loader asynchronously.
    1216                 :   virtual nsresult FinalizeFrameLoader(nsFrameLoader* aLoader) = 0;
    1217                 :   // Removes the frame loader of aShell from the initialization list.
    1218                 :   virtual void TryCancelFrameLoaderInitialization(nsIDocShell* aShell) = 0;
    1219                 :   //  Returns true if the frame loader of aShell is in the finalization list.
    1220                 :   virtual bool FrameLoaderScheduledToBeFinalized(nsIDocShell* aShell) = 0;
    1221                 : 
    1222                 :   /**
    1223                 :    * Check whether this document is a root document that is not an
    1224                 :    * external resource.
    1225                 :    */
    1226               0 :   bool IsRootDisplayDocument() const
    1227                 :   {
    1228               0 :     return !mParentDocument && !mDisplayDocument;
    1229                 :   }
    1230                 : 
    1231               0 :   bool IsBeingUsedAsImage() const {
    1232               0 :     return mIsBeingUsedAsImage;
    1233                 :   }
    1234                 : 
    1235               0 :   void SetIsBeingUsedAsImage() {
    1236               0 :     mIsBeingUsedAsImage = true;
    1237               0 :   }
    1238                 : 
    1239               0 :   bool IsResourceDoc() const {
    1240               0 :     return IsBeingUsedAsImage() || // Are we a helper-doc for an SVG image?
    1241               0 :       !!mDisplayDocument;          // Are we an external resource doc?
    1242                 :   }
    1243                 : 
    1244                 :   /**
    1245                 :    * Get the document for which this document is an external resource.  This
    1246                 :    * will be null if this document is not an external resource.  Otherwise,
    1247                 :    * GetDisplayDocument() will return a non-null document, and
    1248                 :    * GetDisplayDocument()->GetDisplayDocument() is guaranteed to be null.
    1249                 :    */
    1250               8 :   nsIDocument* GetDisplayDocument() const
    1251                 :   {
    1252               8 :     return mDisplayDocument;
    1253                 :   }
    1254                 :   
    1255                 :   /**
    1256                 :    * Set the display document for this document.  aDisplayDocument must not be
    1257                 :    * null.
    1258                 :    */
    1259               0 :   void SetDisplayDocument(nsIDocument* aDisplayDocument)
    1260                 :   {
    1261               0 :     NS_PRECONDITION(!GetShell() &&
    1262                 :                     !nsCOMPtr<nsISupports>(GetContainer()) &&
    1263                 :                     !GetWindow() &&
    1264                 :                     !GetScriptGlobalObject(),
    1265                 :                     "Shouldn't set mDisplayDocument on documents that already "
    1266                 :                     "have a presentation or a docshell or a window");
    1267               0 :     NS_PRECONDITION(aDisplayDocument != this, "Should be different document");
    1268               0 :     NS_PRECONDITION(!aDisplayDocument->GetDisplayDocument(),
    1269                 :                     "Display documents should not nest");
    1270               0 :     mDisplayDocument = aDisplayDocument;
    1271               0 :   }
    1272                 : 
    1273                 :   /**
    1274                 :    * A class that represents an external resource load that has begun but
    1275                 :    * doesn't have a document yet.  Observers can be registered on this object,
    1276                 :    * and will be notified after the document is created.  Observers registered
    1277                 :    * after the document has been created will NOT be notified.  When observers
    1278                 :    * are notified, the subject will be the newly-created document, the topic
    1279                 :    * will be "external-resource-document-created", and the data will be null.
    1280                 :    * If document creation fails for some reason, observers will still be
    1281                 :    * notified, with a null document pointer.
    1282                 :    */
    1283                 :   class ExternalResourceLoad : public nsISupports
    1284               0 :   {
    1285                 :   public:
    1286               0 :     virtual ~ExternalResourceLoad() {}
    1287                 : 
    1288               0 :     void AddObserver(nsIObserver* aObserver) {
    1289               0 :       NS_PRECONDITION(aObserver, "Must have observer");
    1290               0 :       mObservers.AppendElement(aObserver);
    1291               0 :     }
    1292                 : 
    1293               0 :     const nsTArray< nsCOMPtr<nsIObserver> > & Observers() {
    1294               0 :       return mObservers;
    1295                 :     }
    1296                 :   protected:
    1297                 :     nsAutoTArray< nsCOMPtr<nsIObserver>, 8 > mObservers;    
    1298                 :   };
    1299                 : 
    1300                 :   /**
    1301                 :    * Request an external resource document for aURI.  This will return the
    1302                 :    * resource document if available.  If one is not available yet, it will
    1303                 :    * start loading as needed, and the pending load object will be returned in
    1304                 :    * aPendingLoad so that the caller can register an observer to wait for the
    1305                 :    * load.  If this function returns null and doesn't return a pending load,
    1306                 :    * that means that there is no resource document for this URI and won't be
    1307                 :    * one in the future.
    1308                 :    *
    1309                 :    * @param aURI the URI to get
    1310                 :    * @param aRequestingNode the node making the request
    1311                 :    * @param aPendingLoad the pending load for this request, if any
    1312                 :    */
    1313                 :   virtual nsIDocument*
    1314                 :     RequestExternalResource(nsIURI* aURI,
    1315                 :                             nsINode* aRequestingNode,
    1316                 :                             ExternalResourceLoad** aPendingLoad) = 0;
    1317                 : 
    1318                 :   /**
    1319                 :    * Enumerate the external resource documents associated with this document.
    1320                 :    * The enumerator callback should return true to continue enumerating, or
    1321                 :    * false to stop.  This callback will never get passed a null aDocument.
    1322                 :    */
    1323                 :   virtual void EnumerateExternalResources(nsSubDocEnumFunc aCallback,
    1324                 :                                           void* aData) = 0;
    1325                 : 
    1326                 :   /**
    1327                 :    * Return whether the document is currently showing (in the sense of
    1328                 :    * OnPageShow() having been called already and OnPageHide() not having been
    1329                 :    * called yet.
    1330                 :    */
    1331               0 :   bool IsShowing() const { return mIsShowing; }
    1332                 :   /**
    1333                 :    * Return whether the document is currently visible (in the sense of
    1334                 :    * OnPageHide having been called and OnPageShow not yet having been called)
    1335                 :    */
    1336               0 :   bool IsVisible() const { return mVisible; }
    1337                 :   /**
    1338                 :    * Return true when this document is active, i.e., the active document
    1339                 :    * in a content viewer.
    1340                 :    */
    1341               0 :   bool IsActive() const { return mDocumentContainer && !mRemovedFromDocShell; }
    1342                 : 
    1343                 :   void RegisterFreezableElement(nsIContent* aContent);
    1344                 :   bool UnregisterFreezableElement(nsIContent* aContent);
    1345                 :   typedef void (* FreezableElementEnumerator)(nsIContent*, void*);
    1346                 :   void EnumerateFreezableElements(FreezableElementEnumerator aEnumerator,
    1347                 :                                   void* aData);
    1348                 : 
    1349                 :   // Indicates whether mAnimationController has been (lazily) initialized.
    1350                 :   // If this returns true, we're promising that GetAnimationController()
    1351                 :   // will have a non-null return value.
    1352               0 :   bool HasAnimationController()  { return !!mAnimationController; }
    1353                 : 
    1354                 :   // Getter for this document's SMIL Animation Controller. Performs lazy
    1355                 :   // initialization, if this document supports animation and if
    1356                 :   // mAnimationController isn't yet initialized.
    1357                 :   virtual nsSMILAnimationController* GetAnimationController() = 0;
    1358                 : 
    1359                 :   // Makes the images on this document capable of having their animation
    1360                 :   // active or suspended. An Image will animate as long as at least one of its
    1361                 :   // owning Documents needs it to animate; otherwise it can suspend.
    1362                 :   virtual void SetImagesNeedAnimating(bool aAnimating) = 0;
    1363                 : 
    1364                 :   /**
    1365                 :    * Prevents user initiated events from being dispatched to the document and
    1366                 :    * subdocuments.
    1367                 :    */
    1368                 :   virtual void SuppressEventHandling(PRUint32 aIncrease = 1) = 0;
    1369                 : 
    1370                 :   /**
    1371                 :    * Unsuppress event handling.
    1372                 :    * @param aFireEvents If true, delayed events (focus/blur) will be fired
    1373                 :    *                    asynchronously.
    1374                 :    */
    1375                 :   virtual void UnsuppressEventHandlingAndFireEvents(bool aFireEvents) = 0;
    1376                 : 
    1377               0 :   PRUint32 EventHandlingSuppressed() const { return mEventsSuppressed; }
    1378                 : 
    1379               0 :   bool IsEventHandlingEnabled() {
    1380               0 :     return !EventHandlingSuppressed() && mScriptGlobalObject;
    1381                 :   }
    1382                 : 
    1383                 :   /**
    1384                 :    * Increment the number of external scripts being evaluated.
    1385                 :    */
    1386               0 :   void BeginEvaluatingExternalScript() { ++mExternalScriptsBeingEvaluated; }
    1387                 : 
    1388                 :   /**
    1389                 :    * Decrement the number of external scripts being evaluated.
    1390                 :    */
    1391               0 :   void EndEvaluatingExternalScript() { --mExternalScriptsBeingEvaluated; }
    1392                 : 
    1393               0 :   bool IsDNSPrefetchAllowed() const { return mAllowDNSPrefetch; }
    1394                 : 
    1395                 :   /**
    1396                 :    * Returns true if this document is allowed to contain XUL element and
    1397                 :    * use non-builtin XBL bindings.
    1398                 :    */
    1399             144 :   bool AllowXULXBL() {
    1400                 :     return mAllowXULXBL == eTriTrue ? true :
    1401                 :            mAllowXULXBL == eTriFalse ? false :
    1402             144 :            InternalAllowXULXBL();
    1403                 :   }
    1404                 : 
    1405             539 :   void ForceEnableXULXBL() {
    1406             539 :     mAllowXULXBL = eTriTrue;
    1407             539 :   }
    1408                 : 
    1409                 :   /**
    1410                 :    * true when this document is a static clone of a normal document.
    1411                 :    * For example print preview and printing use static documents.
    1412                 :    */
    1413               0 :   bool IsStaticDocument() { return mIsStaticDocument; }
    1414                 : 
    1415                 :   /**
    1416                 :    * Clones the document and subdocuments and stylesheet etc.
    1417                 :    * @param aCloneContainer The container for the clone document.
    1418                 :    */
    1419                 :   virtual already_AddRefed<nsIDocument>
    1420                 :   CreateStaticClone(nsISupports* aCloneContainer);
    1421                 : 
    1422                 :   /**
    1423                 :    * If this document is a static clone, this returns the original
    1424                 :    * document.
    1425                 :    */
    1426               0 :   nsIDocument* GetOriginalDocument()
    1427                 :   {
    1428               0 :     MOZ_ASSERT(!mOriginalDocument || !mOriginalDocument->GetOriginalDocument());
    1429               0 :     return mOriginalDocument;
    1430                 :   }
    1431                 : 
    1432                 :   /**
    1433                 :    * Called by nsParser to preload images. Can be removed and code moved
    1434                 :    * to nsPreloadURIs::PreloadURIs() in file nsParser.cpp whenever the
    1435                 :    * parser-module is linked with gklayout-module.  aCrossOriginAttr should
    1436                 :    * be a void string if the attr is not present.
    1437                 :    */
    1438                 :   virtual void MaybePreLoadImage(nsIURI* uri,
    1439                 :                                  const nsAString& aCrossOriginAttr) = 0;
    1440                 : 
    1441                 :   /**
    1442                 :    * Called by nsParser to preload style sheets.  Can also be merged into
    1443                 :    * the parser if and when the parser is merged with libgklayout.
    1444                 :    */
    1445                 :   virtual void PreloadStyle(nsIURI* aURI, const nsAString& aCharset) = 0;
    1446                 : 
    1447                 :   /**
    1448                 :    * Called by the chrome registry to load style sheets.  Can be put
    1449                 :    * back there if and when when that module is merged with libgklayout.
    1450                 :    *
    1451                 :    * This always does a synchronous load.  If aIsAgentSheet is true,
    1452                 :    * it also uses the system principal and enables unsafe rules.
    1453                 :    * DO NOT USE FOR UNTRUSTED CONTENT.
    1454                 :    */
    1455                 :   virtual nsresult LoadChromeSheetSync(nsIURI* aURI, bool aIsAgentSheet,
    1456                 :                                        nsCSSStyleSheet** aSheet) = 0;
    1457                 : 
    1458                 :   /**
    1459                 :    * Returns true if the locale used for the document specifies a direction of
    1460                 :    * right to left. For chrome documents, this comes from the chrome registry.
    1461                 :    * This is used to determine the current state for the :-moz-locale-dir pseudoclass
    1462                 :    * so once can know whether a document is expected to be rendered left-to-right
    1463                 :    * or right-to-left.
    1464                 :    */
    1465               0 :   virtual bool IsDocumentRightToLeft() { return false; }
    1466                 : 
    1467                 :   enum DocumentTheme {
    1468                 :     Doc_Theme_Uninitialized, // not determined yet
    1469                 :     Doc_Theme_None,
    1470                 :     Doc_Theme_Neutral,
    1471                 :     Doc_Theme_Dark,
    1472                 :     Doc_Theme_Bright
    1473                 :   };
    1474                 : 
    1475                 :   /**
    1476                 :    * Set the document's pending state object (as serialized using structured
    1477                 :    * clone).
    1478                 :    */
    1479               0 :   void SetStateObject(nsIStructuredCloneContainer *scContainer)
    1480                 :   {
    1481               0 :     mStateObjectContainer = scContainer;
    1482               0 :     mStateObjectCached = nsnull;
    1483               0 :   }
    1484                 : 
    1485                 :   /**
    1486                 :    * Returns Doc_Theme_None if there is no lightweight theme specified,
    1487                 :    * Doc_Theme_Dark for a dark theme, Doc_Theme_Bright for a light theme, and
    1488                 :    * Doc_Theme_Neutral for any other theme. This is used to determine the state
    1489                 :    * of the pseudoclasses :-moz-lwtheme and :-moz-lwtheme-text.
    1490                 :    */
    1491               0 :   virtual int GetDocumentLWTheme() { return Doc_Theme_None; }
    1492                 : 
    1493                 :   /**
    1494                 :    * Returns the document state.
    1495                 :    * Document state bits have the form NS_DOCUMENT_STATE_* and are declared in
    1496                 :    * nsIDocument.h.
    1497                 :    */
    1498                 :   virtual nsEventStates GetDocumentState() = 0;
    1499                 : 
    1500                 :   virtual nsISupports* GetCurrentContentSink() = 0;
    1501                 : 
    1502                 :   /**
    1503                 :    * Register/Unregister a filedata uri as being "owned" by this document. 
    1504                 :    * I.e. that its lifetime is connected with this document. When the document
    1505                 :    * goes away it should "kill" the uri by calling
    1506                 :    * nsBlobProtocolHandler::RemoveFileDataEntry
    1507                 :    */
    1508                 :   virtual void RegisterFileDataUri(const nsACString& aUri) = 0;
    1509                 :   virtual void UnregisterFileDataUri(const nsACString& aUri) = 0;
    1510                 : 
    1511                 :   virtual void SetScrollToRef(nsIURI *aDocumentURI) = 0;
    1512                 :   virtual void ScrollToRef() = 0;
    1513                 :   virtual void ResetScrolledToRefAlready() = 0;
    1514                 :   virtual void SetChangeScrollPosWhenScrollingToRef(bool aValue) = 0;
    1515                 : 
    1516                 :   /**
    1517                 :    * This method is similar to GetElementById() from nsIDOMDocument but it
    1518                 :    * returns a mozilla::dom::Element instead of a nsIDOMElement.
    1519                 :    * It prevents converting nsIDOMElement to mozilla::dom::Element which is
    1520                 :    * already converted from mozilla::dom::Element.
    1521                 :    */
    1522                 :   virtual Element* GetElementById(const nsAString& aElementId) = 0;
    1523                 : 
    1524                 :   /**
    1525                 :    * This method returns _all_ the elements in this document which
    1526                 :    * have id aElementId, if there are any.  Otherwise it returns null.
    1527                 :    * The entries of the nsSmallVoidArray are Element*
    1528                 :    */
    1529                 :   virtual const nsSmallVoidArray* GetAllElementsForId(const nsAString& aElementId) const = 0;
    1530                 : 
    1531                 :   /**
    1532                 :    * Lookup an image element using its associated ID, which is usually provided
    1533                 :    * by |-moz-element()|. Similar to GetElementById, with the difference that
    1534                 :    * elements set using mozSetImageElement have higher priority.
    1535                 :    * @param aId the ID associated the element we want to lookup
    1536                 :    * @return the element associated with |aId|
    1537                 :    */
    1538                 :   virtual Element* LookupImageElement(const nsAString& aElementId) = 0;
    1539                 : 
    1540                 :   nsresult ScheduleFrameRequestCallback(nsIFrameRequestCallback* aCallback,
    1541                 :                                         PRInt32 *aHandle);
    1542                 :   void CancelFrameRequestCallback(PRInt32 aHandle);
    1543                 : 
    1544                 :   typedef nsTArray< nsCOMPtr<nsIFrameRequestCallback> > FrameRequestCallbackList;
    1545                 :   /**
    1546                 :    * Put this document's frame request callbacks into the provided
    1547                 :    * list, and forget about them.
    1548                 :    */
    1549                 :   void TakeFrameRequestCallbacks(FrameRequestCallbackList& aCallbacks);
    1550                 : 
    1551                 :   // This returns true when the document tree is being teared down.
    1552               0 :   bool InUnlinkOrDeletion() { return mInUnlinkOrDeletion; }
    1553                 : 
    1554                 :   /*
    1555                 :    * Image Tracking
    1556                 :    *
    1557                 :    * Style and content images register their imgIRequests with their document
    1558                 :    * so that the document can efficiently tell all descendant images when they
    1559                 :    * are and are not visible. When an image is on-screen, we want to call
    1560                 :    * LockImage() on it so that it doesn't do things like discarding frame data
    1561                 :    * to save memory. The PresShell informs the document whether its images
    1562                 :    * should be locked or not via SetImageLockingState().
    1563                 :    *
    1564                 :    * See bug 512260.
    1565                 :    */
    1566                 : 
    1567                 :   // Add/Remove images from the document image tracker
    1568                 :   virtual nsresult AddImage(imgIRequest* aImage) = 0;
    1569                 :   virtual nsresult RemoveImage(imgIRequest* aImage) = 0;
    1570                 : 
    1571                 :   // Makes the images on this document locked/unlocked. By default, the locking
    1572                 :   // state is unlocked/false.
    1573                 :   virtual nsresult SetImageLockingState(bool aLocked) = 0;
    1574                 : 
    1575                 :   virtual nsresult GetStateObject(nsIVariant** aResult) = 0;
    1576                 : 
    1577                 :   virtual nsDOMNavigationTiming* GetNavigationTiming() const = 0;
    1578                 : 
    1579                 :   virtual nsresult SetNavigationTiming(nsDOMNavigationTiming* aTiming) = 0;
    1580                 : 
    1581                 :   virtual Element* FindImageMap(const nsAString& aNormalizedMapName) = 0;
    1582                 : 
    1583                 :   // Called to notify the document that a listener on the "mozaudioavailable"
    1584                 :   // event has been added. Media elements in the document need to ensure they
    1585                 :   // fire the event.
    1586                 :   virtual void NotifyAudioAvailableListener() = 0;
    1587                 : 
    1588                 :   // Returns true if the document has "mozaudioavailable" event listeners.
    1589                 :   virtual bool HasAudioAvailableListeners() = 0;
    1590                 : 
    1591                 :   // Add aLink to the set of links that need their status resolved. 
    1592                 :   void RegisterPendingLinkUpdate(mozilla::dom::Link* aLink);
    1593                 :   
    1594                 :   // Remove aLink from the set of links that need their status resolved.
    1595                 :   // This function must be called when links are removed from the document.
    1596                 :   void UnregisterPendingLinkUpdate(mozilla::dom::Link* aElement);
    1597                 : 
    1598                 :   // Update state on links in mLinksToUpdate.  This function must
    1599                 :   // be called prior to selector matching.
    1600                 :   void FlushPendingLinkUpdates();
    1601                 : 
    1602                 : #define DEPRECATED_OPERATION(_op) e##_op,
    1603                 :   enum DeprecatedOperations {
    1604                 : #include "nsDeprecatedOperationList.h"
    1605                 :     eDeprecatedOperationCount
    1606                 :   };
    1607                 : #undef DEPRECATED_OPERATION
    1608                 :   void WarnOnceAbout(DeprecatedOperations aOperation);
    1609                 : 
    1610                 :   virtual void PostVisibilityUpdateEvent() = 0;
    1611                 :   
    1612               0 :   bool IsSyntheticDocument() { return mIsSyntheticDocument; }
    1613                 : 
    1614               0 :   void SetNeedLayoutFlush() {
    1615               0 :     mNeedLayoutFlush = true;
    1616               0 :     if (mDisplayDocument) {
    1617               0 :       mDisplayDocument->SetNeedLayoutFlush();
    1618                 :     }
    1619               0 :   }
    1620                 : 
    1621               0 :   void SetNeedStyleFlush() {
    1622               0 :     mNeedStyleFlush = true;
    1623               0 :     if (mDisplayDocument) {
    1624               0 :       mDisplayDocument->SetNeedStyleFlush();
    1625                 :     }
    1626               0 :   }
    1627                 : 
    1628                 :   // Note: nsIDocument is a sub-class of nsINode, which has a
    1629                 :   // SizeOfExcludingThis function.  However, because nsIDocument objects can
    1630                 :   // only appear at the top of the DOM tree, we have a specialized measurement
    1631                 :   // function which returns multiple sizes.
    1632                 :   virtual void DocSizeOfExcludingThis(nsWindowSizes* aWindowSizes) const;
    1633                 :   // DocSizeOfIncludingThis doesn't need to be overridden by sub-classes
    1634                 :   // because nsIDocument inherits from nsINode;  see the comment above the
    1635                 :   // declaration of nsINode::SizeOfIncludingThis.
    1636                 :   virtual void DocSizeOfIncludingThis(nsWindowSizes* aWindowSizes) const;
    1637                 : 
    1638                 : private:
    1639                 :   PRUint64 mWarnedAbout;
    1640                 : 
    1641                 : protected:
    1642            1271 :   ~nsIDocument()
    1643            1271 :   {
    1644                 :     // XXX The cleanup of mNodeInfoManager (calling DropDocumentReference and
    1645                 :     //     releasing it) happens in the nsDocument destructor. We'd prefer to
    1646                 :     //     do it here but nsNodeInfoManager is a concrete class that we don't
    1647                 :     //     want to expose to users of the nsIDocument API outside of Gecko.
    1648            1271 :   }
    1649                 : 
    1650                 :   nsPropertyTable* GetExtraPropertyTable(PRUint16 aCategory);
    1651                 : 
    1652                 :   // Never ever call this. Only call GetWindow!
    1653                 :   virtual nsPIDOMWindow *GetWindowInternal() const = 0;
    1654                 : 
    1655                 :   // Never ever call this. Only call GetInnerWindow!
    1656                 :   virtual nsPIDOMWindow *GetInnerWindowInternal() = 0;
    1657                 : 
    1658                 :   // Never ever call this. Only call GetScriptHandlingObject!
    1659                 :   virtual nsIScriptGlobalObject* GetScriptHandlingObjectInternal() const = 0;
    1660                 : 
    1661                 :   // Never ever call this. Only call AllowXULXBL!
    1662                 :   virtual bool InternalAllowXULXBL() = 0;
    1663                 : 
    1664                 :   /**
    1665                 :    * These methods should be called before and after dispatching
    1666                 :    * a mutation event.
    1667                 :    * To make this easy and painless, use the mozAutoSubtreeModified helper class.
    1668                 :    */
    1669                 :   virtual void WillDispatchMutationEvent(nsINode* aTarget) = 0;
    1670                 :   virtual void MutationEventDispatched(nsINode* aTarget) = 0;
    1671                 :   friend class mozAutoSubtreeModified;
    1672                 : 
    1673               0 :   virtual Element* GetNameSpaceElement()
    1674                 :   {
    1675               0 :     return GetRootElement();
    1676                 :   }
    1677                 : 
    1678            2780 :   void SetContentTypeInternal(const nsACString& aType)
    1679                 :   {
    1680            2780 :     mCachedEncoder = nsnull;
    1681            2780 :     mContentType = aType;
    1682            2780 :   }
    1683                 : 
    1684               0 :   nsCString GetContentTypeInternal() const
    1685                 :   {
    1686               0 :     return mContentType;
    1687                 :   }
    1688                 : 
    1689                 :   nsCOMPtr<nsIURI> mDocumentURI;
    1690                 :   nsCOMPtr<nsIURI> mOriginalURI;
    1691                 :   nsCOMPtr<nsIURI> mDocumentBaseURI;
    1692                 : 
    1693                 :   nsWeakPtr mDocumentLoadGroup;
    1694                 : 
    1695                 :   nsWeakPtr mDocumentContainer;
    1696                 : 
    1697                 :   nsCString mCharacterSet;
    1698                 :   PRInt32 mCharacterSetSource;
    1699                 : 
    1700                 :   // This is just a weak pointer; the parent document owns its children.
    1701                 :   nsIDocument* mParentDocument;
    1702                 : 
    1703                 :   // A reference to the element last returned from GetRootElement().
    1704                 :   mozilla::dom::Element* mCachedRootElement;
    1705                 : 
    1706                 :   // We'd like these to be nsRefPtrs, but that'd require us to include
    1707                 :   // additional headers that we don't want to expose.
    1708                 :   // The cleanup is handled by the nsDocument destructor.
    1709                 :   nsNodeInfoManager* mNodeInfoManager; // [STRONG]
    1710                 :   mozilla::css::Loader* mCSSLoader; // [STRONG]
    1711                 : 
    1712                 :   // The set of all object, embed, applet, video and audio elements for
    1713                 :   // which this is the owner document. (They might not be in the document.)
    1714                 :   // These are non-owning pointers, the elements are responsible for removing
    1715                 :   // themselves when they go away.
    1716                 :   nsAutoPtr<nsTHashtable<nsPtrHashKey<nsIContent> > > mFreezableElements;
    1717                 :   
    1718                 :   // The set of all links that need their status resolved.  Links must add themselves
    1719                 :   // to this set by calling RegisterPendingLinkUpdate when added to a document and must
    1720                 :   // remove themselves by calling UnregisterPendingLinkUpdate when removed from a document.
    1721                 :   nsTHashtable<nsPtrHashKey<mozilla::dom::Link> > mLinksToUpdate;
    1722                 : 
    1723                 :   // SMIL Animation Controller, lazily-initialized in GetAnimationController
    1724                 :   nsRefPtr<nsSMILAnimationController> mAnimationController;
    1725                 : 
    1726                 :   // Table of element properties for this document.
    1727                 :   nsPropertyTable mPropertyTable;
    1728                 :   nsTArray<nsAutoPtr<nsPropertyTable> > mExtraPropertyTables;
    1729                 : 
    1730                 :   // Compatibility mode
    1731                 :   nsCompatibility mCompatMode;
    1732                 : 
    1733                 :   // True if BIDI is enabled.
    1734                 :   bool mBidiEnabled;
    1735                 :   // True if a MathML element has ever been owned by this document.
    1736                 :   bool mMathMLEnabled;
    1737                 : 
    1738                 :   // True if this document is the initial document for a window.  This should
    1739                 :   // basically be true only for documents that exist in newly-opened windows or
    1740                 :   // documents created to satisfy a GetDocument() on a window when there's no
    1741                 :   // document in it.
    1742                 :   bool mIsInitialDocumentInWindow;
    1743                 : 
    1744                 :   bool mIsRegularHTML;
    1745                 :   bool mIsXUL;
    1746                 : 
    1747                 :   enum {
    1748                 :     eTriUnset = 0,
    1749                 :     eTriFalse,
    1750                 :     eTriTrue
    1751                 :   } mAllowXULXBL;
    1752                 : 
    1753                 :   // True if we're loaded as data and therefor has any dangerous stuff, such
    1754                 :   // as scripts and plugins, disabled.
    1755                 :   bool mLoadedAsData;
    1756                 : 
    1757                 :   // If true, whoever is creating the document has gotten it to the
    1758                 :   // point where it's safe to start layout on it.
    1759                 :   bool mMayStartLayout;
    1760                 :   
    1761                 :   // True iff we've ever fired a DOMTitleChanged event for this document
    1762                 :   bool mHaveFiredTitleChange;
    1763                 : 
    1764                 :   // True iff IsShowing() should be returning true
    1765                 :   bool mIsShowing;
    1766                 : 
    1767                 :   // True iff the document "page" is not hidden (i.e. currently in the
    1768                 :   // bfcache)
    1769                 :   bool mVisible;
    1770                 : 
    1771                 :   // True if our content viewer has been removed from the docshell
    1772                 :   // (it may still be displayed, but in zombie state). Form control data
    1773                 :   // has been saved.
    1774                 :   bool mRemovedFromDocShell;
    1775                 : 
    1776                 :   // True iff DNS prefetch is allowed for this document.  Note that if the
    1777                 :   // document has no window, DNS prefetch won't be performed no matter what.
    1778                 :   bool mAllowDNSPrefetch;
    1779                 :   
    1780                 :   // True when this document is a static clone of a normal document
    1781                 :   bool mIsStaticDocument;
    1782                 : 
    1783                 :   // True while this document is being cloned to a static document.
    1784                 :   bool mCreatingStaticClone;
    1785                 : 
    1786                 :   // True iff the document is being unlinked or deleted.
    1787                 :   bool mInUnlinkOrDeletion;
    1788                 : 
    1789                 :   // True if document has ever had script handling object.
    1790                 :   bool mHasHadScriptHandlingObject;
    1791                 : 
    1792                 :   // True if we're an SVG document being used as an image.
    1793                 :   bool mIsBeingUsedAsImage;
    1794                 : 
    1795                 :   // True is this document is synthetic : stand alone image, video, audio
    1796                 :   // file, etc.
    1797                 :   bool mIsSyntheticDocument;
    1798                 : 
    1799                 :   // True if this document has links whose state needs updating
    1800                 :   bool mHasLinksToUpdate;
    1801                 : 
    1802                 :   // True if a layout flush might not be a no-op
    1803                 :   bool mNeedLayoutFlush;
    1804                 : 
    1805                 :   // True if a style flush might not be a no-op
    1806                 :   bool mNeedStyleFlush;
    1807                 : 
    1808                 :   // The document's script global object, the object from which the
    1809                 :   // document can get its script context and scope. This is the
    1810                 :   // *inner* window object.
    1811                 :   nsCOMPtr<nsIScriptGlobalObject> mScriptGlobalObject;
    1812                 : 
    1813                 :   // If mIsStaticDocument is true, mOriginalDocument points to the original
    1814                 :   // document.
    1815                 :   nsCOMPtr<nsIDocument> mOriginalDocument;
    1816                 : 
    1817                 :   // The bidi options for this document.  What this bitfield means is
    1818                 :   // defined in nsBidiUtils.h
    1819                 :   PRUint32 mBidiOptions;
    1820                 : 
    1821                 :   nsCString mContentLanguage;
    1822                 : private:
    1823                 :   nsCString mContentType;
    1824                 : protected:
    1825                 : 
    1826                 :   // The document's security info
    1827                 :   nsCOMPtr<nsISupports> mSecurityInfo;
    1828                 : 
    1829                 :   // if this document is part of a multipart document,
    1830                 :   // the ID can be used to distinguish it from the other parts.
    1831                 :   PRUint32 mPartID;
    1832                 :   
    1833                 :   // Cycle collector generation in which we're certain that this document
    1834                 :   // won't be collected
    1835                 :   PRUint32 mMarkedCCGeneration;
    1836                 : 
    1837                 :   nsIPresShell* mPresShell;
    1838                 : 
    1839                 :   nsCOMArray<nsINode> mSubtreeModifiedTargets;
    1840                 :   PRUint32            mSubtreeModifiedDepth;
    1841                 : 
    1842                 :   // If we're an external resource document, this will be non-null and will
    1843                 :   // point to our "display document": the one that all resource lookups should
    1844                 :   // go to.
    1845                 :   nsCOMPtr<nsIDocument> mDisplayDocument;
    1846                 : 
    1847                 :   PRUint32 mEventsSuppressed;
    1848                 : 
    1849                 :   /**
    1850                 :    * The number number of external scripts (ones with the src attribute) that
    1851                 :    * have this document as their owner and that are being evaluated right now.
    1852                 :    */
    1853                 :   PRUint32 mExternalScriptsBeingEvaluated;
    1854                 : 
    1855                 :   /**
    1856                 :    * The current frame request callback handle
    1857                 :    */
    1858                 :   PRInt32 mFrameRequestCallbackCounter;
    1859                 : 
    1860                 :   // Weak reference to mScriptGlobalObject QI:d to nsPIDOMWindow,
    1861                 :   // updated on every set of mSecriptGlobalObject.
    1862                 :   nsPIDOMWindow *mWindow;
    1863                 : 
    1864                 :   nsCOMPtr<nsIDocumentEncoder> mCachedEncoder;
    1865                 : 
    1866               0 :   struct FrameRequest {
    1867               0 :     FrameRequest(nsIFrameRequestCallback* aCallback,
    1868                 :                  PRInt32 aHandle) :
    1869                 :       mCallback(aCallback),
    1870               0 :       mHandle(aHandle)
    1871               0 :     {}
    1872                 : 
    1873                 :     // Conversion operator so that we can append these to a
    1874                 :     // FrameRequestCallbackList
    1875               0 :     operator nsIFrameRequestCallback* const () const { return mCallback; }
    1876                 : 
    1877                 :     // Comparator operators to allow RemoveElementSorted with an
    1878                 :     // integer argument on arrays of FrameRequest
    1879               0 :     bool operator==(PRInt32 aHandle) const {
    1880               0 :       return mHandle == aHandle;
    1881                 :     }
    1882               0 :     bool operator<(PRInt32 aHandle) const {
    1883               0 :       return mHandle < aHandle;
    1884                 :     }
    1885                 :     
    1886                 :     nsCOMPtr<nsIFrameRequestCallback> mCallback;
    1887                 :     PRInt32 mHandle;
    1888                 :   };
    1889                 : 
    1890                 :   nsTArray<FrameRequest> mFrameRequestCallbacks;
    1891                 : 
    1892                 :   // This object allows us to evict ourself from the back/forward cache.  The
    1893                 :   // pointer is non-null iff we're currently in the bfcache.
    1894                 :   nsIBFCacheEntry *mBFCacheEntry;
    1895                 : 
    1896                 :   // Our base target.
    1897                 :   nsString mBaseTarget;
    1898                 : 
    1899                 :   nsCOMPtr<nsIStructuredCloneContainer> mStateObjectContainer;
    1900                 :   nsCOMPtr<nsIVariant> mStateObjectCached;
    1901                 : 
    1902                 :   PRUint8 mDefaultElementType;
    1903                 : };
    1904                 : 
    1905                 : NS_DEFINE_STATIC_IID_ACCESSOR(nsIDocument, NS_IDOCUMENT_IID)
    1906                 : 
    1907                 : /**
    1908                 :  * mozAutoSubtreeModified batches DOM mutations so that a DOMSubtreeModified
    1909                 :  * event is dispatched, if necessary, when the outermost mozAutoSubtreeModified
    1910                 :  * object is deleted.
    1911                 :  */
    1912                 : class NS_STACK_CLASS mozAutoSubtreeModified
    1913                 : {
    1914                 : public:
    1915                 :   /**
    1916                 :    * @param aSubTreeOwner The document in which a subtree will be modified.
    1917                 :    * @param aTarget       The target of the possible DOMSubtreeModified event.
    1918                 :    *                      Can be nsnull, in which case mozAutoSubtreeModified
    1919                 :    *                      is just used to batch DOM mutations.
    1920                 :    */
    1921              36 :   mozAutoSubtreeModified(nsIDocument* aSubtreeOwner, nsINode* aTarget)
    1922              36 :   {
    1923              36 :     UpdateTarget(aSubtreeOwner, aTarget);
    1924              36 :   }
    1925                 : 
    1926              36 :   ~mozAutoSubtreeModified()
    1927              36 :   {
    1928              36 :     UpdateTarget(nsnull, nsnull);
    1929              36 :   }
    1930                 : 
    1931              73 :   void UpdateTarget(nsIDocument* aSubtreeOwner, nsINode* aTarget)
    1932                 :   {
    1933              73 :     if (mSubtreeOwner) {
    1934              36 :       mSubtreeOwner->MutationEventDispatched(mTarget);
    1935                 :     }
    1936                 : 
    1937              73 :     mTarget = aTarget;
    1938              73 :     mSubtreeOwner = aSubtreeOwner;
    1939              73 :     if (mSubtreeOwner) {
    1940              36 :       mSubtreeOwner->WillDispatchMutationEvent(mTarget);
    1941                 :     }
    1942              73 :   }
    1943                 : 
    1944                 : private:
    1945                 :   nsCOMPtr<nsINode>     mTarget;
    1946                 :   nsCOMPtr<nsIDocument> mSubtreeOwner;
    1947                 : };
    1948                 : 
    1949                 : // XXX These belong somewhere else
    1950                 : nsresult
    1951                 : NS_NewHTMLDocument(nsIDocument** aInstancePtrResult);
    1952                 : 
    1953                 : nsresult
    1954                 : NS_NewXMLDocument(nsIDocument** aInstancePtrResult);
    1955                 : 
    1956                 : nsresult
    1957                 : NS_NewSVGDocument(nsIDocument** aInstancePtrResult);
    1958                 : 
    1959                 : nsresult
    1960                 : NS_NewImageDocument(nsIDocument** aInstancePtrResult);
    1961                 : 
    1962                 : #ifdef MOZ_MEDIA
    1963                 : nsresult
    1964                 : NS_NewVideoDocument(nsIDocument** aInstancePtrResult);
    1965                 : #endif
    1966                 : 
    1967                 : nsresult
    1968                 : NS_NewDocumentFragment(nsIDOMDocumentFragment** aInstancePtrResult,
    1969                 :                        nsNodeInfoManager *aNodeInfoManager);
    1970                 : 
    1971                 : // Note: it's the caller's responsibility to create or get aPrincipal as needed
    1972                 : // -- this method will not attempt to get a principal based on aDocumentURI.
    1973                 : // Also, both aDocumentURI and aBaseURI must not be null.
    1974                 : nsresult
    1975                 : NS_NewDOMDocument(nsIDOMDocument** aInstancePtrResult,
    1976                 :                   const nsAString& aNamespaceURI, 
    1977                 :                   const nsAString& aQualifiedName, 
    1978                 :                   nsIDOMDocumentType* aDoctype,
    1979                 :                   nsIURI* aDocumentURI,
    1980                 :                   nsIURI* aBaseURI,
    1981                 :                   nsIPrincipal* aPrincipal,
    1982                 :                   bool aLoadedAsData,
    1983                 :                   nsIScriptGlobalObject* aEventObject,
    1984                 :                   DocumentFlavor aFlavor);
    1985                 : 
    1986                 : // This is used only for xbl documents created from the startup cache.
    1987                 : // Non-cached documents are created in the same manner as xml documents.
    1988                 : nsresult
    1989                 : NS_NewXBLDocument(nsIDOMDocument** aInstancePtrResult,
    1990                 :                   nsIURI* aDocumentURI,
    1991                 :                   nsIURI* aBaseURI,
    1992                 :                   nsIPrincipal* aPrincipal);
    1993                 : 
    1994                 : nsresult
    1995                 : NS_NewPluginDocument(nsIDocument** aInstancePtrResult);
    1996                 : 
    1997                 : inline nsIDocument*
    1998             535 : nsINode::GetOwnerDocument() const
    1999                 : {
    2000             535 :   nsIDocument* ownerDoc = OwnerDoc();
    2001                 : 
    2002             535 :   return ownerDoc != this ? ownerDoc : nsnull;
    2003                 : }
    2004                 : 
    2005                 : #endif /* nsIDocument_h___ */

Generated by: LCOV version 1.7