summaryrefslogtreecommitdiffstats
path: root/layout/style/Loader.h
diff options
context:
space:
mode:
authorMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
committerMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
commit5f8de423f190bbb79a62f804151bc24824fa32d8 (patch)
tree10027f336435511475e392454359edea8e25895d /layout/style/Loader.h
parent49ee0794b5d912db1f95dce6eb52d781dc210db5 (diff)
downloadUXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.gz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.lz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.xz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.zip
Add m-esr52 at 52.6.0
Diffstat (limited to 'layout/style/Loader.h')
-rw-r--r--layout/style/Loader.h598
1 files changed, 598 insertions, 0 deletions
diff --git a/layout/style/Loader.h b/layout/style/Loader.h
new file mode 100644
index 000000000..209783a80
--- /dev/null
+++ b/layout/style/Loader.h
@@ -0,0 +1,598 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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/. */
+
+/* loading of CSS style sheets using the network APIs */
+
+#ifndef mozilla_css_Loader_h
+#define mozilla_css_Loader_h
+
+#include "nsIPrincipal.h"
+#include "nsAutoPtr.h"
+#include "nsCompatibility.h"
+#include "nsCycleCollectionParticipant.h"
+#include "nsDataHashtable.h"
+#include "nsRefPtrHashtable.h"
+#include "nsStringFwd.h"
+#include "nsTArray.h"
+#include "nsTObserverArray.h"
+#include "nsURIHashKey.h"
+#include "mozilla/Attributes.h"
+#include "mozilla/CORSMode.h"
+#include "mozilla/StyleSheetInlines.h"
+#include "mozilla/Maybe.h"
+#include "mozilla/MemoryReporting.h"
+#include "mozilla/StyleBackendType.h"
+#include "mozilla/StyleSheet.h"
+#include "mozilla/net/ReferrerPolicy.h"
+
+class nsICSSLoaderObserver;
+class nsIConsoleReportCollector;
+class nsIContent;
+class nsIDocument;
+class nsMediaList;
+class nsIStyleSheetLinkingElement;
+
+namespace mozilla {
+namespace dom {
+class Element;
+} // namespace dom
+} // namespace mozilla
+
+namespace mozilla {
+
+class URIPrincipalReferrerPolicyAndCORSModeHashKey : public nsURIHashKey
+{
+public:
+ typedef URIPrincipalReferrerPolicyAndCORSModeHashKey* KeyType;
+ typedef const URIPrincipalReferrerPolicyAndCORSModeHashKey* KeyTypePointer;
+ typedef mozilla::net::ReferrerPolicy ReferrerPolicy;
+
+ explicit URIPrincipalReferrerPolicyAndCORSModeHashKey(const URIPrincipalReferrerPolicyAndCORSModeHashKey* aKey)
+ : nsURIHashKey(aKey->mKey),
+ mPrincipal(aKey->mPrincipal),
+ mCORSMode(aKey->mCORSMode),
+ mReferrerPolicy(aKey->mReferrerPolicy)
+ {
+ MOZ_COUNT_CTOR(URIPrincipalReferrerPolicyAndCORSModeHashKey);
+ }
+
+ URIPrincipalReferrerPolicyAndCORSModeHashKey(nsIURI* aURI,
+ nsIPrincipal* aPrincipal,
+ CORSMode aCORSMode,
+ ReferrerPolicy aReferrerPolicy)
+ : nsURIHashKey(aURI),
+ mPrincipal(aPrincipal),
+ mCORSMode(aCORSMode),
+ mReferrerPolicy(aReferrerPolicy)
+ {
+ MOZ_COUNT_CTOR(URIPrincipalReferrerPolicyAndCORSModeHashKey);
+ }
+ URIPrincipalReferrerPolicyAndCORSModeHashKey(const URIPrincipalReferrerPolicyAndCORSModeHashKey& toCopy)
+ : nsURIHashKey(toCopy),
+ mPrincipal(toCopy.mPrincipal),
+ mCORSMode(toCopy.mCORSMode),
+ mReferrerPolicy(toCopy.mReferrerPolicy)
+ {
+ MOZ_COUNT_CTOR(URIPrincipalReferrerPolicyAndCORSModeHashKey);
+ }
+ ~URIPrincipalReferrerPolicyAndCORSModeHashKey()
+ {
+ MOZ_COUNT_DTOR(URIPrincipalReferrerPolicyAndCORSModeHashKey);
+ }
+
+ URIPrincipalReferrerPolicyAndCORSModeHashKey* GetKey() const {
+ return const_cast<URIPrincipalReferrerPolicyAndCORSModeHashKey*>(this);
+ }
+ const URIPrincipalReferrerPolicyAndCORSModeHashKey* GetKeyPointer() const { return this; }
+
+ bool KeyEquals(const URIPrincipalReferrerPolicyAndCORSModeHashKey* aKey) const {
+ if (!nsURIHashKey::KeyEquals(aKey->mKey)) {
+ return false;
+ }
+
+ if (!mPrincipal != !aKey->mPrincipal) {
+ // One or the other has a principal, but not both... not equal
+ return false;
+ }
+
+ if (mCORSMode != aKey->mCORSMode) {
+ // Different CORS modes; we don't match
+ return false;
+ }
+
+ if (mReferrerPolicy != aKey->mReferrerPolicy) {
+ // Different ReferrerPolicy; we don't match
+ return false;
+ }
+
+ bool eq;
+ return !mPrincipal ||
+ (NS_SUCCEEDED(mPrincipal->Equals(aKey->mPrincipal, &eq)) && eq);
+ }
+
+ static const URIPrincipalReferrerPolicyAndCORSModeHashKey*
+ KeyToPointer(URIPrincipalReferrerPolicyAndCORSModeHashKey* aKey) { return aKey; }
+ static PLDHashNumber HashKey(const URIPrincipalReferrerPolicyAndCORSModeHashKey* aKey) {
+ return nsURIHashKey::HashKey(aKey->mKey);
+ }
+
+ nsIURI* GetURI() const { return nsURIHashKey::GetKey(); }
+
+ enum { ALLOW_MEMMOVE = true };
+
+protected:
+ nsCOMPtr<nsIPrincipal> mPrincipal;
+ CORSMode mCORSMode;
+ ReferrerPolicy mReferrerPolicy;
+};
+
+
+
+namespace css {
+
+class SheetLoadData;
+class ImportRule;
+
+/*********************
+ * Style sheet reuse *
+ *********************/
+
+class MOZ_RAII LoaderReusableStyleSheets
+{
+public:
+ LoaderReusableStyleSheets()
+ {
+ }
+
+ /**
+ * Look for a reusable sheet (see AddReusableSheet) matching the
+ * given URL. If found, set aResult, remove the reused sheet from
+ * the internal list, and return true. If not found, return false;
+ * in this case, aResult is not modified.
+ *
+ * @param aURL the url to match
+ * @param aResult [out] the style sheet which can be reused
+ */
+ bool FindReusableStyleSheet(nsIURI* aURL, RefPtr<CSSStyleSheet>& aResult);
+
+ /**
+ * Indicate that a certain style sheet is available for reuse if its
+ * URI matches the URI of an @import. Sheets should be added in the
+ * opposite order in which they are intended to be reused.
+ *
+ * @param aSheet the sheet which can be reused
+ */
+ void AddReusableSheet(CSSStyleSheet* aSheet) {
+ mReusableSheets.AppendElement(aSheet);
+ }
+
+private:
+ LoaderReusableStyleSheets(const LoaderReusableStyleSheets&) = delete;
+ LoaderReusableStyleSheets& operator=(const LoaderReusableStyleSheets&) = delete;
+
+ // The sheets that can be reused.
+ nsTArray<RefPtr<CSSStyleSheet>> mReusableSheets;
+};
+
+/***********************************************************************
+ * Enum that describes the state of the sheet returned by CreateSheet. *
+ ***********************************************************************/
+enum StyleSheetState {
+ eSheetStateUnknown = 0,
+ eSheetNeedsParser,
+ eSheetPending,
+ eSheetLoading,
+ eSheetComplete
+};
+
+class Loader final {
+ typedef mozilla::net::ReferrerPolicy ReferrerPolicy;
+
+public:
+ explicit Loader(StyleBackendType aType);
+ explicit Loader(nsIDocument*);
+
+ private:
+ // Private destructor, to discourage deletion outside of Release():
+ ~Loader();
+
+ public:
+ NS_INLINE_DECL_CYCLE_COLLECTING_NATIVE_REFCOUNTING(Loader)
+ NS_DECL_CYCLE_COLLECTION_NATIVE_CLASS(Loader)
+
+ void DropDocumentReference(); // notification that doc is going away
+
+ void SetCompatibilityMode(nsCompatibility aCompatMode)
+ { mCompatMode = aCompatMode; }
+ nsCompatibility GetCompatibilityMode() { return mCompatMode; }
+ nsresult SetPreferredSheet(const nsAString& aTitle);
+
+ // XXXbz sort out what the deal is with events! When should they fire?
+
+ /**
+ * Load an inline style sheet. If a successful result is returned and
+ * *aCompleted is false, then aObserver is guaranteed to be notified
+ * asynchronously once the sheet is marked complete. If an error is
+ * returned, or if *aCompleted is true, aObserver will not be notified. In
+ * addition to parsing the sheet, this method will insert it into the
+ * stylesheet list of this CSSLoader's document.
+ *
+ * @param aElement the element linking to the stylesheet. This must not be
+ * null and must implement nsIStyleSheetLinkingElement.
+ * @param aBuffer the stylesheet data
+ * @param aLineNumber the line number at which the stylesheet data started.
+ * @param aTitle the title of the sheet.
+ * @param aMedia the media string for the sheet.
+ * @param aObserver the observer to notify when the load completes.
+ * May be null.
+ * @param [out] aCompleted whether parsing of the sheet completed.
+ * @param [out] aIsAlternate whether the stylesheet ended up being an
+ * alternate sheet.
+ */
+ nsresult LoadInlineStyle(nsIContent* aElement,
+ const nsAString& aBuffer,
+ uint32_t aLineNumber,
+ const nsAString& aTitle,
+ const nsAString& aMedia,
+ mozilla::dom::Element* aScopeElement,
+ nsICSSLoaderObserver* aObserver,
+ bool* aCompleted,
+ bool* aIsAlternate);
+
+ /**
+ * Load a linked (document) stylesheet. If a successful result is returned,
+ * aObserver is guaranteed to be notified asynchronously once the sheet is
+ * loaded and marked complete. If an error is returned, aObserver will not
+ * be notified. In addition to loading the sheet, this method will insert it
+ * into the stylesheet list of this CSSLoader's document.
+ *
+ * @param aElement the element linking to the the stylesheet. May be null.
+ * @param aURL the URL of the sheet.
+ * @param aTitle the title of the sheet.
+ * @param aMedia the media string for the sheet.
+ * @param aHasAlternateRel whether the rel for this link included
+ * "alternate".
+ * @param aCORSMode the CORS mode for this load.
+ * @param aObserver the observer to notify when the load completes.
+ * May be null.
+ * @param [out] aIsAlternate whether the stylesheet actually ended up beinga
+ * an alternate sheet. Note that this need not match
+ * aHasAlternateRel.
+ */
+ nsresult LoadStyleLink(nsIContent* aElement,
+ nsIURI* aURL,
+ const nsAString& aTitle,
+ const nsAString& aMedia,
+ bool aHasAlternateRel,
+ CORSMode aCORSMode,
+ ReferrerPolicy aReferrerPolicy,
+ const nsAString& aIntegrity,
+ nsICSSLoaderObserver* aObserver,
+ bool* aIsAlternate);
+
+ /**
+ * Load a child (@import-ed) style sheet. In addition to loading the sheet,
+ * this method will insert it into the child sheet list of aParentSheet. If
+ * there is no sheet currently being parsed and the child sheet is not
+ * complete when this method returns, then when the child sheet becomes
+ * complete aParentSheet will be QIed to nsICSSLoaderObserver and
+ * asynchronously notified, just like for LoadStyleLink. Note that if the
+ * child sheet is already complete when this method returns, no
+ * nsICSSLoaderObserver notification will be sent.
+ *
+ * @param aParentSheet the parent of this child sheet
+ * @param aURL the URL of the child sheet
+ * @param aMedia the already-parsed media list for the child sheet
+ * @param aRule the @import rule importing this child. This is used to
+ * properly order the child sheet list of aParentSheet.
+ * @param aSavedSheets any saved style sheets which could be reused
+ * for this load
+ */
+ nsresult LoadChildSheet(StyleSheet* aParentSheet,
+ nsIURI* aURL,
+ nsMediaList* aMedia,
+ ImportRule* aRule,
+ LoaderReusableStyleSheets* aSavedSheets);
+
+ /**
+ * Synchronously load and return the stylesheet at aURL. Any child sheets
+ * will also be loaded synchronously. Note that synchronous loads over some
+ * protocols may involve spinning up a new event loop, so use of this method
+ * does NOT guarantee not receiving any events before the sheet loads. This
+ * method can be used to load sheets not associated with a document.
+ *
+ * @param aURL the URL of the sheet to load
+ * @param aParsingMode the mode in which to parse the sheet
+ * (see comments at enum SheetParsingMode, above).
+ * @param aUseSystemPrincipal if true, give the resulting sheet the system
+ * principal no matter where it's being loaded from.
+ * @param [out] aSheet the loaded, complete sheet.
+ *
+ * NOTE: At the moment, this method assumes the sheet will be UTF-8, but
+ * ideally it would allow arbitrary encodings. Callers should NOT depend on
+ * non-UTF8 sheets being treated as UTF-8 by this method.
+ *
+ * NOTE: A successful return from this method doesn't indicate anything about
+ * whether the data could be parsed as CSS and doesn't indicate anything
+ * about the status of child sheets of the returned sheet.
+ */
+ nsresult LoadSheetSync(nsIURI* aURL,
+ SheetParsingMode aParsingMode,
+ bool aUseSystemPrincipal,
+ RefPtr<StyleSheet>* aSheet);
+
+ /**
+ * As above, but defaults aParsingMode to eAuthorSheetFeatures and
+ * aUseSystemPrincipal to false.
+ */
+ nsresult LoadSheetSync(nsIURI* aURL, RefPtr<StyleSheet>* aSheet) {
+ return LoadSheetSync(aURL, eAuthorSheetFeatures, false, aSheet);
+ }
+
+ /**
+ * Asynchronously load the stylesheet at aURL. If a successful result is
+ * returned, aObserver is guaranteed to be notified asynchronously once the
+ * sheet is loaded and marked complete. This method can be used to load
+ * sheets not associated with a document. This method cannot be used to
+ * load user or agent sheets.
+ *
+ * @param aURL the URL of the sheet to load
+ * @param aOriginPrincipal the principal to use for security checks. This
+ * can be null to indicate that these checks should
+ * be skipped.
+ * @param aCharset the encoding to use for converting the sheet data
+ * from bytes to Unicode. May be empty to indicate that the
+ * charset of the CSSLoader's document should be used. This
+ * is only used if neither the network transport nor the
+ * sheet itself indicate an encoding.
+ * @param aObserver the observer to notify when the load completes.
+ * Must not be null.
+ * @param [out] aSheet the sheet to load. Note that the sheet may well
+ * not be loaded by the time this method returns.
+ */
+ nsresult LoadSheet(nsIURI* aURL,
+ nsIPrincipal* aOriginPrincipal,
+ const nsCString& aCharset,
+ nsICSSLoaderObserver* aObserver,
+ RefPtr<StyleSheet>* aSheet);
+
+ /**
+ * Same as above, to be used when the caller doesn't care about the
+ * not-yet-loaded sheet.
+ */
+ nsresult LoadSheet(nsIURI* aURL,
+ bool aIsPreload,
+ nsIPrincipal* aOriginPrincipal,
+ const nsCString& aCharset,
+ nsICSSLoaderObserver* aObserver,
+ CORSMode aCORSMode = CORS_NONE,
+ ReferrerPolicy aReferrerPolicy = mozilla::net::RP_Default,
+ const nsAString& aIntegrity = EmptyString());
+
+ /**
+ * Stop loading all sheets. All nsICSSLoaderObservers involved will be
+ * notified with NS_BINDING_ABORTED as the status, possibly synchronously.
+ */
+ nsresult Stop(void);
+
+ /**
+ * nsresult Loader::StopLoadingSheet(nsIURI* aURL), which notifies the
+ * nsICSSLoaderObserver with NS_BINDING_ABORTED, was removed in Bug 556446.
+ * It can be found in revision 2c44a32052ad.
+ */
+
+ /**
+ * Whether the loader is enabled or not.
+ * When disabled, processing of new styles is disabled and an attempt
+ * to do so will fail with a return code of
+ * NS_ERROR_NOT_AVAILABLE. Note that this DOES NOT disable
+ * currently loading styles or already processed styles.
+ */
+ bool GetEnabled() { return mEnabled; }
+ void SetEnabled(bool aEnabled) { mEnabled = aEnabled; }
+
+ /**
+ * Get the document we live for. May return null.
+ */
+ nsIDocument* GetDocument() const { return mDocument; }
+
+ /**
+ * Return true if this loader has pending loads (ones that would send
+ * notifications to an nsICSSLoaderObserver attached to this loader).
+ * If called from inside nsICSSLoaderObserver::StyleSheetLoaded, this will
+ * return false if and only if that is the last StyleSheetLoaded
+ * notification the CSSLoader knows it's going to send. In other words, if
+ * two sheets load at once (via load coalescing, e.g.), HasPendingLoads()
+ * will return true during notification for the first one, and false
+ * during notification for the second one.
+ */
+ bool HasPendingLoads();
+
+ /**
+ * Add an observer to this loader. The observer will be notified
+ * for all loads that would have notified their own observers (even
+ * if those loads don't have observers attached to them).
+ * Load-specific observers will be notified before generic
+ * observers. The loader holds a reference to the observer.
+ *
+ * aObserver must not be null.
+ */
+ nsresult AddObserver(nsICSSLoaderObserver* aObserver);
+
+ /**
+ * Remove an observer added via AddObserver.
+ */
+ void RemoveObserver(nsICSSLoaderObserver* aObserver);
+
+ // These interfaces are public only for the benefit of static functions
+ // within nsCSSLoader.cpp.
+
+ // IsAlternate can change our currently selected style set if none
+ // is selected and aHasAlternateRel is false.
+ bool IsAlternate(const nsAString& aTitle, bool aHasAlternateRel);
+
+ typedef nsTArray<RefPtr<SheetLoadData> > LoadDataArray;
+
+ // Measure our size.
+ size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
+
+ // Marks all the sheets at the given URI obsolete, and removes them from the
+ // cache.
+ nsresult ObsoleteSheet(nsIURI* aURI);
+
+private:
+ friend class SheetLoadData;
+
+ nsresult CheckContentPolicy(nsIPrincipal* aSourcePrincipal,
+ nsIURI* aTargetURI,
+ nsISupports* aContext,
+ bool aIsPreload);
+
+ // For inline style, the aURI param is null, but the aLinkingContent
+ // must be non-null then. The loader principal must never be null
+ // if aURI is not null.
+ // *aIsAlternate is set based on aTitle and aHasAlternateRel.
+ nsresult CreateSheet(nsIURI* aURI,
+ nsIContent* aLinkingContent,
+ nsIPrincipal* aLoaderPrincipal,
+ css::SheetParsingMode aParsingMode,
+ CORSMode aCORSMode,
+ ReferrerPolicy aReferrerPolicy,
+ const nsAString& aIntegrity,
+ bool aSyncLoad,
+ bool aHasAlternateRel,
+ const nsAString& aTitle,
+ StyleSheetState& aSheetState,
+ bool *aIsAlternate,
+ RefPtr<StyleSheet>* aSheet);
+
+ // Pass in either a media string or the nsMediaList from the
+ // CSSParser. Don't pass both.
+ // This method will set the sheet's enabled state based on isAlternate
+ void PrepareSheet(StyleSheet* aSheet,
+ const nsAString& aTitle,
+ const nsAString& aMediaString,
+ nsMediaList* aMediaList,
+ dom::Element* aScopeElement,
+ bool isAlternate);
+
+ nsresult InsertSheetInDoc(StyleSheet* aSheet,
+ nsIContent* aLinkingContent,
+ nsIDocument* aDocument);
+
+ nsresult InsertChildSheet(StyleSheet* aSheet,
+ StyleSheet* aParentSheet,
+ ImportRule* aParentRule);
+
+ nsresult InternalLoadNonDocumentSheet(nsIURI* aURL,
+ bool aIsPreload,
+ SheetParsingMode aParsingMode,
+ bool aUseSystemPrincipal,
+ nsIPrincipal* aOriginPrincipal,
+ const nsCString& aCharset,
+ RefPtr<StyleSheet>* aSheet,
+ nsICSSLoaderObserver* aObserver,
+ CORSMode aCORSMode = CORS_NONE,
+ ReferrerPolicy aReferrerPolicy = mozilla::net::RP_Default,
+ const nsAString& aIntegrity = EmptyString());
+
+ // Post a load event for aObserver to be notified about aSheet. The
+ // notification will be sent with status NS_OK unless the load event is
+ // canceled at some point (in which case it will be sent with
+ // NS_BINDING_ABORTED). aWasAlternate indicates the state when the load was
+ // initiated, not the state at some later time. aURI should be the URI the
+ // sheet was loaded from (may be null for inline sheets). aElement is the
+ // owning element for this sheet.
+ nsresult PostLoadEvent(nsIURI* aURI,
+ StyleSheet* aSheet,
+ nsICSSLoaderObserver* aObserver,
+ bool aWasAlternate,
+ nsIStyleSheetLinkingElement* aElement);
+
+ // Start the loads of all the sheets in mPendingDatas
+ void StartAlternateLoads();
+
+ // Handle an event posted by PostLoadEvent
+ void HandleLoadEvent(SheetLoadData* aEvent);
+
+ // Note: LoadSheet is responsible for releasing aLoadData and setting the
+ // sheet to complete on failure.
+ nsresult LoadSheet(SheetLoadData* aLoadData,
+ StyleSheetState aSheetState,
+ bool aIsPreLoad);
+
+ // Parse the stylesheet in aLoadData. The sheet data comes from aInput.
+ // Set aCompleted to true if the parse finished, false otherwise (e.g. if the
+ // sheet had an @import). If aCompleted is true when this returns, then
+ // ParseSheet also called SheetComplete on aLoadData.
+ nsresult ParseSheet(const nsAString& aInput,
+ SheetLoadData* aLoadData,
+ bool& aCompleted);
+
+ // The load of the sheet in aLoadData is done, one way or another. Do final
+ // cleanup, including releasing aLoadData.
+ void SheetComplete(SheetLoadData* aLoadData, nsresult aStatus);
+
+ // The guts of SheetComplete. This may be called recursively on parent datas
+ // or datas that had glommed on to a single load. The array is there so load
+ // datas whose observers need to be notified can be added to it.
+ void DoSheetComplete(SheetLoadData* aLoadData, nsresult aStatus,
+ LoadDataArray& aDatasToNotify);
+
+ StyleBackendType GetStyleBackendType() const;
+
+ struct Sheets {
+ nsBaseHashtable<URIPrincipalReferrerPolicyAndCORSModeHashKey,
+ RefPtr<StyleSheet>,
+ StyleSheet*> mCompleteSheets;
+ nsDataHashtable<URIPrincipalReferrerPolicyAndCORSModeHashKey, SheetLoadData*>
+ mLoadingDatas; // weak refs
+ nsDataHashtable<URIPrincipalReferrerPolicyAndCORSModeHashKey, SheetLoadData*>
+ mPendingDatas; // weak refs
+ };
+ nsAutoPtr<Sheets> mSheets;
+
+ // We're not likely to have many levels of @import... But likely to have
+ // some. Allocate some storage, what the hell.
+ AutoTArray<SheetLoadData*, 8> mParsingDatas;
+
+ // The array of posted stylesheet loaded events (SheetLoadDatas) we have.
+ // Note that these are rare.
+ LoadDataArray mPostedEvents;
+
+ // Our array of "global" observers
+ nsTObserverArray<nsCOMPtr<nsICSSLoaderObserver> > mObservers;
+
+ // This reference is nulled by the Document in it's destructor through
+ // DropDocumentReference().
+ nsIDocument* MOZ_NON_OWNING_REF mDocument; // the document we live for
+
+
+ // Number of datas still waiting to be notified on if we're notifying on a
+ // whole bunch at once (e.g. in one of the stop methods). This is used to
+ // make sure that HasPendingLoads() won't return false until we're notifying
+ // on the last data we're working with.
+ uint32_t mDatasToNotifyOn;
+
+ nsCompatibility mCompatMode;
+ nsString mPreferredSheet; // title of preferred sheet
+
+ // Set explicitly when the Loader(StyleBackendType) constructor is used, or
+ // taken from the document when the Loader(nsIDocument*) constructor is used.
+ mozilla::Maybe<StyleBackendType> mStyleBackendType;
+
+ bool mEnabled; // is enabled to load new styles
+
+ nsCOMPtr<nsIConsoleReportCollector> mReporter;
+
+#ifdef DEBUG
+ bool mSyncCallback;
+#endif
+};
+
+} // namespace css
+} // namespace mozilla
+
+#endif /* mozilla_css_Loader_h */