mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-10-22 01:35:35 +00:00
e7b3b3140d
Everything that goes in a PLDHashtable (and its derivatives, like nsTHashtable) needs to inherit from PLDHashEntryHdr. But through a lack of enforcement, copy constructors for these derived classes didn't explicitly invoke the copy constructor for PLDHashEntryHdr (and the compiler didn't invoke the copy constructor for us). Instead, PLDHashTable explicitly copied around the bits that the copy constructor would have. The current setup has two problems: 1) Derived classes should be using move construction, not copy construction, since anything that's shuffling hash table keys/entries around will be using move construction. 2) Derived classes should take responsibility for transferring bits of superclass state around, and not rely on something else to handle that. The second point is not a huge problem for PLDHashTable (PLDHashTable only has to copy PLDHashEntryHdr's bits in a single place), but future hash table implementations that might move entries around more aggressively would have to insert compensation code all over the place. Additionally, if moving entries is implemented via memcpy (which is quite common), PLDHashTable copying around bits *again* is inefficient. Let's fix all these problems in one go, by: 1) Explicitly declaring the set of constructors that PLDHashEntryHdr implements (and does not implement). In particular, the copy constructor is deleted, so any derived classes that attempt to make themselves copyable will be detected at compile time: the compiler will complain that the superclass type is not copyable. This change on its own will result in many compiler errors, so... 2) Change any derived classes to implement move constructors instead of copy constructors. Note that some of these move constructors are, strictly speaking, unnecessary, since the relevant classes are moved via memcpy in nsTHashtable and its derivatives.
636 lines
24 KiB
C++
636 lines
24 KiB
C++
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
|
|
/* 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 "nsCompatibility.h"
|
|
#include "nsCycleCollectionParticipant.h"
|
|
#include "nsDataHashtable.h"
|
|
#include "nsRefPtrHashtable.h"
|
|
#include "nsStringFwd.h"
|
|
#include "nsTArray.h"
|
|
#include "nsTObserverArray.h"
|
|
#include "nsURIHashKey.h"
|
|
#include "nsIStyleSheetLinkingElement.h"
|
|
#include "mozilla/Attributes.h"
|
|
#include "mozilla/CORSMode.h"
|
|
#include "mozilla/StyleSheetInlines.h"
|
|
#include "mozilla/Maybe.h"
|
|
#include "mozilla/MemoryReporting.h"
|
|
#include "mozilla/Move.h"
|
|
#include "mozilla/StyleSheet.h"
|
|
#include "mozilla/UniquePtr.h"
|
|
#include "mozilla/net/ReferrerPolicy.h"
|
|
|
|
class nsICSSLoaderObserver;
|
|
class nsIConsoleReportCollector;
|
|
class nsIContent;
|
|
class nsIDocument;
|
|
|
|
namespace mozilla {
|
|
namespace dom {
|
|
class DocGroup;
|
|
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(URIPrincipalReferrerPolicyAndCORSModeHashKey&& toMove)
|
|
: nsURIHashKey(std::move(toMove)),
|
|
mPrincipal(std::move(toMove.mPrincipal)),
|
|
mCORSMode(std::move(toMove.mCORSMode)),
|
|
mReferrerPolicy(std::move(toMove.mReferrerPolicy))
|
|
{
|
|
MOZ_COUNT_CTOR(URIPrincipalReferrerPolicyAndCORSModeHashKey);
|
|
}
|
|
|
|
explicit URIPrincipalReferrerPolicyAndCORSModeHashKey(css::SheetLoadData* aLoadData);
|
|
|
|
~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<StyleSheet>& 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(StyleSheet* aSheet) {
|
|
mReusableSheets.AppendElement(aSheet);
|
|
}
|
|
|
|
private:
|
|
LoaderReusableStyleSheets(const LoaderReusableStyleSheets&) = delete;
|
|
LoaderReusableStyleSheets& operator=(const LoaderReusableStyleSheets&) = delete;
|
|
|
|
// The sheets that can be reused.
|
|
nsTArray<RefPtr<StyleSheet>> 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:
|
|
typedef nsIStyleSheetLinkingElement::Completed Completed;
|
|
typedef nsIStyleSheetLinkingElement::HasAlternateRel HasAlternateRel;
|
|
typedef nsIStyleSheetLinkingElement::IsAlternate IsAlternate;
|
|
typedef nsIStyleSheetLinkingElement::IsInline IsInline;
|
|
typedef nsIStyleSheetLinkingElement::MediaMatched MediaMatched;
|
|
typedef nsIStyleSheetLinkingElement::Update LoadSheetResult;
|
|
typedef nsIStyleSheetLinkingElement::SheetInfo SheetInfo;
|
|
|
|
Loader();
|
|
// aDocGroup is used for dispatching SheetLoadData in PostLoadEvent(). It
|
|
// can be null if you want to use this constructor, and there's no
|
|
// document when the Loader is constructed.
|
|
explicit Loader(mozilla::dom::DocGroup*);
|
|
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; }
|
|
|
|
// TODO(emilio): Is the complexity of this method and carrying the titles
|
|
// around worth it? The alternate sheets will load anyhow eventually...
|
|
void DocumentStyleSheetSetChanged();
|
|
|
|
// 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
|
|
* result.WillNotify() is true, then aObserver is guaranteed to be notified
|
|
* asynchronously once the sheet is marked complete. If an error is
|
|
* returned, or if result.WillNotify() is false, 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 aObserver the observer to notify when the load completes.
|
|
* May be null.
|
|
* @param aBuffer the stylesheet data
|
|
* @param aLineNumber the line number at which the stylesheet data started.
|
|
*/
|
|
Result<LoadSheetResult, nsresult>
|
|
LoadInlineStyle(const SheetInfo&,
|
|
const nsAString& aBuffer,
|
|
uint32_t aLineNumber,
|
|
nsICSSLoaderObserver* aObserver);
|
|
|
|
/**
|
|
* 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, i.e., result.WillNotify() will always return
|
|
* true. 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 aObserver the observer to notify when the load completes.
|
|
* May be null.
|
|
*/
|
|
Result<LoadSheetResult, nsresult>
|
|
LoadStyleLink(const SheetInfo&, nsICSSLoaderObserver* aObserver);
|
|
|
|
/**
|
|
* 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 aParentData the SheetLoadData corresponding to the load of the
|
|
* parent sheet.
|
|
* @param aURL the URL of the child sheet
|
|
* @param aMedia the already-parsed media list for the child sheet
|
|
* @param aSavedSheets any saved style sheets which could be reused
|
|
* for this load
|
|
*/
|
|
nsresult LoadChildSheet(StyleSheet* aParentSheet,
|
|
SheetLoadData* aParentData,
|
|
nsIURI* aURL,
|
|
dom::MediaList* aMedia,
|
|
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.
|
|
*
|
|
* @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 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.
|
|
*
|
|
* 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.
|
|
*/
|
|
nsresult LoadSheet(nsIURI* aURL,
|
|
SheetParsingMode aParsingMode,
|
|
bool aUseSystemPrincipal,
|
|
nsICSSLoaderObserver* aObserver,
|
|
RefPtr<StyleSheet>* 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 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,
|
|
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 Encoding* aPreloadEncoding,
|
|
nsICSSLoaderObserver* aObserver,
|
|
CORSMode aCORSMode = CORS_NONE,
|
|
ReferrerPolicy aReferrerPolicy = mozilla::net::RP_Unset,
|
|
const nsAString& aIntegrity = EmptyString());
|
|
|
|
/**
|
|
* Stop loading all sheets. All nsICSSLoaderObservers involved will be
|
|
* notified with NS_BINDING_ABORTED as the status, possibly synchronously.
|
|
*/
|
|
void Stop();
|
|
|
|
/**
|
|
* 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.
|
|
|
|
// IsAlternateSheet can change our currently selected style set if none is
|
|
// selected and aHasAlternateRel is false.
|
|
IsAlternate IsAlternateSheet(const nsAString& aTitle, bool aHasAlternateRel);
|
|
|
|
typedef nsTArray<RefPtr<SheetLoadData>> LoadDataArray;
|
|
|
|
// Measure our size.
|
|
size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
|
|
|
|
private:
|
|
friend class SheetLoadData;
|
|
friend class StreamLoader;
|
|
|
|
// Helpers to conditionally block onload if mDocument is non-null.
|
|
void BlockOnload();
|
|
void UnblockOnload(bool aFireSync);
|
|
|
|
// Helper to select the correct dispatch target for asynchronous events for
|
|
// this loader.
|
|
already_AddRefed<nsISerialEventTarget> DispatchTarget();
|
|
|
|
nsresult CheckContentPolicy(nsIPrincipal* aLoadingPrincipal,
|
|
nsIPrincipal* aTriggeringPrincipal,
|
|
nsIURI* aTargetURI,
|
|
nsINode* aRequestingNode,
|
|
bool aIsPreload);
|
|
|
|
nsresult CreateSheet(const SheetInfo& aInfo,
|
|
nsIPrincipal* aLoaderPrincipal,
|
|
css::SheetParsingMode aParsingMode,
|
|
bool aSyncLoad,
|
|
StyleSheetState& aSheetState,
|
|
RefPtr<StyleSheet>* aSheet)
|
|
{
|
|
return CreateSheet(aInfo.mURI,
|
|
aInfo.mContent,
|
|
aLoaderPrincipal,
|
|
aParsingMode,
|
|
aInfo.mCORSMode,
|
|
aInfo.mReferrerPolicy,
|
|
aInfo.mIntegrity,
|
|
aSyncLoad,
|
|
aSheetState,
|
|
aSheet);
|
|
}
|
|
|
|
// 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.
|
|
nsresult CreateSheet(nsIURI* aURI,
|
|
nsIContent* aLinkingContent,
|
|
nsIPrincipal* aLoaderPrincipal,
|
|
css::SheetParsingMode aParsingMode,
|
|
CORSMode aCORSMode,
|
|
ReferrerPolicy aReferrerPolicy,
|
|
const nsAString& aIntegrity,
|
|
bool aSyncLoad,
|
|
StyleSheetState& aSheetState,
|
|
RefPtr<StyleSheet>* aSheet);
|
|
|
|
// Pass in either a media string or the MediaList from the CSSParser. Don't
|
|
// pass both.
|
|
//
|
|
// This method will set the sheet's enabled state based on aIsAlternate
|
|
MediaMatched PrepareSheet(StyleSheet* aSheet,
|
|
const nsAString& aTitle,
|
|
const nsAString& aMediaString,
|
|
dom::MediaList* aMediaList,
|
|
IsAlternate);
|
|
|
|
// Inserts a style sheet in a document or a ShadowRoot.
|
|
void InsertSheetInTree(StyleSheet& aSheet, nsIContent* aLinkingContent);
|
|
// Inserts a style sheet into a parent style sheet.
|
|
void InsertChildSheet(StyleSheet& aSheet, StyleSheet& aParentSheet);
|
|
|
|
nsresult InternalLoadNonDocumentSheet(
|
|
nsIURI* aURL,
|
|
bool aIsPreload,
|
|
SheetParsingMode aParsingMode,
|
|
bool aUseSystemPrincipal,
|
|
nsIPrincipal* aOriginPrincipal,
|
|
const Encoding* aPreloadEncoding,
|
|
RefPtr<StyleSheet>* aSheet,
|
|
nsICSSLoaderObserver* aObserver,
|
|
CORSMode aCORSMode = CORS_NONE,
|
|
ReferrerPolicy aReferrerPolicy = mozilla::net::RP_Unset,
|
|
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,
|
|
IsAlternate aWasAlternate,
|
|
MediaMatched aMediaMatched,
|
|
nsIStyleSheetLinkingElement* aElement);
|
|
|
|
// Start the loads of all the sheets in mPendingDatas
|
|
void StartDeferredLoads();
|
|
|
|
// 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);
|
|
|
|
enum class AllowAsyncParse
|
|
{
|
|
Yes,
|
|
No,
|
|
};
|
|
|
|
// Parse the stylesheet in the load data.
|
|
//
|
|
// Returns whether the parse finished. It may not finish e.g. if the sheet had
|
|
// an @import.
|
|
//
|
|
// If this function returns Completed::Yes, then ParseSheet also called
|
|
// SheetComplete on aLoadData.
|
|
Completed ParseSheet(const nsACString& aBytes, SheetLoadData*, AllowAsyncParse);
|
|
|
|
// 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, LoadDataArray& aDatasToNotify);
|
|
|
|
// Mark the given SheetLoadData, as well as any of its siblings, parents, etc
|
|
// transitively, as failed. The idea is to mark as failed any load that was
|
|
// directly or indirectly @importing the sheet this SheetLoadData represents.
|
|
void MarkLoadTreeFailed(SheetLoadData* aLoadData);
|
|
|
|
// If there's Referrer-Policy reponse header, the loading data and key should
|
|
// be updated with the referer policy parsed from the header.
|
|
void UpdateLoadingData(URIPrincipalReferrerPolicyAndCORSModeHashKey* aOldKey,
|
|
SheetLoadData* aData);
|
|
|
|
struct Sheets {
|
|
nsBaseHashtable<URIPrincipalReferrerPolicyAndCORSModeHashKey,
|
|
RefPtr<StyleSheet>,
|
|
StyleSheet*> mCompleteSheets;
|
|
nsDataHashtable<URIPrincipalReferrerPolicyAndCORSModeHashKey, SheetLoadData*>
|
|
mLoadingDatas; // weak refs
|
|
nsDataHashtable<URIPrincipalReferrerPolicyAndCORSModeHashKey, SheetLoadData*>
|
|
mPendingDatas; // weak refs
|
|
};
|
|
UniquePtr<Sheets> mSheets;
|
|
|
|
// 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
|
|
|
|
// For dispatching events via DocGroup::Dispatch() when mDocument is nullptr.
|
|
RefPtr<mozilla::dom::DocGroup> mDocGroup;
|
|
|
|
// 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;
|
|
|
|
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 */
|