f93834868a
Various places in dom/ use the pattern: already_AddRefed<NodeInfo> ni = ...; which is supposed to be disallowed by our static analysis code, but isn't, for whatever reason. To fix our static analysis code, we need to eliminate instances of the above pattern. Unfortunately, eliminating this pattern requires restructuring how Nodes are created. Most Node subclasses take `already_AddRefed<NodeInfo>&` in their constructors, and a few accept `already_AddRefed<NodeInfo>&&`. We need to enforce the latter pattern consistently, which requires changing dozens of source files.
643 lines
19 KiB
C++
643 lines
19 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/. */
|
|
|
|
#include "mozilla/dom/HTMLLinkElement.h"
|
|
|
|
#include "mozilla/AsyncEventDispatcher.h"
|
|
#include "mozilla/Attributes.h"
|
|
#include "mozilla/EventDispatcher.h"
|
|
#include "mozilla/EventStates.h"
|
|
#include "mozilla/MemoryReporting.h"
|
|
#include "mozilla/Preferences.h"
|
|
#include "mozilla/dom/HTMLLinkElementBinding.h"
|
|
#include "nsContentUtils.h"
|
|
#include "nsGenericHTMLElement.h"
|
|
#include "nsGkAtoms.h"
|
|
#include "nsDOMTokenList.h"
|
|
#include "nsIContentInlines.h"
|
|
#include "nsIDocument.h"
|
|
#include "nsINode.h"
|
|
#include "nsIStyleSheetLinkingElement.h"
|
|
#include "nsIURL.h"
|
|
#include "nsPIDOMWindow.h"
|
|
#include "nsReadableUtils.h"
|
|
#include "nsStyleConsts.h"
|
|
#include "nsStyleLinkElement.h"
|
|
#include "nsUnicharUtils.h"
|
|
#include "nsWindowSizes.h"
|
|
#include "nsIContentPolicy.h"
|
|
#include "nsMimeTypes.h"
|
|
#include "imgLoader.h"
|
|
#include "MediaContainerType.h"
|
|
#include "DecoderDoctorDiagnostics.h"
|
|
#include "DecoderTraits.h"
|
|
#include "MediaList.h"
|
|
#include "nsAttrValueInlines.h"
|
|
|
|
#define LINK_ELEMENT_FLAG_BIT(n_) \
|
|
NODE_FLAG_BIT(ELEMENT_TYPE_SPECIFIC_BITS_OFFSET + (n_))
|
|
|
|
// Link element specific bits
|
|
enum {
|
|
// Indicates that a DNS Prefetch has been requested from this Link element.
|
|
HTML_LINK_DNS_PREFETCH_REQUESTED = LINK_ELEMENT_FLAG_BIT(0),
|
|
|
|
// Indicates that a DNS Prefetch was added to the deferral queue
|
|
HTML_LINK_DNS_PREFETCH_DEFERRED = LINK_ELEMENT_FLAG_BIT(1)
|
|
};
|
|
|
|
#undef LINK_ELEMENT_FLAG_BIT
|
|
|
|
ASSERT_NODE_FLAGS_SPACE(ELEMENT_TYPE_SPECIFIC_BITS_OFFSET + 2);
|
|
|
|
NS_IMPL_NS_NEW_HTML_ELEMENT(Link)
|
|
|
|
namespace mozilla {
|
|
namespace dom {
|
|
|
|
HTMLLinkElement::HTMLLinkElement(already_AddRefed<mozilla::dom::NodeInfo>&& aNodeInfo)
|
|
: nsGenericHTMLElement(std::move(aNodeInfo))
|
|
, Link(this)
|
|
{
|
|
}
|
|
|
|
HTMLLinkElement::~HTMLLinkElement()
|
|
{
|
|
}
|
|
|
|
NS_IMPL_CYCLE_COLLECTION_CLASS(HTMLLinkElement)
|
|
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN_INHERITED(HTMLLinkElement,
|
|
nsGenericHTMLElement)
|
|
tmp->nsStyleLinkElement::Traverse(cb);
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mRelList)
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
|
|
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN_INHERITED(HTMLLinkElement,
|
|
nsGenericHTMLElement)
|
|
tmp->nsStyleLinkElement::Unlink();
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK(mRelList)
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK_END
|
|
|
|
NS_IMPL_ISUPPORTS_CYCLE_COLLECTION_INHERITED(HTMLLinkElement,
|
|
nsGenericHTMLElement,
|
|
nsIStyleSheetLinkingElement,
|
|
Link)
|
|
|
|
NS_IMPL_ELEMENT_CLONE(HTMLLinkElement)
|
|
|
|
bool
|
|
HTMLLinkElement::Disabled()
|
|
{
|
|
StyleSheet* ss = GetSheet();
|
|
return ss && ss->Disabled();
|
|
}
|
|
|
|
void
|
|
HTMLLinkElement::SetDisabled(bool aDisabled)
|
|
{
|
|
if (StyleSheet* ss = GetSheet()) {
|
|
ss->SetDisabled(aDisabled);
|
|
}
|
|
}
|
|
|
|
void
|
|
HTMLLinkElement::OnDNSPrefetchRequested()
|
|
{
|
|
UnsetFlags(HTML_LINK_DNS_PREFETCH_DEFERRED);
|
|
SetFlags(HTML_LINK_DNS_PREFETCH_REQUESTED);
|
|
}
|
|
|
|
void
|
|
HTMLLinkElement::OnDNSPrefetchDeferred()
|
|
{
|
|
UnsetFlags(HTML_LINK_DNS_PREFETCH_REQUESTED);
|
|
SetFlags(HTML_LINK_DNS_PREFETCH_DEFERRED);
|
|
}
|
|
|
|
bool
|
|
HTMLLinkElement::HasDeferredDNSPrefetchRequest()
|
|
{
|
|
return HasFlag(HTML_LINK_DNS_PREFETCH_DEFERRED);
|
|
}
|
|
|
|
nsresult
|
|
HTMLLinkElement::BindToTree(nsIDocument* aDocument,
|
|
nsIContent* aParent,
|
|
nsIContent* aBindingParent)
|
|
{
|
|
Link::ResetLinkState(false, Link::ElementHasHref());
|
|
|
|
nsresult rv = nsGenericHTMLElement::BindToTree(aDocument, aParent,
|
|
aBindingParent);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
if (nsIDocument* doc = GetComposedDoc()) {
|
|
doc->RegisterPendingLinkUpdate(this);
|
|
TryDNSPrefetchOrPreconnectOrPrefetchOrPreloadOrPrerender();
|
|
}
|
|
|
|
void (HTMLLinkElement::*update)() = &HTMLLinkElement::UpdateStyleSheetInternal;
|
|
nsContentUtils::AddScriptRunner(
|
|
NewRunnableMethod("dom::HTMLLinkElement::BindToTree", this, update));
|
|
|
|
if (aDocument && this->AttrValueIs(kNameSpaceID_None, nsGkAtoms::rel, nsGkAtoms::localization, eIgnoreCase)) {
|
|
aDocument->LocalizationLinkAdded(this);
|
|
}
|
|
|
|
CreateAndDispatchEvent(aDocument, NS_LITERAL_STRING("DOMLinkAdded"));
|
|
|
|
return rv;
|
|
}
|
|
|
|
void
|
|
HTMLLinkElement::LinkAdded()
|
|
{
|
|
CreateAndDispatchEvent(OwnerDoc(), NS_LITERAL_STRING("DOMLinkAdded"));
|
|
}
|
|
|
|
void
|
|
HTMLLinkElement::LinkRemoved()
|
|
{
|
|
CreateAndDispatchEvent(OwnerDoc(), NS_LITERAL_STRING("DOMLinkRemoved"));
|
|
}
|
|
|
|
void
|
|
HTMLLinkElement::UnbindFromTree(bool aDeep, bool aNullParent)
|
|
{
|
|
// Cancel any DNS prefetches
|
|
// Note: Must come before ResetLinkState. If called after, it will recreate
|
|
// mCachedURI based on data that is invalid - due to a call to GetHostname.
|
|
CancelDNSPrefetch(HTML_LINK_DNS_PREFETCH_DEFERRED,
|
|
HTML_LINK_DNS_PREFETCH_REQUESTED);
|
|
CancelPrefetchOrPreload();
|
|
|
|
// If this link is ever reinserted into a document, it might
|
|
// be under a different xml:base, so forget the cached state now.
|
|
Link::ResetLinkState(false, Link::ElementHasHref());
|
|
|
|
// If this is reinserted back into the document it will not be
|
|
// from the parser.
|
|
nsIDocument* oldDoc = GetUncomposedDoc();
|
|
ShadowRoot* oldShadowRoot = GetContainingShadow();
|
|
|
|
if (oldDoc && this->AttrValueIs(kNameSpaceID_None, nsGkAtoms::rel, nsGkAtoms::localization, eIgnoreCase)) {
|
|
oldDoc->LocalizationLinkRemoved(this);
|
|
}
|
|
|
|
CreateAndDispatchEvent(oldDoc, NS_LITERAL_STRING("DOMLinkRemoved"));
|
|
nsGenericHTMLElement::UnbindFromTree(aDeep, aNullParent);
|
|
|
|
Unused << UpdateStyleSheetInternal(oldDoc, oldShadowRoot);
|
|
}
|
|
|
|
bool
|
|
HTMLLinkElement::ParseAttribute(int32_t aNamespaceID,
|
|
nsAtom* aAttribute,
|
|
const nsAString& aValue,
|
|
nsIPrincipal* aMaybeScriptedPrincipal,
|
|
nsAttrValue& aResult)
|
|
{
|
|
if (aNamespaceID == kNameSpaceID_None) {
|
|
if (aAttribute == nsGkAtoms::crossorigin) {
|
|
ParseCORSValue(aValue, aResult);
|
|
return true;
|
|
}
|
|
|
|
if (aAttribute == nsGkAtoms::as) {
|
|
ParseAsValue(aValue, aResult);
|
|
return true;
|
|
}
|
|
|
|
if (aAttribute == nsGkAtoms::sizes) {
|
|
aResult.ParseAtomArray(aValue);
|
|
return true;
|
|
}
|
|
|
|
if (aAttribute == nsGkAtoms::integrity) {
|
|
aResult.ParseStringOrAtom(aValue);
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return nsGenericHTMLElement::ParseAttribute(aNamespaceID, aAttribute, aValue,
|
|
aMaybeScriptedPrincipal, aResult);
|
|
}
|
|
|
|
void
|
|
HTMLLinkElement::CreateAndDispatchEvent(nsIDocument* aDoc,
|
|
const nsAString& aEventName)
|
|
{
|
|
if (!aDoc)
|
|
return;
|
|
|
|
// In the unlikely case that both rev is specified *and* rel=stylesheet,
|
|
// this code will cause the event to fire, on the principle that maybe the
|
|
// page really does want to specify that its author is a stylesheet. Since
|
|
// this should never actually happen and the performance hit is minimal,
|
|
// doing the "right" thing costs virtually nothing here, even if it doesn't
|
|
// make much sense.
|
|
static Element::AttrValuesArray strings[] =
|
|
{&nsGkAtoms::_empty, &nsGkAtoms::stylesheet, nullptr};
|
|
|
|
if (!nsContentUtils::HasNonEmptyAttr(this, kNameSpaceID_None,
|
|
nsGkAtoms::rev) &&
|
|
FindAttrValueIn(kNameSpaceID_None, nsGkAtoms::rel,
|
|
strings, eIgnoreCase) != ATTR_VALUE_NO_MATCH)
|
|
return;
|
|
|
|
RefPtr<AsyncEventDispatcher> asyncDispatcher =
|
|
new AsyncEventDispatcher(this,
|
|
aEventName,
|
|
CanBubble::eYes,
|
|
ChromeOnlyDispatch::eYes);
|
|
// Always run async in order to avoid running script when the content
|
|
// sink isn't expecting it.
|
|
asyncDispatcher->PostDOMEvent();
|
|
}
|
|
|
|
nsresult
|
|
HTMLLinkElement::BeforeSetAttr(int32_t aNameSpaceID, nsAtom* aName,
|
|
const nsAttrValueOrString* aValue, bool aNotify)
|
|
{
|
|
if (aNameSpaceID == kNameSpaceID_None &&
|
|
(aName == nsGkAtoms::href || aName == nsGkAtoms::rel)) {
|
|
CancelDNSPrefetch(HTML_LINK_DNS_PREFETCH_DEFERRED,
|
|
HTML_LINK_DNS_PREFETCH_REQUESTED);
|
|
CancelPrefetchOrPreload();
|
|
}
|
|
|
|
return nsGenericHTMLElement::BeforeSetAttr(aNameSpaceID, aName,
|
|
aValue, aNotify);
|
|
}
|
|
|
|
nsresult
|
|
HTMLLinkElement::AfterSetAttr(int32_t aNameSpaceID, nsAtom* aName,
|
|
const nsAttrValue* aValue,
|
|
const nsAttrValue* aOldValue,
|
|
nsIPrincipal* aSubjectPrincipal,
|
|
bool aNotify)
|
|
{
|
|
// It's safe to call ResetLinkState here because our new attr value has
|
|
// already been set or unset. ResetLinkState needs the updated attribute
|
|
// value because notifying the document that content states have changed will
|
|
// call IntrinsicState, which will try to get updated information about the
|
|
// visitedness from Link.
|
|
if (aName == nsGkAtoms::href && kNameSpaceID_None == aNameSpaceID) {
|
|
bool hasHref = aValue;
|
|
Link::ResetLinkState(!!aNotify, hasHref);
|
|
if (IsInUncomposedDoc()) {
|
|
CreateAndDispatchEvent(OwnerDoc(), NS_LITERAL_STRING("DOMLinkChanged"));
|
|
}
|
|
}
|
|
|
|
if (aNameSpaceID == kNameSpaceID_None && aName == nsGkAtoms::href) {
|
|
mTriggeringPrincipal = nsContentUtils::GetAttrTriggeringPrincipal(
|
|
this, aValue ? aValue->GetStringValue() : EmptyString(),
|
|
aSubjectPrincipal);
|
|
}
|
|
|
|
// If a link's `rel` attribute was changed from or to `localization`,
|
|
// update the list of localization links.
|
|
if (aNameSpaceID == kNameSpaceID_None && aName == nsGkAtoms::rel) {
|
|
nsIDocument* doc = GetComposedDoc();
|
|
if (doc) {
|
|
if ((aValue && aValue->Equals(nsGkAtoms::localization, eIgnoreCase)) &&
|
|
(!aOldValue || !aOldValue->Equals(nsGkAtoms::localization, eIgnoreCase))) {
|
|
doc->LocalizationLinkAdded(this);
|
|
} else if ((aOldValue && aOldValue->Equals(nsGkAtoms::localization, eIgnoreCase)) &&
|
|
(!aValue || !aValue->Equals(nsGkAtoms::localization, eIgnoreCase))) {
|
|
doc->LocalizationLinkRemoved(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
// If the link has `rel=localization` and its `href` attribute is changed,
|
|
// update the list of localization links.
|
|
if (aNameSpaceID == kNameSpaceID_None && aName == nsGkAtoms::href &&
|
|
AttrValueIs(kNameSpaceID_None, nsGkAtoms::rel, nsGkAtoms::localization, eIgnoreCase)) {
|
|
nsIDocument* doc = GetComposedDoc();
|
|
if (doc) {
|
|
if (aOldValue) {
|
|
doc->LocalizationLinkRemoved(this);
|
|
}
|
|
if (aValue) {
|
|
doc->LocalizationLinkAdded(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (aValue) {
|
|
if (aNameSpaceID == kNameSpaceID_None &&
|
|
(aName == nsGkAtoms::href ||
|
|
aName == nsGkAtoms::rel ||
|
|
aName == nsGkAtoms::title ||
|
|
aName == nsGkAtoms::media ||
|
|
aName == nsGkAtoms::type ||
|
|
aName == nsGkAtoms::as ||
|
|
aName == nsGkAtoms::crossorigin)) {
|
|
bool dropSheet = false;
|
|
if (aName == nsGkAtoms::rel) {
|
|
nsAutoString value;
|
|
aValue->ToString(value);
|
|
uint32_t linkTypes = nsStyleLinkElement::ParseLinkTypes(value);
|
|
if (GetSheet()) {
|
|
dropSheet = !(linkTypes & nsStyleLinkElement::eSTYLESHEET);
|
|
}
|
|
}
|
|
|
|
if ((aName == nsGkAtoms::rel || aName == nsGkAtoms::href) &&
|
|
IsInComposedDoc()) {
|
|
TryDNSPrefetchOrPreconnectOrPrefetchOrPreloadOrPrerender();
|
|
}
|
|
|
|
if ((aName == nsGkAtoms::as || aName == nsGkAtoms::type ||
|
|
aName == nsGkAtoms::crossorigin || aName == nsGkAtoms::media) &&
|
|
IsInComposedDoc()) {
|
|
UpdatePreload(aName, aValue, aOldValue);
|
|
}
|
|
|
|
const bool forceUpdate = dropSheet ||
|
|
aName == nsGkAtoms::title ||
|
|
aName == nsGkAtoms::media ||
|
|
aName == nsGkAtoms::type;
|
|
|
|
Unused << UpdateStyleSheetInternal(
|
|
nullptr, nullptr, forceUpdate ? ForceUpdate::Yes : ForceUpdate::No);
|
|
}
|
|
} else {
|
|
// Since removing href or rel makes us no longer link to a
|
|
// stylesheet, force updates for those too.
|
|
if (aNameSpaceID == kNameSpaceID_None) {
|
|
if (aName == nsGkAtoms::href ||
|
|
aName == nsGkAtoms::rel ||
|
|
aName == nsGkAtoms::title ||
|
|
aName == nsGkAtoms::media ||
|
|
aName == nsGkAtoms::type) {
|
|
Unused << UpdateStyleSheetInternal(nullptr, nullptr, ForceUpdate::Yes);
|
|
}
|
|
if ((aName == nsGkAtoms::as || aName == nsGkAtoms::type ||
|
|
aName == nsGkAtoms::crossorigin || aName == nsGkAtoms::media) &&
|
|
IsInComposedDoc()) {
|
|
UpdatePreload(aName, aValue, aOldValue);
|
|
}
|
|
}
|
|
}
|
|
|
|
return nsGenericHTMLElement::AfterSetAttr(aNameSpaceID, aName, aValue,
|
|
aOldValue, aSubjectPrincipal, aNotify);
|
|
}
|
|
|
|
void
|
|
HTMLLinkElement::GetEventTargetParent(EventChainPreVisitor& aVisitor)
|
|
{
|
|
GetEventTargetParentForAnchors(aVisitor);
|
|
}
|
|
|
|
nsresult
|
|
HTMLLinkElement::PostHandleEvent(EventChainPostVisitor& aVisitor)
|
|
{
|
|
return PostHandleEventForAnchors(aVisitor);
|
|
}
|
|
|
|
bool
|
|
HTMLLinkElement::IsLink(nsIURI** aURI) const
|
|
{
|
|
return IsHTMLLink(aURI);
|
|
}
|
|
|
|
void
|
|
HTMLLinkElement::GetLinkTarget(nsAString& aTarget)
|
|
{
|
|
GetAttr(kNameSpaceID_None, nsGkAtoms::target, aTarget);
|
|
if (aTarget.IsEmpty()) {
|
|
GetBaseTarget(aTarget);
|
|
}
|
|
}
|
|
|
|
static const DOMTokenListSupportedToken sSupportedRelValues[] = {
|
|
// Keep this in sync with ToLinkMask in nsStyleLinkElement.cpp.
|
|
// "preload" must come first because it can be disabled.
|
|
"preload",
|
|
"prefetch",
|
|
"dns-prefetch",
|
|
"stylesheet",
|
|
"next",
|
|
"alternate",
|
|
"preconnect",
|
|
"icon",
|
|
"search",
|
|
nullptr
|
|
};
|
|
|
|
nsDOMTokenList*
|
|
HTMLLinkElement::RelList()
|
|
{
|
|
if (!mRelList) {
|
|
if (Preferences::GetBool("network.preload")) {
|
|
mRelList = new nsDOMTokenList(this, nsGkAtoms::rel, sSupportedRelValues);
|
|
} else {
|
|
mRelList = new nsDOMTokenList(this, nsGkAtoms::rel, &sSupportedRelValues[1]);
|
|
}
|
|
}
|
|
return mRelList;
|
|
}
|
|
|
|
already_AddRefed<nsIURI>
|
|
HTMLLinkElement::GetHrefURI() const
|
|
{
|
|
return GetHrefURIForAnchors();
|
|
}
|
|
|
|
Maybe<nsStyleLinkElement::SheetInfo>
|
|
HTMLLinkElement::GetStyleSheetInfo()
|
|
{
|
|
nsAutoString rel;
|
|
GetAttr(kNameSpaceID_None, nsGkAtoms::rel, rel);
|
|
uint32_t linkTypes = nsStyleLinkElement::ParseLinkTypes(rel);
|
|
if (!(linkTypes & nsStyleLinkElement::eSTYLESHEET)) {
|
|
return Nothing();
|
|
}
|
|
|
|
if (!IsCSSMimeTypeAttribute(*this)) {
|
|
return Nothing();
|
|
}
|
|
|
|
nsAutoString title;
|
|
nsAutoString media;
|
|
GetTitleAndMediaForElement(*this, title, media);
|
|
|
|
bool alternate = linkTypes & nsStyleLinkElement::eALTERNATE;
|
|
if (alternate && title.IsEmpty()) {
|
|
// alternates must have title.
|
|
return Nothing();
|
|
}
|
|
|
|
nsAutoString href;
|
|
GetAttr(kNameSpaceID_None, nsGkAtoms::href, href);
|
|
if (href.IsEmpty()) {
|
|
return Nothing();
|
|
}
|
|
|
|
nsCOMPtr<nsIURI> uri = Link::GetURI();
|
|
nsCOMPtr<nsIPrincipal> prin = mTriggeringPrincipal;
|
|
return Some(SheetInfo {
|
|
*OwnerDoc(),
|
|
this,
|
|
uri.forget(),
|
|
prin.forget(),
|
|
GetReferrerPolicyAsEnum(),
|
|
GetCORSMode(),
|
|
title,
|
|
media,
|
|
alternate ? HasAlternateRel::Yes : HasAlternateRel::No,
|
|
IsInline::No,
|
|
});
|
|
}
|
|
|
|
EventStates
|
|
HTMLLinkElement::IntrinsicState() const
|
|
{
|
|
return Link::LinkState() | nsGenericHTMLElement::IntrinsicState();
|
|
}
|
|
|
|
void
|
|
HTMLLinkElement::AddSizeOfExcludingThis(nsWindowSizes& aSizes,
|
|
size_t* aNodeSize) const
|
|
{
|
|
nsGenericHTMLElement::AddSizeOfExcludingThis(aSizes, aNodeSize);
|
|
*aNodeSize += Link::SizeOfExcludingThis(aSizes.mState);
|
|
}
|
|
|
|
JSObject*
|
|
HTMLLinkElement::WrapNode(JSContext* aCx, JS::Handle<JSObject*> aGivenProto)
|
|
{
|
|
return HTMLLinkElement_Binding::Wrap(aCx, this, aGivenProto);
|
|
}
|
|
|
|
void
|
|
HTMLLinkElement::GetAs(nsAString& aResult)
|
|
{
|
|
GetEnumAttr(nsGkAtoms::as, EmptyCString().get(), aResult);
|
|
}
|
|
|
|
// We will use official mime-types from:
|
|
// https://www.iana.org/assignments/media-types/media-types.xhtml#font
|
|
// We do not support old deprecated mime-types for preload feature.
|
|
// (We currectly do not support font/collection)
|
|
static uint32_t StyleLinkElementFontMimeTypesNum = 5;
|
|
static const char* StyleLinkElementFontMimeTypes[] = {
|
|
"font/otf",
|
|
"font/sfnt",
|
|
"font/ttf",
|
|
"font/woff",
|
|
"font/woff2"
|
|
};
|
|
|
|
bool
|
|
IsFontMimeType(const nsAString& aType)
|
|
{
|
|
if (aType.IsEmpty()) {
|
|
return true;
|
|
}
|
|
for (uint32_t i = 0; i < StyleLinkElementFontMimeTypesNum; i++) {
|
|
if (aType.EqualsASCII(StyleLinkElementFontMimeTypes[i])) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool
|
|
HTMLLinkElement::CheckPreloadAttrs(const nsAttrValue& aAs,
|
|
const nsAString& aType,
|
|
const nsAString& aMedia,
|
|
nsIDocument* aDocument)
|
|
{
|
|
nsContentPolicyType policyType = Link::AsValueToContentPolicy(aAs);
|
|
if (policyType == nsIContentPolicy::TYPE_INVALID) {
|
|
return false;
|
|
}
|
|
|
|
// Check if media attribute is valid.
|
|
if (!aMedia.IsEmpty()) {
|
|
RefPtr<MediaList> mediaList = MediaList::Create(aMedia);
|
|
nsPresContext* presContext = aDocument->GetPresContext();
|
|
if (!presContext) {
|
|
return false;
|
|
}
|
|
if (!mediaList->Matches(presContext)) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
if (aType.IsEmpty()) {
|
|
return true;
|
|
}
|
|
|
|
nsString type = nsString(aType);
|
|
ToLowerCase(type);
|
|
|
|
if (policyType == nsIContentPolicy::TYPE_OTHER) {
|
|
return true;
|
|
|
|
} else if (policyType == nsIContentPolicy::TYPE_MEDIA) {
|
|
if (aAs.GetEnumValue() == DESTINATION_TRACK) {
|
|
if (type.EqualsASCII("text/vtt")) {
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
Maybe<MediaContainerType> mimeType = MakeMediaContainerType(aType);
|
|
if (!mimeType) {
|
|
return false;
|
|
}
|
|
DecoderDoctorDiagnostics diagnostics;
|
|
CanPlayStatus status = DecoderTraits::CanHandleContainerType(*mimeType,
|
|
&diagnostics);
|
|
// Preload if this return CANPLAY_YES and CANPLAY_MAYBE.
|
|
if (status == CANPLAY_NO) {
|
|
return false;
|
|
} else {
|
|
return true;
|
|
}
|
|
|
|
} else if (policyType == nsIContentPolicy::TYPE_FONT) {
|
|
if (IsFontMimeType(type)) {
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
|
|
} else if (policyType == nsIContentPolicy::TYPE_IMAGE) {
|
|
if (imgLoader::SupportImageWithMimeType(NS_ConvertUTF16toUTF8(type).get(),
|
|
AcceptedMimeTypes::IMAGES_AND_DOCUMENTS)) {
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
|
|
} else if (policyType == nsIContentPolicy::TYPE_SCRIPT) {
|
|
if (nsContentUtils::IsJavascriptMIMEType(type)) {
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
|
|
} else if (policyType == nsIContentPolicy::TYPE_STYLESHEET) {
|
|
if (type.EqualsASCII("text/css")) {
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
} // namespace dom
|
|
} // namespace mozilla
|