2003-10-05 07:29:50 +00:00
|
|
|
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
2012-05-21 11:12:37 +00:00
|
|
|
/* This Source Code Form is subject to the terms of the Mozilla Public
|
|
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
|
2003-10-05 07:29:50 +00:00
|
|
|
|
2006-03-30 08:03:04 +00:00
|
|
|
/*
|
|
|
|
* Base class for the XML and HTML content sinks, which construct a
|
|
|
|
* DOM based on information from the parser.
|
|
|
|
*/
|
|
|
|
|
2003-10-05 07:29:50 +00:00
|
|
|
#ifndef _nsContentSink_h_
|
|
|
|
#define _nsContentSink_h_
|
|
|
|
|
|
|
|
// Base class for contentsink implementations.
|
|
|
|
|
|
|
|
#include "nsICSSLoaderObserver.h"
|
|
|
|
#include "nsWeakReference.h"
|
|
|
|
#include "nsCOMPtr.h"
|
2003-12-24 13:43:25 +00:00
|
|
|
#include "nsCOMArray.h"
|
2003-10-05 07:29:50 +00:00
|
|
|
#include "nsString.h"
|
2004-06-25 12:26:02 +00:00
|
|
|
#include "nsAutoPtr.h"
|
2006-12-26 17:47:52 +00:00
|
|
|
#include "nsGkAtoms.h"
|
2006-08-12 04:46:43 +00:00
|
|
|
#include "nsTHashtable.h"
|
|
|
|
#include "nsHashKeys.h"
|
2009-01-18 20:14:14 +00:00
|
|
|
#include "nsTArray.h"
|
2007-01-30 21:21:06 +00:00
|
|
|
#include "nsITimer.h"
|
|
|
|
#include "nsStubDocumentObserver.h"
|
|
|
|
#include "nsIParserService.h"
|
|
|
|
#include "nsIContentSink.h"
|
|
|
|
#include "prlog.h"
|
|
|
|
#include "nsIRequest.h"
|
2008-02-08 22:07:51 +00:00
|
|
|
#include "nsCycleCollectionParticipant.h"
|
2009-06-25 13:13:38 +00:00
|
|
|
#include "nsThreadUtils.h"
|
2012-01-20 11:16:27 +00:00
|
|
|
#include "nsIScriptElement.h"
|
2003-10-05 07:29:50 +00:00
|
|
|
|
|
|
|
class nsIDocument;
|
|
|
|
class nsIURI;
|
|
|
|
class nsIChannel;
|
|
|
|
class nsIDocShell;
|
|
|
|
class nsIParser;
|
|
|
|
class nsIAtom;
|
|
|
|
class nsIChannel;
|
|
|
|
class nsIContent;
|
|
|
|
class nsIViewManager;
|
2004-06-25 12:26:02 +00:00
|
|
|
class nsNodeInfoManager;
|
2007-04-20 22:59:18 +00:00
|
|
|
class nsScriptLoader;
|
2008-08-28 01:15:32 +00:00
|
|
|
class nsIApplicationCache;
|
2003-10-05 07:29:50 +00:00
|
|
|
|
2010-03-02 21:00:53 +00:00
|
|
|
namespace mozilla {
|
|
|
|
namespace css {
|
|
|
|
class Loader;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-01-30 21:21:06 +00:00
|
|
|
#ifdef NS_DEBUG
|
|
|
|
|
|
|
|
extern PRLogModuleInfo* gContentSinkLogModuleInfo;
|
|
|
|
|
|
|
|
#define SINK_TRACE_CALLS 0x1
|
|
|
|
#define SINK_TRACE_REFLOW 0x2
|
|
|
|
#define SINK_ALWAYS_REFLOW 0x4
|
|
|
|
|
|
|
|
#define SINK_LOG_TEST(_lm, _bit) (PRIntn((_lm)->level) & (_bit))
|
|
|
|
|
|
|
|
#define SINK_TRACE(_lm, _bit, _args) \
|
|
|
|
PR_BEGIN_MACRO \
|
|
|
|
if (SINK_LOG_TEST(_lm, _bit)) { \
|
|
|
|
PR_LogPrint _args; \
|
|
|
|
} \
|
|
|
|
PR_END_MACRO
|
|
|
|
|
|
|
|
#else
|
|
|
|
#define SINK_TRACE(_lm, _bit, _args)
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#undef SINK_NO_INCREMENTAL
|
|
|
|
|
|
|
|
//----------------------------------------------------------------------
|
|
|
|
|
|
|
|
// 1/2 second fudge factor for window creation
|
|
|
|
#define NS_DELAY_FOR_WINDOW_CREATION 500000
|
|
|
|
|
2003-10-05 07:29:50 +00:00
|
|
|
class nsContentSink : public nsICSSLoaderObserver,
|
2007-01-30 21:21:06 +00:00
|
|
|
public nsSupportsWeakReference,
|
|
|
|
public nsStubDocumentObserver,
|
|
|
|
public nsITimerCallback
|
2003-10-05 07:29:50 +00:00
|
|
|
{
|
2008-02-08 22:07:51 +00:00
|
|
|
NS_DECL_CYCLE_COLLECTING_ISUPPORTS
|
|
|
|
NS_DECL_CYCLE_COLLECTION_CLASS_AMBIGUOUS(nsContentSink,
|
2012-01-20 11:16:27 +00:00
|
|
|
nsICSSLoaderObserver)
|
2007-01-30 21:21:06 +00:00
|
|
|
// nsITimerCallback
|
|
|
|
NS_DECL_NSITIMERCALLBACK
|
|
|
|
|
2003-10-05 07:29:50 +00:00
|
|
|
// nsICSSLoaderObserver
|
2011-09-29 06:19:26 +00:00
|
|
|
NS_IMETHOD StyleSheetLoaded(nsCSSStyleSheet* aSheet, bool aWasAlternate,
|
2005-09-12 18:41:15 +00:00
|
|
|
nsresult aStatus);
|
2003-10-05 07:29:50 +00:00
|
|
|
|
2008-07-17 03:16:23 +00:00
|
|
|
virtual nsresult ProcessMETATag(nsIContent* aContent);
|
2005-11-10 15:51:10 +00:00
|
|
|
|
2007-02-04 05:14:23 +00:00
|
|
|
// nsIContentSink implementation helpers
|
2008-10-30 21:31:00 +00:00
|
|
|
NS_HIDDEN_(nsresult) WillParseImpl(void);
|
2007-02-04 05:14:23 +00:00
|
|
|
NS_HIDDEN_(nsresult) WillInterruptImpl(void);
|
|
|
|
NS_HIDDEN_(nsresult) WillResumeImpl(void);
|
|
|
|
NS_HIDDEN_(nsresult) DidProcessATokenImpl(void);
|
|
|
|
NS_HIDDEN_(void) WillBuildModelImpl(void);
|
2011-09-29 06:19:26 +00:00
|
|
|
NS_HIDDEN_(void) DidBuildModelImpl(bool aTerminated);
|
2007-02-04 05:14:23 +00:00
|
|
|
NS_HIDDEN_(void) DropParserAndPerfHint(void);
|
2011-09-29 06:19:26 +00:00
|
|
|
bool IsScriptExecutingImpl();
|
2007-01-30 21:21:06 +00:00
|
|
|
|
|
|
|
void NotifyAppend(nsIContent* aContent, PRUint32 aStartIndex);
|
|
|
|
|
|
|
|
// nsIDocumentObserver
|
2010-10-20 07:41:05 +00:00
|
|
|
NS_DECL_NSIDOCUMENTOBSERVER_BEGINUPDATE
|
|
|
|
NS_DECL_NSIDOCUMENTOBSERVER_ENDUPDATE
|
2007-01-30 21:21:06 +00:00
|
|
|
|
|
|
|
virtual void UpdateChildCounts() = 0;
|
|
|
|
|
2011-09-29 06:19:26 +00:00
|
|
|
bool IsTimeToNotify();
|
|
|
|
bool LinkContextIsOurDocument(const nsSubstring& aAnchor);
|
2009-06-28 22:44:22 +00:00
|
|
|
|
2010-04-27 09:57:32 +00:00
|
|
|
static void InitializeStatics();
|
|
|
|
|
2003-10-05 07:29:50 +00:00
|
|
|
protected:
|
|
|
|
nsContentSink();
|
|
|
|
virtual ~nsContentSink();
|
|
|
|
|
2008-08-28 01:15:32 +00:00
|
|
|
enum CacheSelectionAction {
|
|
|
|
// There is no offline cache manifest specified by the document,
|
|
|
|
// or the document was loaded from a cache other than the one it
|
|
|
|
// specifies via its manifest attribute and IS NOT a top-level
|
|
|
|
// document, or an error occurred during the cache selection
|
|
|
|
// algorithm.
|
|
|
|
CACHE_SELECTION_NONE = 0,
|
|
|
|
|
|
|
|
// The offline cache manifest must be updated.
|
|
|
|
CACHE_SELECTION_UPDATE = 1,
|
|
|
|
|
|
|
|
// The document was loaded from a cache other than the one it
|
|
|
|
// specifies via its manifest attribute and IS a top-level
|
|
|
|
// document. In this case, the document is marked as foreign in
|
|
|
|
// the cache it was loaded from and must be reloaded from the
|
|
|
|
// correct cache (the one it specifies).
|
2008-11-06 00:01:07 +00:00
|
|
|
CACHE_SELECTION_RELOAD = 2,
|
|
|
|
|
|
|
|
// Some conditions require we must reselect the cache without the manifest
|
|
|
|
CACHE_SELECTION_RESELECT_WITHOUT_MANIFEST = 3
|
2008-08-28 01:15:32 +00:00
|
|
|
};
|
|
|
|
|
2004-01-09 23:54:21 +00:00
|
|
|
nsresult Init(nsIDocument* aDoc, nsIURI* aURI,
|
2003-10-05 07:29:50 +00:00
|
|
|
nsISupports* aContainer, nsIChannel* aChannel);
|
|
|
|
|
|
|
|
nsresult ProcessHTTPHeaders(nsIChannel* aChannel);
|
|
|
|
nsresult ProcessHeaderData(nsIAtom* aHeader, const nsAString& aValue,
|
|
|
|
nsIContent* aContent = nsnull);
|
|
|
|
nsresult ProcessLinkHeader(nsIContent* aElement,
|
|
|
|
const nsAString& aLinkData);
|
2011-06-07 20:19:06 +00:00
|
|
|
nsresult ProcessLink(nsIContent* aElement, const nsSubstring& aAnchor,
|
|
|
|
const nsSubstring& aHref, const nsSubstring& aRel,
|
|
|
|
const nsSubstring& aTitle, const nsSubstring& aType,
|
|
|
|
const nsSubstring& aMedia);
|
2003-10-05 07:29:50 +00:00
|
|
|
|
|
|
|
virtual nsresult ProcessStyleLink(nsIContent* aElement,
|
2005-03-30 00:36:57 +00:00
|
|
|
const nsSubstring& aHref,
|
2011-09-29 06:19:26 +00:00
|
|
|
bool aAlternate,
|
2005-03-30 00:36:57 +00:00
|
|
|
const nsSubstring& aTitle,
|
|
|
|
const nsSubstring& aType,
|
|
|
|
const nsSubstring& aMedia);
|
2003-10-05 07:29:50 +00:00
|
|
|
|
2007-07-09 06:19:27 +00:00
|
|
|
void PrefetchHref(const nsAString &aHref, nsIContent *aSource,
|
2011-09-29 06:19:26 +00:00
|
|
|
bool aExplicit);
|
2008-08-28 01:15:32 +00:00
|
|
|
|
2008-11-07 23:00:26 +00:00
|
|
|
// aHref can either be the usual URI format or of the form "//www.hostname.com"
|
|
|
|
// without a scheme.
|
|
|
|
void PrefetchDNS(const nsAString &aHref);
|
|
|
|
|
2008-08-28 01:15:32 +00:00
|
|
|
// Gets the cache key (used to identify items in a cache) of the channel.
|
|
|
|
nsresult GetChannelCacheKey(nsIChannel* aChannel, nsACString& aCacheKey);
|
|
|
|
|
|
|
|
// There is an offline cache manifest attribute specified and the
|
|
|
|
// document is allowed to use the offline cache. Process the cache
|
|
|
|
// selection algorithm for this document and the manifest. Result is
|
|
|
|
// an action that must be taken on the manifest, see
|
|
|
|
// CacheSelectionAction enum above.
|
|
|
|
//
|
|
|
|
// @param aLoadApplicationCache
|
|
|
|
// The application cache from which the load originated, if
|
|
|
|
// any.
|
|
|
|
// @param aManifestURI
|
|
|
|
// The manifest URI listed in the document.
|
|
|
|
// @param aFetchedWithHTTPGetOrEquiv
|
|
|
|
// TRUE if this was fetched using the HTTP GET method.
|
|
|
|
// @param aAction
|
|
|
|
// Out parameter, returns the action that should be performed
|
|
|
|
// by the calling function.
|
|
|
|
nsresult SelectDocAppCache(nsIApplicationCache *aLoadApplicationCache,
|
|
|
|
nsIURI *aManifestURI,
|
2011-09-29 06:19:26 +00:00
|
|
|
bool aFetchedWithHTTPGetOrEquiv,
|
2008-08-28 01:15:32 +00:00
|
|
|
CacheSelectionAction *aAction);
|
|
|
|
|
|
|
|
// There is no offline cache manifest attribute specified. Process
|
|
|
|
// the cache selection algorithm w/o the manifest. Result is an
|
|
|
|
// action that must be taken, see CacheSelectionAction enum
|
|
|
|
// above. In case the offline cache manifest has to be updated the
|
|
|
|
// manifest URI is returned in aManifestURI.
|
|
|
|
//
|
|
|
|
// @param aLoadApplicationCache
|
|
|
|
// The application cache from which the load originated, if
|
|
|
|
// any.
|
|
|
|
// @param aManifestURI
|
|
|
|
// Out parameter, returns the manifest URI of the cache that
|
|
|
|
// was selected.
|
|
|
|
// @param aAction
|
|
|
|
// Out parameter, returns the action that should be performed
|
|
|
|
// by the calling function.
|
|
|
|
nsresult SelectDocAppCacheNoManifest(nsIApplicationCache *aLoadApplicationCache,
|
|
|
|
nsIURI **aManifestURI,
|
|
|
|
CacheSelectionAction *aAction);
|
|
|
|
|
2009-06-28 22:44:22 +00:00
|
|
|
public:
|
2008-08-28 01:15:32 +00:00
|
|
|
// Searches for the offline cache manifest attribute and calls one
|
|
|
|
// of the above defined methods to select the document's application
|
|
|
|
// cache, let it be associated with the document and eventually
|
|
|
|
// schedule the cache update process.
|
2011-05-13 08:31:12 +00:00
|
|
|
// This method MUST be called with the empty string as the argument
|
|
|
|
// when there is no manifest attribute!
|
2010-02-02 07:43:18 +00:00
|
|
|
void ProcessOfflineManifest(const nsAString& aManifestSpec);
|
|
|
|
|
|
|
|
// Extracts the manifest attribute from the element if it is the root
|
|
|
|
// element and calls the above method.
|
2008-01-16 21:54:33 +00:00
|
|
|
void ProcessOfflineManifest(nsIContent *aElement);
|
2003-10-05 07:29:50 +00:00
|
|
|
|
2009-06-28 22:44:22 +00:00
|
|
|
protected:
|
2011-05-12 16:07:42 +00:00
|
|
|
// Tries to scroll to the URI's named anchor. Once we've successfully
|
|
|
|
// done that, further calls to this method will be ignored.
|
|
|
|
void ScrollToRef();
|
2007-04-20 22:59:18 +00:00
|
|
|
|
|
|
|
// Start layout. If aIgnorePendingSheets is true, this will happen even if
|
|
|
|
// we still have stylesheet loads pending. Otherwise, we'll wait until the
|
|
|
|
// stylesheets are all done loading.
|
2009-06-28 22:44:22 +00:00
|
|
|
public:
|
2011-09-29 06:19:26 +00:00
|
|
|
void StartLayout(bool aIgnorePendingSheets);
|
2010-08-28 05:54:57 +00:00
|
|
|
|
|
|
|
static void NotifyDocElementCreated(nsIDocument* aDoc);
|
|
|
|
|
2009-06-28 22:44:22 +00:00
|
|
|
protected:
|
2007-01-30 21:21:06 +00:00
|
|
|
void
|
2011-09-29 06:19:26 +00:00
|
|
|
FavorPerformanceHint(bool perfOverStarvation, PRUint32 starvationDelay);
|
2007-01-30 21:21:06 +00:00
|
|
|
|
|
|
|
inline PRInt32 GetNotificationInterval()
|
|
|
|
{
|
|
|
|
if (mDynamicLowerValue) {
|
|
|
|
return 1000;
|
|
|
|
}
|
|
|
|
|
2010-04-27 09:57:32 +00:00
|
|
|
return sNotificationInterval;
|
2007-01-30 21:21:06 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
virtual nsresult FlushTags() = 0;
|
|
|
|
|
2007-07-11 03:42:11 +00:00
|
|
|
// Later on we might want to make this more involved somehow
|
|
|
|
// (e.g. stop waiting after some timeout or whatnot).
|
2011-09-29 06:19:26 +00:00
|
|
|
bool WaitForPendingSheets() { return mPendingSheetCount > 0; }
|
2007-07-11 03:42:11 +00:00
|
|
|
|
2009-06-25 13:13:38 +00:00
|
|
|
void DoProcessLinkHeader();
|
|
|
|
|
2012-01-20 11:16:27 +00:00
|
|
|
void StopDeflecting() {
|
|
|
|
mDeflectedCount = sPerfDeflectCount;
|
|
|
|
}
|
|
|
|
|
2007-02-02 02:12:48 +00:00
|
|
|
private:
|
|
|
|
// People shouldn't be allocating this class directly. All subclasses should
|
|
|
|
// be allocated using a zeroing operator new.
|
|
|
|
void* operator new(size_t sz) CPP_THROW_NEW; // Not to be implemented
|
|
|
|
|
|
|
|
protected:
|
|
|
|
|
2003-12-24 13:43:25 +00:00
|
|
|
nsCOMPtr<nsIDocument> mDocument;
|
2012-01-20 11:16:27 +00:00
|
|
|
nsRefPtr<nsParserBase> mParser;
|
2004-01-09 23:54:21 +00:00
|
|
|
nsCOMPtr<nsIURI> mDocumentURI;
|
2003-10-05 07:29:50 +00:00
|
|
|
nsCOMPtr<nsIDocShell> mDocShell;
|
2010-03-02 21:00:53 +00:00
|
|
|
nsRefPtr<mozilla::css::Loader> mCSSLoader;
|
2004-06-25 12:26:02 +00:00
|
|
|
nsRefPtr<nsNodeInfoManager> mNodeInfoManager;
|
2007-04-20 22:59:18 +00:00
|
|
|
nsRefPtr<nsScriptLoader> mScriptLoader;
|
2003-10-05 07:29:50 +00:00
|
|
|
|
2007-01-30 21:21:06 +00:00
|
|
|
// back off timer notification after count
|
|
|
|
PRInt32 mBackoffCount;
|
|
|
|
|
|
|
|
// Time of last notification
|
2007-04-20 22:59:18 +00:00
|
|
|
// Note: mLastNotificationTime is only valid once mLayoutStarted is true.
|
2007-01-30 21:21:06 +00:00
|
|
|
PRTime mLastNotificationTime;
|
|
|
|
|
|
|
|
// Timer used for notification
|
|
|
|
nsCOMPtr<nsITimer> mNotificationTimer;
|
|
|
|
|
2007-03-09 23:43:50 +00:00
|
|
|
// Have we already called BeginUpdate for this set of content changes?
|
|
|
|
PRUint8 mBeganUpdate : 1;
|
|
|
|
PRUint8 mLayoutStarted : 1;
|
2007-01-30 21:21:06 +00:00
|
|
|
PRUint8 mDynamicLowerValue : 1;
|
|
|
|
PRUint8 mParsing : 1;
|
|
|
|
PRUint8 mDroppedTimer : 1;
|
2007-04-20 22:59:18 +00:00
|
|
|
// If true, we deferred starting layout until sheets load
|
|
|
|
PRUint8 mDeferredLayoutStart : 1;
|
2007-07-11 03:42:11 +00:00
|
|
|
// If true, we deferred notifications until sheets load
|
|
|
|
PRUint8 mDeferredFlushTags : 1;
|
2009-05-17 14:22:55 +00:00
|
|
|
// If false, we're not ourselves a document observer; that means we
|
|
|
|
// shouldn't be performing any more content model notifications,
|
|
|
|
// since we're not longer updating our child counts.
|
|
|
|
PRUint8 mIsDocumentObserver : 1;
|
2012-01-20 12:03:49 +00:00
|
|
|
// True if this is parser is a fragment parser or an HTML DOMParser.
|
|
|
|
// XML DOMParser leaves this to false for now!
|
|
|
|
PRUint8 mRunsToCompletion : 1;
|
2011-08-01 07:48:28 +00:00
|
|
|
// True to call prevent script execution in the fragment mode.
|
|
|
|
PRUint8 mPreventScriptExecution : 1;
|
2011-05-12 16:07:42 +00:00
|
|
|
|
2009-05-19 15:54:42 +00:00
|
|
|
//
|
2007-01-30 21:21:06 +00:00
|
|
|
// -- Can interrupt parsing members --
|
2009-05-19 15:54:42 +00:00
|
|
|
//
|
|
|
|
|
|
|
|
// The number of tokens that have been processed since we measured
|
|
|
|
// if it's time to return to the main event loop.
|
|
|
|
PRUint32 mDeflectedCount;
|
|
|
|
|
|
|
|
// Is there currently a pending event?
|
2011-09-29 06:19:26 +00:00
|
|
|
bool mHasPendingEvent;
|
2009-05-19 15:54:42 +00:00
|
|
|
|
|
|
|
// When to return to the main event loop
|
2010-03-12 06:50:13 +00:00
|
|
|
PRUint32 mCurrentParseEndTime;
|
2007-01-30 21:21:06 +00:00
|
|
|
|
|
|
|
PRInt32 mBeginLoadTime;
|
|
|
|
|
|
|
|
// Last mouse event or keyboard event time sampled by the content
|
|
|
|
// sink
|
|
|
|
PRUint32 mLastSampledUserEventTime;
|
|
|
|
|
|
|
|
PRInt32 mInMonolithicContainer;
|
|
|
|
|
|
|
|
PRInt32 mInNotification;
|
2007-05-17 23:54:35 +00:00
|
|
|
PRUint32 mUpdatesInNotification;
|
2007-02-13 21:18:25 +00:00
|
|
|
|
2007-04-20 22:59:18 +00:00
|
|
|
PRUint32 mPendingSheetCount;
|
|
|
|
|
2010-04-20 17:22:04 +00:00
|
|
|
nsRevocableEventPtr<nsRunnableMethod<nsContentSink, void, false> >
|
2009-06-25 13:13:38 +00:00
|
|
|
mProcessLinkHeaderEvent;
|
2010-04-27 09:57:32 +00:00
|
|
|
|
|
|
|
// Do we notify based on time?
|
2011-09-29 06:19:26 +00:00
|
|
|
static bool sNotifyOnTimer;
|
2010-04-27 09:57:32 +00:00
|
|
|
// Back off timer notification after count.
|
|
|
|
static PRInt32 sBackoffCount;
|
|
|
|
// Notification interval in microseconds
|
|
|
|
static PRInt32 sNotificationInterval;
|
|
|
|
// How many times to deflect in interactive/perf modes
|
|
|
|
static PRInt32 sInteractiveDeflectCount;
|
|
|
|
static PRInt32 sPerfDeflectCount;
|
|
|
|
// 0 = don't check for pending events
|
|
|
|
// 1 = don't deflect if there are pending events
|
|
|
|
// 2 = bail if there are pending events
|
|
|
|
static PRInt32 sPendingEventMode;
|
|
|
|
// How often to probe for pending events. 1=every token
|
|
|
|
static PRInt32 sEventProbeRate;
|
|
|
|
// How long to stay off the event loop in interactive/perf modes
|
|
|
|
static PRInt32 sInteractiveParseTime;
|
|
|
|
static PRInt32 sPerfParseTime;
|
|
|
|
// How long to be in interactive mode after an event
|
|
|
|
static PRInt32 sInteractiveTime;
|
|
|
|
// How long to stay in perf mode after initial loading
|
|
|
|
static PRInt32 sInitialPerfTime;
|
|
|
|
// Should we switch between perf-mode and interactive-mode
|
|
|
|
static PRInt32 sEnablePerfMode;
|
2003-10-05 07:29:50 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
#endif // _nsContentSink_h_
|