diff options
Diffstat (limited to 'layout/style/Loader.h')
| -rw-r--r-- | layout/style/Loader.h | 598 |
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 */ |