--- a/dom/base/nsDocument.cpp
+++ b/dom/base/nsDocument.cpp
@@ -4205,16 +4205,17 @@ nsDocument::LoadAdditionalStyleSheet(add
// Checking if we have loaded this one already.
if (FindSheet(mAdditionalSheets[aType], aSheetURI) >= 0)
return NS_ERROR_INVALID_ARG;
// Loading the sheet sync.
RefPtr<css::Loader> loader = new css::Loader(GetStyleBackendType());
+ SheetType sheetType = ConvertAdditionalSheetType(aType);
css::SheetParsingMode parsingMode;
switch (aType) {
case nsIDocument::eAgentSheet:
parsingMode = css::eAgentSheetFeatures;
break;
case nsIDocument::eUserSheet:
parsingMode = css::eUserSheetFeatures;
@@ -4224,17 +4225,18 @@ nsDocument::LoadAdditionalStyleSheet(add
parsingMode = css::eAuthorSheetFeatures;
break;
default:
MOZ_CRASH("impossible value for aType");
}
RefPtr<StyleSheet> sheet;
- nsresult rv = loader->LoadSheetSync(aSheetURI, parsingMode, true, &sheet);
+ nsresult rv = loader->LoadSheetSync(aSheetURI, sheetType, parsingMode, true,
+ &sheet);
NS_ENSURE_SUCCESS(rv, rv);
sheet->SetOwningDocument(this);
MOZ_ASSERT(sheet->IsApplicable());
return AddAdditionalStyleSheet(aType, sheet);
}
@@ -9437,17 +9439,18 @@ nsDocument::PreloadStyle(nsIURI* uri, co
nsresult
nsDocument::LoadChromeSheetSync(nsIURI* uri, bool isAgentSheet,
RefPtr<mozilla::StyleSheet>* aSheet)
{
css::SheetParsingMode mode =
isAgentSheet ? css::eAgentSheetFeatures
: css::eAuthorSheetFeatures;
- return CSSLoader()->LoadSheetSync(uri, mode, isAgentSheet, aSheet);
+ return CSSLoader()->LoadSheetSync(uri, SheetType::Doc, mode, isAgentSheet,
+ aSheet);
}
class nsDelayedEventDispatcher : public Runnable
{
public:
explicit nsDelayedEventDispatcher(nsTArray<nsCOMPtr<nsIDocument>>& aDocuments)
{
mDocuments.SwapElements(aDocuments);
--- a/dom/base/nsIDocument.h
+++ b/dom/base/nsIDocument.h
@@ -2303,16 +2303,20 @@ public:
/**
* Called by the chrome registry to load style sheets. Can be put
* back there if and when when that module is merged with libgklayout.
*
* This always does a synchronous load. If aIsAgentSheet is true,
* it also uses the system principal and enables unsafe rules.
* DO NOT USE FOR UNTRUSTED CONTENT.
+ *
+ * Regardless of the value of aIsAgentSheet, this creates a sheet whose type
+ * is SheetType::Doc. aIsAgentSheet is only used to determine the
+ * SheetParsingMode.
*/
virtual nsresult LoadChromeSheetSync(nsIURI* aURI, bool aIsAgentSheet,
RefPtr<mozilla::StyleSheet>* aSheet) = 0;
/**
* Returns true if the locale used for the document specifies a direction of
* right to left. For chrome documents, this comes from the chrome registry.
* This is used to determine the current state for the :-moz-locale-dir pseudoclass
--- a/dom/base/nsTreeSanitizer.cpp
+++ b/dom/base/nsTreeSanitizer.cpp
@@ -1081,17 +1081,17 @@ nsTreeSanitizer::SanitizeStyleSheet(cons
{
nsresult rv;
aSanitized.Truncate();
// aSanitized will hold the permitted CSS text.
// -moz-binding is blacklisted.
bool didSanitize = false;
// Create a sheet to hold the parsed CSS
RefPtr<CSSStyleSheet> sheet =
- new CSSStyleSheet(mozilla::css::eAuthorSheetFeatures,
+ new CSSStyleSheet(SheetType::Doc, mozilla::css::eAuthorSheetFeatures,
CORS_NONE, aDocument->GetReferrerPolicy());
sheet->SetURIs(aDocument->GetDocumentURI(), nullptr, aBaseURI);
sheet->SetPrincipal(aDocument->NodePrincipal());
// Create the CSS parser, and parse the CSS text.
nsCSSParser parser(nullptr, sheet);
rv = parser.ParseSheet(aOriginal, aDocument->GetDocumentURI(), aBaseURI,
aDocument->NodePrincipal(), 0);
NS_ENSURE_SUCCESS(rv, true);
--- a/dom/svg/SVGDocument.cpp
+++ b/dom/svg/SVGDocument.cpp
@@ -120,16 +120,17 @@ SVGDocument::EnsureNonSVGUserAgentStyleS
mozilla::css::Loader* cssLoader = CSSLoader();
if (cssLoader->GetEnabled()) {
nsCOMPtr<nsIURI> uri;
NS_NewURI(getter_AddRefs(uri), spec);
if (uri) {
RefPtr<StyleSheet> sheet;
cssLoader->LoadSheetSync(uri,
+ SheetType::Agent,
mozilla::css::eAgentSheetFeatures,
true, &sheet);
if (sheet) {
EnsureOnDemandBuiltInUASheet(sheet);
}
}
}
}
--- a/editor/libeditor/HTMLEditor.cpp
+++ b/editor/libeditor/HTMLEditor.cpp
@@ -2898,18 +2898,18 @@ HTMLEditor::AddOverrideStyleSheet(const
NS_ENSURE_SUCCESS(rv, rv);
// We MUST ONLY load synchronous local files (no @import)
// XXXbz Except this will actually try to load remote files
// synchronously, of course..
RefPtr<StyleSheet> sheet;
// Editor override style sheets may want to style Gecko anonymous boxes
rv = ps->GetDocument()->CSSLoader()->
- LoadSheetSync(uaURI, mozilla::css::eAgentSheetFeatures, true,
- &sheet);
+ LoadSheetSync(uaURI, SheetType::Override, mozilla::css::eAgentSheetFeatures,
+ true, &sheet);
// Synchronous loads should ALWAYS return completed
NS_ENSURE_TRUE(sheet, NS_ERROR_NULL_POINTER);
// Add the override style sheet
// (This checks if already exists)
ps->AddOverrideStyleSheet(sheet);
--- a/layout/base/nsStyleSheetService.cpp
+++ b/layout/base/nsStyleSheetService.cpp
@@ -203,47 +203,63 @@ nsStyleSheetService::LoadAndRegisterShee
for (uint32_t i = 0; i < children.Length(); i++) {
Unused << children[i]->SendLoadAndRegisterSheet(uri, aSheetType);
}
}
}
return rv;
}
-nsresult
-nsStyleSheetService::LoadAndRegisterSheetInternal(nsIURI *aSheetURI,
- uint32_t aSheetType)
+/* static */ nsresult
+nsStyleSheetService::ConvertSheetType(uint32_t aSheetServiceSheetType,
+ SheetType* aSheetType,
+ css::SheetParsingMode* aParsingMode)
{
- NS_ENSURE_ARG_POINTER(aSheetURI);
-
- css::SheetParsingMode parsingMode;
- switch (aSheetType) {
+ switch (aSheetServiceSheetType) {
case AGENT_SHEET:
- parsingMode = css::eAgentSheetFeatures;
+ *aSheetType = SheetType::Agent;
+ *aParsingMode = css::eAgentSheetFeatures;
break;
case USER_SHEET:
- parsingMode = css::eUserSheetFeatures;
+ *aSheetType = SheetType::User;
+ *aParsingMode = css::eUserSheetFeatures;
break;
case AUTHOR_SHEET:
- parsingMode = css::eAuthorSheetFeatures;
+ *aSheetType = SheetType::Doc;
+ *aParsingMode = css::eAuthorSheetFeatures;
break;
default:
NS_WARNING("invalid sheet type argument");
return NS_ERROR_INVALID_ARG;
}
+ return NS_OK;
+}
+
+nsresult
+nsStyleSheetService::LoadAndRegisterSheetInternal(nsIURI *aSheetURI,
+ uint32_t aSheetType)
+{
+ NS_ENSURE_ARG_POINTER(aSheetURI);
+
+ SheetType sheetType;
+ css::SheetParsingMode parsingMode;
+
+ nsresult rv = ConvertSheetType(aSheetType, &sheetType, &parsingMode);
+ NS_ENSURE_SUCCESS(rv, rv);
+
// XXXheycam We'll need to load and register both a Gecko- and Servo-backed
// style sheet.
RefPtr<css::Loader> loader = new css::Loader(StyleBackendType::Gecko);
RefPtr<StyleSheet> sheet;
- nsresult rv = loader->LoadSheetSync(aSheetURI, parsingMode, true, &sheet);
+ rv = loader->LoadSheetSync(aSheetURI, sheetType, parsingMode, true, &sheet);
NS_ENSURE_SUCCESS(rv, rv);
mSheets[aSheetType].AppendElement(sheet);
return rv;
}
NS_IMETHODIMP
@@ -262,42 +278,30 @@ nsStyleSheetService::SheetRegistered(nsI
}
NS_IMETHODIMP
nsStyleSheetService::PreloadSheet(nsIURI *aSheetURI, uint32_t aSheetType,
nsIDOMStyleSheet **aSheet)
{
NS_PRECONDITION(aSheet, "Null out param");
NS_ENSURE_ARG_POINTER(aSheetURI);
- css::SheetParsingMode parsingMode;
- switch (aSheetType) {
- case AGENT_SHEET:
- parsingMode = css::eAgentSheetFeatures;
- break;
- case USER_SHEET:
- parsingMode = css::eUserSheetFeatures;
- break;
+ SheetType sheetType;
+ css::SheetParsingMode parsingMode;
- case AUTHOR_SHEET:
- parsingMode = css::eAuthorSheetFeatures;
- break;
-
- default:
- NS_WARNING("invalid sheet type argument");
- return NS_ERROR_INVALID_ARG;
- }
+ nsresult rv = ConvertSheetType(aSheetType, &sheetType, &parsingMode);
+ NS_ENSURE_SUCCESS(rv, rv);
// XXXheycam PreloadSheet can't support ServoStyleSheets until they implement
// nsIDOMStyleSheet.
RefPtr<css::Loader> loader = new css::Loader(StyleBackendType::Gecko);
RefPtr<StyleSheet> sheet;
- nsresult rv = loader->LoadSheetSync(aSheetURI, parsingMode, true, &sheet);
+ rv = loader->LoadSheetSync(aSheetURI, sheetType, parsingMode, true, &sheet);
NS_ENSURE_SUCCESS(rv, rv);
MOZ_ASSERT(sheet->IsGecko(),
"stylo: didn't expect Loader to create a ServoStyleSheet");
RefPtr<CSSStyleSheet> cssSheet = sheet->AsGecko();
cssSheet.forget(aSheet);
--- a/layout/base/nsStyleSheetService.h
+++ b/layout/base/nsStyleSheetService.h
@@ -70,12 +70,16 @@ class nsStyleSheetService final
int32_t FindSheetByURI(const nsTArray<RefPtr<mozilla::StyleSheet>>& aSheets,
nsIURI* aSheetURI);
// Like LoadAndRegisterSheet, but doesn't notify. If successful, the
// new sheet will be the last sheet in mSheets[aSheetType].
nsresult LoadAndRegisterSheetInternal(nsIURI *aSheetURI,
uint32_t aSheetType);
+ static nsresult ConvertSheetType(uint32_t aSheetServiceSheetType,
+ mozilla::SheetType* aSheetType,
+ mozilla::css::SheetParsingMode* aParsingMode);
+
nsTArray<RefPtr<mozilla::StyleSheet>> mSheets[3];
};
#endif
--- a/layout/style/CSSStyleSheet.cpp
+++ b/layout/style/CSSStyleSheet.cpp
@@ -1075,35 +1075,37 @@ CSSStyleSheetInner::SizeOfIncludingThis(
return n;
}
// -------------------------------
// CSS Style Sheet
//
-CSSStyleSheet::CSSStyleSheet(css::SheetParsingMode aParsingMode,
+CSSStyleSheet::CSSStyleSheet(SheetType aSheetType,
+ css::SheetParsingMode aParsingMode,
CORSMode aCORSMode, ReferrerPolicy aReferrerPolicy)
- : StyleSheet(StyleBackendType::Gecko, aParsingMode),
+ : StyleSheet(StyleBackendType::Gecko, aSheetType, aParsingMode),
mParent(nullptr),
mOwnerRule(nullptr),
mDirty(false),
mInRuleProcessorCache(false),
mScopeElement(nullptr),
mRuleProcessors(nullptr)
{
mInner = new CSSStyleSheetInner(this, aCORSMode, aReferrerPolicy,
SRIMetadata());
}
-CSSStyleSheet::CSSStyleSheet(css::SheetParsingMode aParsingMode,
+CSSStyleSheet::CSSStyleSheet(SheetType aSheetType,
+ css::SheetParsingMode aParsingMode,
CORSMode aCORSMode,
ReferrerPolicy aReferrerPolicy,
const SRIMetadata& aIntegrity)
- : StyleSheet(StyleBackendType::Gecko, aParsingMode),
+ : StyleSheet(StyleBackendType::Gecko, aSheetType, aParsingMode),
mParent(nullptr),
mOwnerRule(nullptr),
mDirty(false),
mInRuleProcessorCache(false),
mScopeElement(nullptr),
mRuleProcessors(nullptr)
{
mInner = new CSSStyleSheetInner(this, aCORSMode, aReferrerPolicy,
--- a/layout/style/CSSStyleSheet.h
+++ b/layout/style/CSSStyleSheet.h
@@ -98,19 +98,21 @@ struct CSSStyleSheetInner : public Style
{ 0x98, 0x99, 0x0c, 0x86, 0xec, 0x12, 0x2f, 0x54 } }
class CSSStyleSheet final : public StyleSheet
, public nsICSSLoaderObserver
{
public:
typedef net::ReferrerPolicy ReferrerPolicy;
- CSSStyleSheet(css::SheetParsingMode aParsingMode,
+ CSSStyleSheet(SheetType aSheetType,
+ css::SheetParsingMode aParsingMode,
CORSMode aCORSMode, ReferrerPolicy aReferrerPolicy);
- CSSStyleSheet(css::SheetParsingMode aParsingMode,
+ CSSStyleSheet(SheetType aSheetType,
+ css::SheetParsingMode aParsingMode,
CORSMode aCORSMode, ReferrerPolicy aReferrerPolicy,
const dom::SRIMetadata& aIntegrity);
NS_DECL_ISUPPORTS_INHERITED
NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(CSSStyleSheet, StyleSheet)
NS_DECLARE_STATIC_IID_ACCESSOR(NS_CSS_STYLE_SHEET_IMPL_CID)
--- a/layout/style/Loader.cpp
+++ b/layout/style/Loader.cpp
@@ -1067,16 +1067,17 @@ Loader::CheckContentPolicy(nsIPrincipal*
* sheets will have the title/media/enabled state of the sheet they
* are clones off; make sure to call PrepareSheet() on the result of
* CreateSheet().
*/
nsresult
Loader::CreateSheet(nsIURI* aURI,
nsIContent* aLinkingContent,
nsIPrincipal* aLoaderPrincipal,
+ SheetType aSheetType,
css::SheetParsingMode aParsingMode,
CORSMode aCORSMode,
ReferrerPolicy aReferrerPolicy,
const nsAString& aIntegrity,
bool aSyncLoad,
bool aHasAlternateRel,
const nsAString& aTitle,
StyleSheetState& aSheetState,
@@ -1247,19 +1248,21 @@ Loader::CreateSheet(nsIURI* aURI,
if (mDocument && mDocument->GetDocumentURI()) {
mDocument->GetDocumentURI()->GetAsciiSpec(sourceUri);
}
SRICheck::IntegrityMetadata(aIntegrity, sourceUri, mReporter,
&sriMetadata);
}
if (GetStyleBackendType() == StyleBackendType::Gecko) {
- *aSheet = new CSSStyleSheet(aParsingMode, aCORSMode, aReferrerPolicy, sriMetadata);
+ *aSheet = new CSSStyleSheet(aSheetType, aParsingMode, aCORSMode,
+ aReferrerPolicy, sriMetadata);
} else {
- *aSheet = new ServoStyleSheet(aParsingMode, aCORSMode, aReferrerPolicy, sriMetadata);
+ *aSheet = new ServoStyleSheet(aSheetType, aParsingMode, aCORSMode,
+ aReferrerPolicy, sriMetadata);
}
(*aSheet)->SetURIs(sheetURI, originalURI, baseURI);
}
NS_ASSERTION(*aSheet, "We should have a sheet by now!");
NS_ASSERTION(aSheetState != eSheetStateUnknown, "Have to set a state!");
LOG((" State: %s", gStateStrings[aSheetState]));
@@ -2005,17 +2008,18 @@ Loader::LoadInlineStyle(nsIContent* aEle
nsCOMPtr<nsIStyleSheetLinkingElement> owningElement(do_QueryInterface(aElement));
NS_ASSERTION(owningElement, "Element is not a style linking element!");
// Since we're not planning to load a URI, no need to hand a principal to the
// load data or to CreateSheet(). Also, OK to use CORS_NONE for the CORS
// mode and mDocument's ReferrerPolicy.
StyleSheetState state;
RefPtr<StyleSheet> sheet;
- nsresult rv = CreateSheet(nullptr, aElement, nullptr, eAuthorSheetFeatures,
+ nsresult rv = CreateSheet(nullptr, aElement, nullptr,
+ SheetType::Doc, eAuthorSheetFeatures,
CORS_NONE, mDocument->GetReferrerPolicy(),
EmptyString(), // no inline integrity checks
false, false, aTitle, state, aIsAlternate,
&sheet);
NS_ENSURE_SUCCESS(rv, rv);
NS_ASSERTION(state == eSheetNeedsParser,
"Inline sheets should not be cached");
@@ -2103,17 +2107,18 @@ Loader::LoadStyleLink(nsIContent* aEleme
false, false);
loadBlockingAsyncDispatcher->PostDOMEvent();
}
return rv;
}
StyleSheetState state;
RefPtr<StyleSheet> sheet;
- rv = CreateSheet(aURL, aElement, principal, eAuthorSheetFeatures,
+ rv = CreateSheet(aURL, aElement, principal,
+ SheetType::Doc, eAuthorSheetFeatures,
aCORSMode, aReferrerPolicy, aIntegrity, false,
aHasAlternateRel, aTitle, state, aIsAlternate,
&sheet);
NS_ENSURE_SUCCESS(rv, rv);
LOG((" Sheet is alternate: %d", *aIsAlternate));
PrepareSheet(sheet, aTitle, aMedia, nullptr, nullptr, *aIsAlternate);
@@ -2268,16 +2273,17 @@ Loader::LoadChildSheet(StyleSheet* aPare
sheet = reusableSheet;
aParentRule->SetSheet(reusableSheet);
state = eSheetComplete;
} else {
bool isAlternate;
const nsSubstring& empty = EmptyString();
// For now, use CORS_NONE for child sheets
rv = CreateSheet(aURL, nullptr, principal,
+ aParentSheet->GetSheetType(),
aParentSheet->ParsingMode(),
CORS_NONE, aParentSheet->GetReferrerPolicy(),
EmptyString(), // integrity is only checked on main sheet
parentData ? parentData->mSyncLoad : false,
false, empty, state, &isAlternate, &sheet);
NS_ENSURE_SUCCESS(rv, rv);
PrepareSheet(sheet, empty, empty, aMedia, nullptr, isAlternate);
@@ -2309,63 +2315,68 @@ Loader::LoadChildSheet(StyleSheet* aPare
if (!syncLoad) {
data->mMustNotify = true;
}
return rv;
}
nsresult
Loader::LoadSheetSync(nsIURI* aURL,
+ SheetType aSheetType,
SheetParsingMode aParsingMode,
bool aUseSystemPrincipal,
RefPtr<StyleSheet>* aSheet)
{
LOG(("css::Loader::LoadSheetSync"));
return InternalLoadNonDocumentSheet(aURL,
- false, aParsingMode, aUseSystemPrincipal,
+ false, aSheetType, aParsingMode,
+ aUseSystemPrincipal,
nullptr, EmptyCString(),
aSheet, nullptr);
}
nsresult
Loader::LoadSheet(nsIURI* aURL,
nsIPrincipal* aOriginPrincipal,
const nsCString& aCharset,
nsICSSLoaderObserver* aObserver,
RefPtr<StyleSheet>* aSheet)
{
LOG(("css::Loader::LoadSheet(aURL, aObserver, aSheet) api call"));
NS_PRECONDITION(aSheet, "aSheet is null");
return InternalLoadNonDocumentSheet(aURL,
- false, eAuthorSheetFeatures, false,
+ false, SheetType::Doc,
+ eAuthorSheetFeatures, false,
aOriginPrincipal, aCharset,
aSheet, aObserver);
}
nsresult
Loader::LoadSheet(nsIURI* aURL,
bool aIsPreload,
nsIPrincipal* aOriginPrincipal,
const nsCString& aCharset,
nsICSSLoaderObserver* aObserver,
CORSMode aCORSMode,
ReferrerPolicy aReferrerPolicy,
const nsAString& aIntegrity)
{
LOG(("css::Loader::LoadSheet(aURL, aObserver) api call"));
return InternalLoadNonDocumentSheet(aURL,
- aIsPreload, eAuthorSheetFeatures, false,
+ aIsPreload, SheetType::Doc,
+ eAuthorSheetFeatures, false,
aOriginPrincipal, aCharset,
nullptr, aObserver,
aCORSMode, aReferrerPolicy, aIntegrity);
}
nsresult
Loader::InternalLoadNonDocumentSheet(nsIURI* aURL,
bool aIsPreload,
+ SheetType aSheetType,
SheetParsingMode aParsingMode,
bool aUseSystemPrincipal,
nsIPrincipal* aOriginPrincipal,
const nsCString& aCharset,
RefPtr<StyleSheet>* aSheet,
nsICSSLoaderObserver* aObserver,
CORSMode aCORSMode,
ReferrerPolicy aReferrerPolicy,
@@ -2392,17 +2403,17 @@ Loader::InternalLoadNonDocumentSheet(nsI
NS_ENSURE_SUCCESS(rv, rv);
StyleSheetState state;
bool isAlternate;
RefPtr<StyleSheet> sheet;
bool syncLoad = (aObserver == nullptr);
const nsSubstring& empty = EmptyString();
- rv = CreateSheet(aURL, nullptr, aOriginPrincipal, aParsingMode,
+ rv = CreateSheet(aURL, nullptr, aOriginPrincipal, aSheetType, aParsingMode,
aCORSMode, aReferrerPolicy, aIntegrity, syncLoad,
false, empty, state, &isAlternate, &sheet);
NS_ENSURE_SUCCESS(rv, rv);
PrepareSheet(sheet, empty, empty, nullptr, nullptr, isAlternate);
if (state == eSheetComplete) {
LOG((" Sheet already complete"));
--- a/layout/style/Loader.h
+++ b/layout/style/Loader.h
@@ -314,26 +314,28 @@ public:
* 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,
+ SheetType aSheetType,
SheetParsingMode aParsingMode,
bool aUseSystemPrincipal,
RefPtr<StyleSheet>* aSheet);
/**
- * As above, but defaults aParsingMode to eAuthorSheetFeatures and
- * aUseSystemPrincipal to false.
+ * As above, but defaults aSheetType to SheetType::Doc, aParsingMode to
+ * eAuthorSheetFeatures and aUseSystemPrincipal to false.
*/
nsresult LoadSheetSync(nsIURI* aURL, RefPtr<StyleSheet>* aSheet) {
- return LoadSheetSync(aURL, eAuthorSheetFeatures, false, aSheet);
+ return LoadSheetSync(aURL, SheetType::Doc, 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.
@@ -452,16 +454,17 @@ private:
// 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,
+ SheetType aSheetType,
css::SheetParsingMode aParsingMode,
CORSMode aCORSMode,
ReferrerPolicy aReferrerPolicy,
const nsAString& aIntegrity,
bool aSyncLoad,
bool aHasAlternateRel,
const nsAString& aTitle,
StyleSheetState& aSheetState,
@@ -483,16 +486,17 @@ private:
nsIDocument* aDocument);
nsresult InsertChildSheet(StyleSheet* aSheet,
StyleSheet* aParentSheet,
ImportRule* aParentRule);
nsresult InternalLoadNonDocumentSheet(nsIURI* aURL,
bool aIsPreload,
+ SheetType aSheetType,
SheetParsingMode aParsingMode,
bool aUseSystemPrincipal,
nsIPrincipal* aOriginPrincipal,
const nsCString& aCharset,
RefPtr<StyleSheet>* aSheet,
nsICSSLoaderObserver* aObserver,
CORSMode aCORSMode = CORS_NONE,
ReferrerPolicy aReferrerPolicy = mozilla::net::RP_Default,
--- a/layout/style/ServoStyleSheet.cpp
+++ b/layout/style/ServoStyleSheet.cpp
@@ -13,21 +13,22 @@
#include "mozilla/dom/CSSRuleList.h"
#include "mozAutoDocUpdate.h"
using namespace mozilla::dom;
namespace mozilla {
-ServoStyleSheet::ServoStyleSheet(css::SheetParsingMode aParsingMode,
+ServoStyleSheet::ServoStyleSheet(SheetType aSheetType,
+ css::SheetParsingMode aParsingMode,
CORSMode aCORSMode,
net::ReferrerPolicy aReferrerPolicy,
const dom::SRIMetadata& aIntegrity)
- : StyleSheet(StyleBackendType::Servo, aParsingMode)
+ : StyleSheet(StyleBackendType::Servo, aSheetType, aParsingMode)
, mSheetInfo(aCORSMode, aReferrerPolicy, aIntegrity)
{
}
ServoStyleSheet::~ServoStyleSheet()
{
DropSheet();
if (mRuleList) {
--- a/layout/style/ServoStyleSheet.h
+++ b/layout/style/ServoStyleSheet.h
@@ -19,17 +19,18 @@ namespace mozilla {
class ServoCSSRuleList;
/**
* CSS style sheet object that is a wrapper for a Servo Stylesheet.
*/
class ServoStyleSheet : public StyleSheet
{
public:
- ServoStyleSheet(css::SheetParsingMode aParsingMode,
+ ServoStyleSheet(SheetType aSheetType,
+ css::SheetParsingMode aParsingMode,
CORSMode aCORSMode,
net::ReferrerPolicy aReferrerPolicy,
const dom::SRIMetadata& aIntegrity);
bool HasRules() const;
void SetOwningDocument(nsIDocument* aDocument);
--- a/layout/style/StyleSheet.cpp
+++ b/layout/style/StyleSheet.cpp
@@ -13,31 +13,41 @@
#include "mozilla/CSSStyleSheet.h"
#include "mozAutoDocUpdate.h"
#include "nsIMediaList.h"
#include "nsNullPrincipal.h"
namespace mozilla {
-StyleSheet::StyleSheet(StyleBackendType aType, css::SheetParsingMode aParsingMode)
+StyleSheet::StyleSheet(StyleBackendType aType,
+ SheetType aSheetType,
+ css::SheetParsingMode aParsingMode)
: mDocument(nullptr)
, mOwningNode(nullptr)
+ , mSheetType(aSheetType)
, mParsingMode(aParsingMode)
, mType(aType)
, mDisabled(false)
{
+ MOZ_ASSERT(mSheetType == SheetType::Agent ||
+ mSheetType == SheetType::User ||
+ mSheetType == SheetType::Doc ||
+ mSheetType == SheetType::Override,
+ "SheetType must only be a cascade level corresponding to a "
+ "CSS style sheet");
}
StyleSheet::StyleSheet(const StyleSheet& aCopy,
nsIDocument* aDocumentToUse,
nsINode* aOwningNodeToUse)
: mTitle(aCopy.mTitle)
, mDocument(aDocumentToUse)
, mOwningNode(aOwningNodeToUse)
+ , mSheetType(aCopy.mSheetType)
, mParsingMode(aCopy.mParsingMode)
, mType(aCopy.mType)
, mDisabled(aCopy.mDisabled)
{
}
// QueryInterface implementation for StyleSheet
NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(StyleSheet)
--- a/layout/style/StyleSheet.h
+++ b/layout/style/StyleSheet.h
@@ -5,16 +5,17 @@
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#ifndef mozilla_StyleSheet_h
#define mozilla_StyleSheet_h
#include "mozilla/css/SheetParsingMode.h"
#include "mozilla/dom/CSSStyleSheetBinding.h"
#include "mozilla/net/ReferrerPolicy.h"
+#include "mozilla/SheetType.h"
#include "mozilla/StyleBackendType.h"
#include "mozilla/CORSMode.h"
#include "mozilla/ServoUtils.h"
#include "nsIDOMCSSStyleSheet.h"
#include "nsWrapperCache.h"
class nsIDocument;
@@ -35,31 +36,35 @@ class SRIMetadata;
/**
* Superclass for data common to CSSStyleSheet and ServoStyleSheet.
*/
class StyleSheet : public nsIDOMCSSStyleSheet
, public nsWrapperCache
{
protected:
- StyleSheet(StyleBackendType aType, css::SheetParsingMode aParsingMode);
+ StyleSheet(StyleBackendType aType,
+ SheetType aSheetType,
+ css::SheetParsingMode aParsingMode);
StyleSheet(const StyleSheet& aCopy,
nsIDocument* aDocumentToUse,
nsINode* aOwningNodeToUse);
virtual ~StyleSheet() {}
public:
NS_DECL_CYCLE_COLLECTING_ISUPPORTS
NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS(StyleSheet)
void SetOwningNode(nsINode* aOwningNode)
{
mOwningNode = aOwningNode;
}
+ SheetType GetSheetType() const { return mSheetType; }
+
css::SheetParsingMode ParsingMode() { return mParsingMode; }
mozilla::dom::CSSStyleSheetParsingMode ParsingModeDOM();
// The document this style sheet is associated with. May be null
nsIDocument* GetDocument() const { return mDocument; }
/**
* Whether the sheet is complete.
@@ -191,16 +196,21 @@ protected:
// it will set the principal of the inner to the subject principal.
void SubjectSubsumesInnerPrincipal(nsIPrincipal& aSubjectPrincipal,
ErrorResult& aRv);
nsString mTitle;
nsIDocument* mDocument; // weak ref; parents maintain this for their children
nsINode* mOwningNode; // weak ref
+ // The intended CSS cascade level for this sheet. Adding this sheet to an
+ // nsStyleSet is not an error, but an ServoStyleSet will use mSheetType to
+ // determine the level to add the sheet at.
+ SheetType mSheetType;
+
// mParsingMode controls access to nonstandard style constructs that
// are not safe for use on the public Web but necessary in UA sheets
// and/or useful in user sheets.
css::SheetParsingMode mParsingMode;
const StyleBackendType mType;
bool mDisabled;
};
--- a/layout/style/nsLayoutStylesheetCache.cpp
+++ b/layout/style/nsLayoutStylesheetCache.cpp
@@ -70,44 +70,47 @@ nsLayoutStylesheetCache::Observe(nsISupp
}
StyleSheet*
nsLayoutStylesheetCache::ScrollbarsSheet()
{
if (!mScrollbarsSheet) {
// Scrollbars don't need access to unsafe rules
LoadSheetURL("chrome://global/skin/scrollbars.css",
- &mScrollbarsSheet, eAuthorSheetFeatures);
+ &mScrollbarsSheet,
+ SheetType::Agent, eAuthorSheetFeatures);
}
return mScrollbarsSheet;
}
StyleSheet*
nsLayoutStylesheetCache::FormsSheet()
{
if (!mFormsSheet) {
// forms.css needs access to unsafe rules
LoadSheetURL("resource://gre-resources/forms.css",
- &mFormsSheet, eAgentSheetFeatures);
+ &mFormsSheet,
+ SheetType::Agent, eAgentSheetFeatures);
}
return mFormsSheet;
}
StyleSheet*
nsLayoutStylesheetCache::NumberControlSheet()
{
if (!sNumberControlEnabled) {
return nullptr;
}
if (!mNumberControlSheet) {
LoadSheetURL("resource://gre-resources/number-control.css",
- &mNumberControlSheet, eAgentSheetFeatures);
+ &mNumberControlSheet,
+ SheetType::Agent, eAgentSheetFeatures);
}
return mNumberControlSheet;
}
StyleSheet*
nsLayoutStylesheetCache::UserContentSheet()
{
@@ -120,17 +123,18 @@ nsLayoutStylesheetCache::UserChromeSheet
return mUserChromeSheet;
}
StyleSheet*
nsLayoutStylesheetCache::UASheet()
{
if (!mUASheet) {
LoadSheetURL("resource://gre-resources/ua.css",
- &mUASheet, eAgentSheetFeatures);
+ &mUASheet,
+ SheetType::Agent, eAgentSheetFeatures);
}
return mUASheet;
}
StyleSheet*
nsLayoutStylesheetCache::HTMLSheet()
{
@@ -161,45 +165,48 @@ nsLayoutStylesheetCache::SVGSheet()
return mSVGSheet;
}
StyleSheet*
nsLayoutStylesheetCache::MathMLSheet()
{
if (!mMathMLSheet) {
LoadSheetURL("resource://gre-resources/mathml.css",
- &mMathMLSheet, eAgentSheetFeatures);
+ &mMathMLSheet,
+ SheetType::Agent, eAgentSheetFeatures);
}
return mMathMLSheet;
}
StyleSheet*
nsLayoutStylesheetCache::CounterStylesSheet()
{
return mCounterStylesSheet;
}
StyleSheet*
nsLayoutStylesheetCache::NoScriptSheet()
{
if (!mNoScriptSheet) {
LoadSheetURL("resource://gre-resources/noscript.css",
- &mNoScriptSheet, eAgentSheetFeatures);
+ &mNoScriptSheet,
+ SheetType::Agent, eAgentSheetFeatures);
}
return mNoScriptSheet;
}
StyleSheet*
nsLayoutStylesheetCache::NoFramesSheet()
{
if (!mNoFramesSheet) {
LoadSheetURL("resource://gre-resources/noframes.css",
- &mNoFramesSheet, eAgentSheetFeatures);
+ &mNoFramesSheet,
+ SheetType::Agent, eAgentSheetFeatures);
}
return mNoFramesSheet;
}
StyleSheet*
nsLayoutStylesheetCache::ChromePreferenceSheet(nsPresContext* aPresContext)
{
@@ -220,28 +227,30 @@ nsLayoutStylesheetCache::ContentPreferen
return mContentPreferenceSheet;
}
StyleSheet*
nsLayoutStylesheetCache::ContentEditableSheet()
{
if (!mContentEditableSheet) {
LoadSheetURL("resource://gre/res/contenteditable.css",
- &mContentEditableSheet, eAgentSheetFeatures);
+ &mContentEditableSheet,
+ SheetType::Agent, eAgentSheetFeatures);
}
return mContentEditableSheet;
}
StyleSheet*
nsLayoutStylesheetCache::DesignModeSheet()
{
if (!mDesignModeSheet) {
LoadSheetURL("resource://gre/res/designmode.css",
- &mDesignModeSheet, eAgentSheetFeatures);
+ &mDesignModeSheet,
+ SheetType::Agent, eAgentSheetFeatures);
}
return mDesignModeSheet;
}
void
nsLayoutStylesheetCache::Shutdown()
{
@@ -323,31 +332,38 @@ nsLayoutStylesheetCache::nsLayoutStylesh
obsSvc->AddObserver(this, "chrome-flush-caches", false);
}
InitFromProfile();
// And make sure that we load our UA sheets. No need to do this
// per-profile, since they're profile-invariant.
LoadSheetURL("resource://gre-resources/counterstyles.css",
- &mCounterStylesSheet, eAgentSheetFeatures);
+ &mCounterStylesSheet,
+ SheetType::Agent, eAgentSheetFeatures);
LoadSheetURL("resource://gre-resources/html.css",
- &mHTMLSheet, eAgentSheetFeatures);
+ &mHTMLSheet,
+ SheetType::Agent, eAgentSheetFeatures);
LoadSheetURL("chrome://global/content/minimal-xul.css",
- &mMinimalXULSheet, eAgentSheetFeatures);
+ &mMinimalXULSheet,
+ SheetType::Agent, eAgentSheetFeatures);
LoadSheetURL("resource://gre-resources/quirk.css",
- &mQuirkSheet, eAgentSheetFeatures);
+ &mQuirkSheet,
+ SheetType::Agent, eAgentSheetFeatures);
LoadSheetURL("resource://gre/res/svg.css",
- &mSVGSheet, eAgentSheetFeatures);
+ &mSVGSheet,
+ SheetType::Agent, eAgentSheetFeatures);
LoadSheetURL("chrome://global/content/xul.css",
- &mXULSheet, eAgentSheetFeatures);
+ &mXULSheet,
+ SheetType::Agent, eAgentSheetFeatures);
if (gUserContentSheetURL) {
MOZ_ASSERT(XRE_IsContentProcess(), "Only used in content processes.");
- LoadSheet(gUserContentSheetURL, &mUserContentSheet, eUserSheetFeatures);
+ LoadSheet(gUserContentSheetURL, &mUserContentSheet,
+ SheetType::User, eUserSheetFeatures);
gUserContentSheetURL = nullptr;
}
// The remaining sheets are created on-demand do to their use being rarer
// (which helps save memory for Firefox OS apps) or because they need to
// be re-loadable in DependentPrefChanged.
}
@@ -417,47 +433,51 @@ nsLayoutStylesheetCache::InitFromProfile
}
contentFile->Clone(getter_AddRefs(chromeFile));
if (!chromeFile) return;
contentFile->Append(NS_LITERAL_STRING("userContent.css"));
chromeFile->Append(NS_LITERAL_STRING("userChrome.css"));
- LoadSheetFile(contentFile, &mUserContentSheet, eUserSheetFeatures);
- LoadSheetFile(chromeFile, &mUserChromeSheet, eUserSheetFeatures);
+ LoadSheetFile(contentFile, &mUserContentSheet,
+ SheetType::User, eUserSheetFeatures);
+ LoadSheetFile(chromeFile, &mUserChromeSheet,
+ SheetType::User, eUserSheetFeatures);
}
void
nsLayoutStylesheetCache::LoadSheetURL(const char* aURL,
RefPtr<StyleSheet>* aSheet,
+ SheetType aSheetType,
SheetParsingMode aParsingMode)
{
nsCOMPtr<nsIURI> uri;
NS_NewURI(getter_AddRefs(uri), aURL);
- LoadSheet(uri, aSheet, aParsingMode);
+ LoadSheet(uri, aSheet, aSheetType, aParsingMode);
if (!aSheet) {
NS_ERROR(nsPrintfCString("Could not load %s", aURL).get());
}
}
void
nsLayoutStylesheetCache::LoadSheetFile(nsIFile* aFile,
RefPtr<StyleSheet>* aSheet,
+ SheetType aSheetType,
SheetParsingMode aParsingMode)
{
bool exists = false;
aFile->Exists(&exists);
if (!exists) return;
nsCOMPtr<nsIURI> uri;
NS_NewFileURI(getter_AddRefs(uri), aFile);
- LoadSheet(uri, aSheet, aParsingMode);
+ LoadSheet(uri, aSheet, aSheetType, aParsingMode);
}
#ifdef MOZ_CRASHREPORTER
static inline nsresult
ComputeCRC32(nsIFile* aFile, uint32_t* aResult)
{
PRFileDesc* fd;
nsresult rv = aFile->OpenNSPRFileDesc(PR_RDONLY, 0, &fd);
@@ -739,16 +759,17 @@ ErrorLoadingBuiltinSheet(nsIURI* aURI, c
NS_RUNTIMEABORT(
nsPrintfCString("%s loading built-in stylesheet '%s'",
aMsg, aURI ? aURI->GetSpecOrDefault().get() : "").get());
}
void
nsLayoutStylesheetCache::LoadSheet(nsIURI* aURI,
RefPtr<StyleSheet>* aSheet,
+ SheetType aSheetType,
SheetParsingMode aParsingMode)
{
if (!aURI) {
ErrorLoadingBuiltinSheet(aURI, "null URI");
return;
}
auto& loader = mBackendType == StyleBackendType::Gecko ?
@@ -761,17 +782,18 @@ nsLayoutStylesheetCache::LoadSheet(nsIUR
ErrorLoadingBuiltinSheet(aURI, "no Loader");
return;
}
}
#ifdef MOZ_CRASHREPORTER
nsZipArchive::sFileCorruptedReason = nullptr;
#endif
- nsresult rv = loader->LoadSheetSync(aURI, aParsingMode, true, aSheet);
+ nsresult rv = loader->LoadSheetSync(aURI, aSheetType, aParsingMode, true,
+ aSheet);
if (NS_FAILED(rv)) {
ErrorLoadingBuiltinSheet(aURI,
nsPrintfCString("LoadSheetSync failed with error %x", rv).get());
}
}
/* static */ void
nsLayoutStylesheetCache::InvalidateSheet(RefPtr<StyleSheet>* aGeckoSheet,
@@ -847,21 +869,22 @@ nsLayoutStylesheetCache::InvalidatePrefe
}
}
void
nsLayoutStylesheetCache::BuildPreferenceSheet(RefPtr<StyleSheet>* aSheet,
nsPresContext* aPresContext)
{
if (mBackendType == StyleBackendType::Gecko) {
- *aSheet = new CSSStyleSheet(eAgentSheetFeatures, CORS_NONE,
+ *aSheet = new CSSStyleSheet(SheetType::User, eAgentSheetFeatures, CORS_NONE,
mozilla::net::RP_Default);
} else {
- *aSheet = new ServoStyleSheet(eAgentSheetFeatures, CORS_NONE,
- mozilla::net::RP_Default, dom::SRIMetadata());
+ *aSheet = new ServoStyleSheet(SheetType::User, eAgentSheetFeatures,
+ CORS_NONE, mozilla::net::RP_Default,
+ dom::SRIMetadata());
}
StyleSheet* sheet = *aSheet;
nsCOMPtr<nsIURI> uri;
NS_NewURI(getter_AddRefs(uri), "about:PreferenceStyleSheet", nullptr);
MOZ_ASSERT(uri, "URI creation shouldn't fail");
--- a/layout/style/nsLayoutStylesheetCache.h
+++ b/layout/style/nsLayoutStylesheetCache.h
@@ -73,21 +73,24 @@ class nsLayoutStylesheetCache final
private:
explicit nsLayoutStylesheetCache(mozilla::StyleBackendType aImpl);
~nsLayoutStylesheetCache();
void InitFromProfile();
void InitMemoryReporter();
void LoadSheetURL(const char* aURL,
RefPtr<mozilla::StyleSheet>* aSheet,
+ mozilla::SheetType aSheetType,
mozilla::css::SheetParsingMode aParsingMode);
void LoadSheetFile(nsIFile* aFile,
RefPtr<mozilla::StyleSheet>* aSheet,
+ mozilla::SheetType aSheetType,
mozilla::css::SheetParsingMode aParsingMode);
void LoadSheet(nsIURI* aURI, RefPtr<mozilla::StyleSheet>* aSheet,
+ mozilla::SheetType aSheetType,
mozilla::css::SheetParsingMode aParsingMode);
static void InvalidateSheet(RefPtr<mozilla::StyleSheet>* aGeckoSheet,
RefPtr<mozilla::StyleSheet>* aServoSheet);
static void DependentPrefChanged(const char* aPref, void* aData);
void BuildPreferenceSheet(RefPtr<mozilla::StyleSheet>* aSheet,
nsPresContext* aPresContext);
static mozilla::StaticRefPtr<nsLayoutStylesheetCache> gStyleCache_Gecko;