Magic-Mirror/gecko-dev
1
0
Fork 0
mirror of https://github.com/mozilla/gecko-dev.git synced 2025-04-02 20:42:49 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Bug 1459498: Refactor nsStyleLinkElement so that all the stylesheet information comes from one place. r=heycam

Browse Source 
I've kept the nsAutoStrings in the StyleSheetInfo class on the hopes that the
compiler does RVO, but if it doesn't I can remove I guess.

MozReview-Commit-ID: 2vN6BSEhYcw
This commit is contained in:
Emilio Cobos Álvarez 2018-05-06 13:20:03 +02:00
parent e966f910ac
commit 5b6f2bdee0
12 changed files with 243 additions and 246 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

103
dom/base/nsStyleLinkElement.cpp
View File

@ -35,6 +35,43 @@
using namespace mozilla;
using namespace mozilla::dom;
nsStyleLinkElement::StyleSheetInfo::StyleSheetInfo(
const nsIDocument& aDocument,
const nsIContent* aContent,
already_AddRefed<nsIURI> aURI,
already_AddRefed<nsIPrincipal> aTriggeringPrincipal,
mozilla::net::ReferrerPolicy aReferrerPolicy,
mozilla::CORSMode aCORSMode,
const nsAString& aTitle,
const nsAString& aMedia,
IsAlternate aHasAlternateRel,
IsInline aIsInline
)
: mURI(aURI)
, mTriggeringPrincipal(aTriggeringPrincipal)
, mReferrerPolicy(aReferrerPolicy)
, mCORSMode(aCORSMode)
, mTitle(aTitle)
, mMedia(aMedia)
, mHasAlternateRel(aHasAlternateRel == IsAlternate::Yes)
, mIsInline(aIsInline == IsInline::Yes)
{
MOZ_ASSERT(!mIsInline || aContent);
MOZ_ASSERT_IF(aContent, aContent->OwnerDoc() == &aDocument);
if (mReferrerPolicy == net::ReferrerPolicy::RP_Unset) {
mReferrerPolicy = aDocument.GetReferrerPolicy();
}
if (!mIsInline && aContent && aContent->IsElement()) {
aContent->AsElement()->GetAttr(kNameSpaceID_None,
nsGkAtoms::integrity,
mIntegrity);
}
}
nsStyleLinkElement::StyleSheetInfo::~StyleSheetInfo() = default;
nsStyleLinkElement::nsStyleLinkElement()
: mDontLoadStyle(false)
, mUpdatesEnabled(true)
@ -261,14 +298,15 @@ nsStyleLinkElement::DoUpdateStyleSheet(nsIDocument* aOldDocument,
return Update { };
}
bool isInline;
nsCOMPtr<nsIPrincipal> triggeringPrincipal;
nsCOMPtr<nsIURI> uri = GetStyleSheetURL(&isInline, getter_AddRefs(triggeringPrincipal));
if (aForceUpdate == ForceUpdate::No && mStyleSheet && !isInline && uri) {
auto info = GetStyleSheetInfo();
if (aForceUpdate == ForceUpdate::No &&
mStyleSheet &&
info &&
!info->mIsInline &&
info->mURI) {
if (nsIURI* oldURI = mStyleSheet->GetSheetURI()) {
bool equal;
nsresult rv = oldURI->Equals(uri, &equal);
nsresult rv = oldURI->Equals(info->mURI, &equal);
if (NS_SUCCEEDED(rv) && equal) {
return Update { };
}
@ -288,28 +326,18 @@ nsStyleLinkElement::DoUpdateStyleSheet(nsIDocument* aOldDocument,
nsStyleLinkElement::SetStyleSheet(nullptr);
}
if (!uri && !isInline) {
if (!info) {
return Update { };
}
MOZ_ASSERT(info->mReferrerPolicy != net::RP_Unset ||
info->mReferrerPolicy == doc->GetReferrerPolicy());
if (!info->mURI && !info->mIsInline) {
// If href is empty and this is not inline style then just bail
return Update { };
}
nsAutoString title, type, media;
bool hasAlternateRel;
GetStyleSheetInfo(title, type, media, &hasAlternateRel);
if (!type.LowerCaseEqualsLiteral("text/css")) {
return Update { };
}
// Load the link's referrerpolicy attribute. If the link does not provide a
// referrerpolicy attribute, ignore this and use the document's referrer
// policy
net::ReferrerPolicy referrerPolicy = GetLinkReferrerPolicy();
if (referrerPolicy == net::RP_Unset) {
referrerPolicy = doc->GetReferrerPolicy();
}
if (isInline) {
if (info->mIsInline) {
nsAutoString text;
if (!nsContentUtils::GetNodeTextContent(thisContent, false, text, fallible)) {
return Err(NS_ERROR_OUT_OF_MEMORY);
@ -322,7 +350,7 @@ nsStyleLinkElement::DoUpdateStyleSheet(nsIDocument* aOldDocument,
nsresult rv = NS_OK;
if (!nsStyleUtil::CSPAllowsInlineStyle(thisContent->AsElement(),
thisContent->NodePrincipal(),
triggeringPrincipal,
info->mTriggeringPrincipal,
doc->GetDocumentURI(),
mLineNumber, text, &rv)) {
if (NS_FAILED(rv)) {
@ -333,8 +361,13 @@ nsStyleLinkElement::DoUpdateStyleSheet(nsIDocument* aOldDocument,
// Parse the style sheet.
return doc->CSSLoader()->
LoadInlineStyle(thisContent, text, triggeringPrincipal, mLineNumber,
title, media, referrerPolicy,
LoadInlineStyle(thisContent,
text,
info->mTriggeringPrincipal,
mLineNumber,
info->mTitle,
info->mMedia,
info->mReferrerPolicy,
aObserver);
}
nsAutoString integrity;
@ -349,14 +382,14 @@ nsStyleLinkElement::DoUpdateStyleSheet(nsIDocument* aOldDocument,
}
auto resultOrError =
doc->CSSLoader()->LoadStyleLink(thisContent,
uri,
triggeringPrincipal,
title,
media,
hasAlternateRel,
GetCORSMode(),
referrerPolicy,
integrity,
info->mURI,
info->mTriggeringPrincipal,
info->mTitle,
info->mMedia,
info->mHasAlternateRel,
info->mCORSMode,
info->mReferrerPolicy,
info->mIntegrity,
aObserver);
if (resultOrError.isErr()) {
// Don't propagate LoadStyleLink() errors further than this, since some

54
dom/base/nsStyleLinkElement.h
View File

@ -34,6 +34,43 @@ class ShadowRoot;
class nsStyleLinkElement : public nsIStyleSheetLinkingElement
{
protected:
enum class IsInline
{
Yes,
No
};
struct MOZ_STACK_CLASS StyleSheetInfo
{
const nsIContent* mContent;
// FIXME(emilio): do these really need to be strong refs?
nsCOMPtr<nsIURI> mURI;
nsCOMPtr<nsIPrincipal> mTriggeringPrincipal;
mozilla::net::ReferrerPolicy mReferrerPolicy;
mozilla::CORSMode mCORSMode;
nsAutoString mTitle;
nsAutoString mMedia;
nsAutoString mIntegrity;
bool mHasAlternateRel : 1;
bool mIsInline : 1;
StyleSheetInfo(const nsIDocument&,
const nsIContent*,
already_AddRefed<nsIURI> aURI,
already_AddRefed<nsIPrincipal> aTriggeringPrincipal,
mozilla::net::ReferrerPolicy aReferrerPolicy,
mozilla::CORSMode aCORSMode,
const nsAString& aTitle,
const nsAString& aMedia,
IsAlternate aHasAlternateRel,
IsInline aIsInline);
~StyleSheetInfo();
};
public:
nsStyleLinkElement();
virtual ~nsStyleLinkElement();
@ -93,22 +130,7 @@ protected:
mozilla::dom::ShadowRoot* aOldShadowRoot,
ForceUpdate = ForceUpdate::No);
virtual already_AddRefed<nsIURI> GetStyleSheetURL(bool* aIsInline, nsIPrincipal** aTriggeringPrincipal) = 0;
virtual void GetStyleSheetInfo(nsAString& aTitle,
nsAString& aType,
nsAString& aMedia,
bool* aIsAlternate) = 0;
virtual mozilla::CORSMode GetCORSMode() const
{
// Default to no CORS
return mozilla::CORS_NONE;
}
virtual mozilla::net::ReferrerPolicy GetLinkReferrerPolicy()
{
return mozilla::net::RP_Unset;
}
virtual mozilla::Maybe<StyleSheetInfo> GetStyleSheetInfo() = 0;
// CC methods
void Unlink();

94
dom/html/HTMLLinkElement.cpp
View File

@ -420,80 +420,64 @@ HTMLLinkElement::GetHrefURI() const
return GetHrefURIForAnchors();
}
already_AddRefed<nsIURI>
HTMLLinkElement::GetStyleSheetURL(bool* aIsInline, nsIPrincipal** aTriggeringPrincipal)
Maybe<nsStyleLinkElement::StyleSheetInfo>
HTMLLinkElement::GetStyleSheetInfo()
{
*aIsInline = false;
*aTriggeringPrincipal = nullptr;
nsAutoString href;
GetAttr(kNameSpaceID_None, nsGkAtoms::href, href);
if (href.IsEmpty()) {
return nullptr;
}
nsCOMPtr<nsIPrincipal> prin = mTriggeringPrincipal;
prin.forget(aTriggeringPrincipal);
nsCOMPtr<nsIURI> uri = Link::GetURI();
return uri.forget();
}
void
HTMLLinkElement::GetStyleSheetInfo(nsAString& aTitle,
nsAString& aType,
nsAString& aMedia,
bool* aIsAlternate)
{
aTitle.Truncate();
aType.Truncate();
aMedia.Truncate();
*aIsAlternate = false;
nsAutoString rel;
GetAttr(kNameSpaceID_None, nsGkAtoms::rel, rel);
uint32_t linkTypes = nsStyleLinkElement::ParseLinkTypes(rel);
// Is it a stylesheet link?
if (!(linkTypes & nsStyleLinkElement::eSTYLESHEET)) {
return;
return Nothing();
}
nsAutoString title;
GetAttr(kNameSpaceID_None, nsGkAtoms::title, title);
title.CompressWhitespace();
aTitle.Assign(title);
// If alternate, does it have title?
if (linkTypes & nsStyleLinkElement::eALTERNATE) {
if (aTitle.IsEmpty()) { // alternates must have title
return;
} else {
*aIsAlternate = true;
}
bool alternate = linkTypes & nsStyleLinkElement::eALTERNATE;
if (alternate && title.IsEmpty()) {
// alternates must have title.
return Nothing();
}
GetAttr(kNameSpaceID_None, nsGkAtoms::media, aMedia);
// The HTML5 spec is formulated in terms of the CSSOM spec, which specifies
// that media queries should be ASCII lowercased during serialization.
nsContentUtils::ASCIIToLower(aMedia);
nsAutoString type;
nsAutoString mimeType;
nsAutoString notUsed;
GetAttr(kNameSpaceID_None, nsGkAtoms::type, aType);
nsContentUtils::SplitMimeType(aType, mimeType, notUsed);
GetAttr(kNameSpaceID_None, nsGkAtoms::type, type);
nsContentUtils::SplitMimeType(type, mimeType, notUsed);
if (!mimeType.IsEmpty() && !mimeType.LowerCaseEqualsLiteral("text/css")) {
return;
return Nothing();
}
// If we get here we assume that we're loading a css file, so set the
// type to 'text/css'
aType.AssignLiteral("text/css");
}
nsAutoString href;
GetAttr(kNameSpaceID_None, nsGkAtoms::href, href);
if (href.IsEmpty()) {
return Nothing();
}
CORSMode
HTMLLinkElement::GetCORSMode() const
{
return AttrValueToCORSMode(GetParsedAttr(nsGkAtoms::crossorigin));
nsAutoString media;
GetAttr(kNameSpaceID_None, nsGkAtoms::media, media);
// The HTML5 spec is formulated in terms of the CSSOM spec, which specifies
// that media queries should be ASCII lowercased during serialization.
//
// FIXME(emilio): How does it matter? This is going to be parsed anyway, CSS
// should take care of serializing it properly.
nsContentUtils::ASCIIToLower(media);
nsCOMPtr<nsIURI> uri = Link::GetURI();
nsCOMPtr<nsIPrincipal> prin = mTriggeringPrincipal;
return Some(StyleSheetInfo {
*OwnerDoc(),
this,
uri.forget(),
prin.forget(),
GetReferrerPolicyAsEnum(),
GetCORSMode(),
title,
media,
alternate ? IsAlternate::Yes : IsAlternate::No,
IsInline::No,
});
}
EventStates

16
dom/html/HTMLLinkElement.h
View File

@ -189,12 +189,11 @@ public:
{
GetEnumAttr(nsGkAtoms::referrerpolicy, EmptyCString().get(), aReferrer);
}
mozilla::net::ReferrerPolicy GetLinkReferrerPolicy() override
{
return GetReferrerPolicyAsEnum();
}
virtual CORSMode GetCORSMode() const override;
CORSMode GetCORSMode() const
{
return AttrValueToCORSMode(GetParsedAttr(nsGkAtoms::crossorigin));
}
void NodeInfoChanged(nsIDocument* aOldDoc) final
{
@ -208,13 +207,8 @@ protected:
virtual ~HTMLLinkElement();
// nsStyleLinkElement
already_AddRefed<nsIURI>
GetStyleSheetURL(bool* aIsInline, nsIPrincipal** aTriggeringPrincipal) final;
Maybe<StyleSheetInfo> GetStyleSheetInfo() final;
void GetStyleSheetInfo(nsAString& aTitle,
nsAString& aType,
nsAString& aMedia,
bool* aIsAlternate) final;
protected:
RefPtr<nsDOMTokenList> mRelList;
};

52
dom/html/HTMLStyleElement.cpp
View File

@ -194,47 +194,43 @@ HTMLStyleElement::SetTextContentInternal(const nsAString& aTextContent,
Unused << UpdateStyleSheetInternal(nullptr, nullptr);
}
already_AddRefed<nsIURI>
HTMLStyleElement::GetStyleSheetURL(bool* aIsInline, nsIPrincipal** aTriggeringPrincipal)
Maybe<nsStyleLinkElement::StyleSheetInfo>
HTMLStyleElement::GetStyleSheetInfo()
{
*aIsInline = true;
*aTriggeringPrincipal = do_AddRef(mTriggeringPrincipal).take();
return nullptr;
}
void
HTMLStyleElement::GetStyleSheetInfo(nsAString& aTitle,
nsAString& aType,
nsAString& aMedia,
bool* aIsAlternate)
{
aTitle.Truncate();
aType.Truncate();
aMedia.Truncate();
*aIsAlternate = false;
nsAutoString title;
GetAttr(kNameSpaceID_None, nsGkAtoms::title, title);
title.CompressWhitespace();
aTitle.Assign(title);
GetAttr(kNameSpaceID_None, nsGkAtoms::media, aMedia);
nsAutoString media;
GetAttr(kNameSpaceID_None, nsGkAtoms::media, media);
// The HTML5 spec is formulated in terms of the CSSOM spec, which specifies
// that media queries should be ASCII lowercased during serialization.
nsContentUtils::ASCIIToLower(aMedia);
GetAttr(kNameSpaceID_None, nsGkAtoms::type, aType);
//
// FIXME(emilio): Doesn't matter I'd think, style should take care of that.
nsContentUtils::ASCIIToLower(media);
nsAutoString type;
nsAutoString mimeType;
nsAutoString notUsed;
nsContentUtils::SplitMimeType(aType, mimeType, notUsed);
GetAttr(kNameSpaceID_None, nsGkAtoms::type, type);
nsContentUtils::SplitMimeType(type, mimeType, notUsed);
if (!mimeType.IsEmpty() && !mimeType.LowerCaseEqualsLiteral("text/css")) {
return;
return Nothing();
}
// If we get here we assume that we're loading a css file, so set the
// type to 'text/css'
aType.AssignLiteral("text/css");
nsCOMPtr<nsIPrincipal> prin = mTriggeringPrincipal;
return Some(StyleSheetInfo {
*OwnerDoc(),
this,
nullptr,
prin.forget(),
net::ReferrerPolicy::RP_Unset,
CORS_NONE,
title,
media,
IsAlternate::No,
IsInline::Yes,
});
}
JSObject*

8
dom/html/HTMLStyleElement.h
View File

@ -84,12 +84,8 @@ public:
protected:
virtual ~HTMLStyleElement();
already_AddRefed<nsIURI>
GetStyleSheetURL(bool* aIsInline, nsIPrincipal** aTriggeringPrincipal) final;
void GetStyleSheetInfo(nsAString& aTitle,
nsAString& aType,
nsAString& aMedia,
bool* aIsAlternate) final;
Maybe<StyleSheetInfo> GetStyleSheetInfo() final;
/**
* Common method to call from the various mutation observer methods.
* aContent is a content node that's either the one that changed or its

48
dom/svg/SVGStyleElement.cpp
View File

@ -216,42 +216,38 @@ SVGStyleElement::SetTitle(const nsAString& aTitle, ErrorResult& rv)
//----------------------------------------------------------------------
// nsStyleLinkElement methods
already_AddRefed<nsIURI>
SVGStyleElement::GetStyleSheetURL(bool* aIsInline, nsIPrincipal** aTriggeringPrincipal)
Maybe<nsStyleLinkElement::StyleSheetInfo>
SVGStyleElement::GetStyleSheetInfo()
{
*aIsInline = true;
*aTriggeringPrincipal = nullptr;
return nullptr;
}
void
SVGStyleElement::GetStyleSheetInfo(nsAString& aTitle,
nsAString& aType,
nsAString& aMedia,
bool* aIsAlternate)
{
*aIsAlternate = false;
nsAutoString title;
GetAttr(kNameSpaceID_None, nsGkAtoms::title, title);
title.CompressWhitespace();
aTitle.Assign(title);
GetAttr(kNameSpaceID_None, nsGkAtoms::media, aMedia);
nsAutoString media;
GetAttr(kNameSpaceID_None, nsGkAtoms::media, media);
// The SVG spec is formulated in terms of the CSS2 spec,
// which specifies that media queries are case insensitive.
nsContentUtils::ASCIIToLower(aMedia);
nsContentUtils::ASCIIToLower(media);
GetAttr(kNameSpaceID_None, nsGkAtoms::type, aType);
if (aType.IsEmpty()) {
aType.AssignLiteral("text/css");
// FIXME(emilio): Why doesn't this do the same as HTMLStyleElement?
nsAutoString type;
GetAttr(kNameSpaceID_None, nsGkAtoms::type, type);
if (!type.IsEmpty() && !type.LowerCaseEqualsLiteral("text/css")) {
return Nothing();
}
}
CORSMode
SVGStyleElement::GetCORSMode() const
{
return AttrValueToCORSMode(GetParsedAttr(nsGkAtoms::crossorigin));
return Some(StyleSheetInfo {
*OwnerDoc(),
this,
nullptr,
nullptr,
net::ReferrerPolicy::RP_Unset,
AttrValueToCORSMode(GetParsedAttr(nsGkAtoms::crossorigin)),
title,
media,
IsAlternate::No,
IsInline::Yes,
});
}
} // namespace dom

10
dom/svg/SVGStyleElement.h
View File

@ -84,15 +84,7 @@ protected:
}
// nsStyleLinkElement overrides
already_AddRefed<nsIURI>
GetStyleSheetURL(bool* aIsInline, nsIPrincipal** aTriggeringPrincipal) final;
void GetStyleSheetInfo(nsAString& aTitle,
nsAString& aType,
nsAString& aMedia,
bool* aIsAlternate) final;
CORSMode GetCORSMode() const final;
Maybe<StyleSheetInfo> GetStyleSheetInfo() final;
/**
* Common method to call from the various mutation observer methods.

85
dom/xml/XMLStylesheetProcessingInstruction.cpp
View File

@ -100,65 +100,38 @@ XMLStylesheetProcessingInstruction::OverrideBaseURI(nsIURI* aNewBaseURI)
mOverriddenBaseURI = aNewBaseURI;
}
already_AddRefed<nsIURI>
XMLStylesheetProcessingInstruction::GetStyleSheetURL(bool* aIsInline, nsIPrincipal** aTriggeringPrincipal)
Maybe<nsStyleLinkElement::StyleSheetInfo>
XMLStylesheetProcessingInstruction::GetStyleSheetInfo()
{
*aIsInline = false;
*aTriggeringPrincipal = nullptr;
// xml-stylesheet PI is special only in prolog
if (!nsContentUtils::InProlog(this)) {
return Nothing();
}
nsAutoString href;
if (!GetAttrValue(nsGkAtoms::href, href)) {
return nullptr;
}
nsIURI *baseURL;
nsIDocument *document = OwnerDoc();
baseURL = mOverriddenBaseURI ?
mOverriddenBaseURI.get() :
document->GetDocBaseURI();
auto encoding = document->GetDocumentCharacterSet();
nsCOMPtr<nsIURI> aURI;
NS_NewURI(getter_AddRefs(aURI), href, encoding, baseURL);
return aURI.forget();
}
void
XMLStylesheetProcessingInstruction::GetStyleSheetInfo(nsAString& aTitle,
nsAString& aType,
nsAString& aMedia,
bool* aIsAlternate)
{
aTitle.Truncate();
aType.Truncate();
aMedia.Truncate();
*aIsAlternate = false;
// xml-stylesheet PI is special only in prolog
if (!nsContentUtils::InProlog(this)) {
return;
return Nothing();
}
nsAutoString data;
GetData(data);
nsContentUtils::GetPseudoAttributeValue(data, nsGkAtoms::title, aTitle);
nsAutoString title;
nsContentUtils::GetPseudoAttributeValue(data, nsGkAtoms::title, title);
nsAutoString alternate;
nsAutoString alternateAttr;
nsContentUtils::GetPseudoAttributeValue(data,
nsGkAtoms::alternate,
alternate);
alternateAttr);
// if alternate, does it have title?
if (alternate.EqualsLiteral("yes")) {
if (aTitle.IsEmpty()) { // alternates must have title
return;
}
*aIsAlternate = true;
bool alternate = alternateAttr.EqualsLiteral("yes");
if (alternate && title.IsEmpty()) {
// alternates must have title
return Nothing();
}
nsContentUtils::GetPseudoAttributeValue(data, nsGkAtoms::media, aMedia);
nsAutoString media;
nsContentUtils::GetPseudoAttributeValue(data, nsGkAtoms::media, media);
// Make sure the type handling here matches
// nsXMLContentSink::HandleProcessingInstruction
@ -168,13 +141,27 @@ XMLStylesheetProcessingInstruction::GetStyleSheetInfo(nsAString& aTitle,
nsAutoString mimeType, notUsed;
nsContentUtils::SplitMimeType(type, mimeType, notUsed);
if (!mimeType.IsEmpty() && !mimeType.LowerCaseEqualsLiteral("text/css")) {
aType.Assign(type);
return;
return Nothing();
}
// If we get here we assume that we're loading a css file, so set the
// type to 'text/css'
aType.AssignLiteral("text/css");
nsIDocument* doc = OwnerDoc();
nsIURI* baseURL =
mOverriddenBaseURI ? mOverriddenBaseURI.get() : doc->GetDocBaseURI();
auto encoding = doc->GetDocumentCharacterSet();
nsCOMPtr<nsIURI> uri;
NS_NewURI(getter_AddRefs(uri), href, encoding, baseURL);
return Some(StyleSheetInfo {
*doc,
this,
uri.forget(),
nullptr,
net::RP_Unset,
CORS_NONE,
title,
media,
alternate ? IsAlternate::Yes : IsAlternate::No,
IsInline::No,
});
}
already_AddRefed<CharacterData>

8
dom/xml/XMLStylesheetProcessingInstruction.h
View File

@ -77,12 +77,8 @@ protected:
nsCOMPtr<nsIURI> mOverriddenBaseURI;
already_AddRefed<nsIURI>
GetStyleSheetURL(bool* aIsInline, nsIPrincipal** aTriggeringPrincipal) final;
void GetStyleSheetInfo(nsAString& aTitle,
nsAString& aType,
nsAString& aMedia,
bool* aIsAlternate) final;
Maybe<StyleSheetInfo> GetStyleSheetInfo() final;
already_AddRefed<CharacterData>
CloneDataNode(mozilla::dom::NodeInfo* aNodeInfo,
bool aCloneText) const final;

6
layout/style/Loader.cpp
View File

@ -2164,8 +2164,10 @@ Loader::LoadChildSheet(StyleSheet* aParentSheet,
nsCOMPtr<nsINode> owningNode;
// check for an associated document: if none, don't bother walking up the
// parent sheets
// Check for an associated document: if none, don't bother walking up the
// parent sheets.
//
// FIXME(emilio): This looks wrong for Shadow DOM.
if (aParentSheet->GetAssociatedDocument()) {
StyleSheet* topSheet = aParentSheet;
while (StyleSheet* parent = topSheet->GetParentSheet()) {

5
uriloader/prefetch/nsPrefetchService.cpp
View File

@ -124,10 +124,9 @@ nsPrefetchNode::OpenChannel()
nsCOMPtr<nsILoadGroup> loadGroup = source->OwnerDoc()->GetDocumentLoadGroup();
CORSMode corsMode = CORS_NONE;
net::ReferrerPolicy referrerPolicy = net::RP_Unset;
if (source->IsHTMLElement(nsGkAtoms::link)) {
dom::HTMLLinkElement* link = static_cast<dom::HTMLLinkElement*>(source.get());
if (auto* link = dom::HTMLLinkElement::FromNode(source)) {
corsMode = link->GetCORSMode();
referrerPolicy = link->GetLinkReferrerPolicy();
referrerPolicy = link->GetReferrerPolicyAsEnum();
}
if (referrerPolicy == net::RP_Unset) {