void HTMLAnchorElement::parseAttribute(const QualifiedName& name, const AtomicString& value)
{
if (name == hrefAttr) {
bool wasLink = isLink();
setIsLink(!value.isNull());
if (wasLink != isLink())
didAffectSelector(AffectedSelectorLink | AffectedSelectorVisited | AffectedSelectorEnabled);
if (isLink()) {
String parsedURL = stripLeadingAndTrailingHTMLSpaces(value);
if (document()->isDNSPrefetchEnabled()) {
if (protocolIs(parsedURL, "http") || protocolIs(parsedURL, "https") || parsedURL.startsWith("//"))
prefetchDNS(document()->completeURL(parsedURL).host());
}
if (wasLink)
prefetchEventHandler()->didChangeHREF();
}
invalidateCachedVisitedLinkHash();
} else if (name == nameAttr || name == titleAttr) {
// Do nothing.
} else if (name == relAttr)
setRel(value);
else
HTMLElement::parseAttribute(name, value);
}
void HTMLTrackElement::parseAttribute(const QualifiedName& name, const AtomicString& value)
{
if (RuntimeEnabledFeatures::webkitVideoTrackEnabled()) {
if (name == srcAttr) {
if (!value.isEmpty())
scheduleLoad();
else if (m_track)
m_track->removeAllCues();
// 4.8.10.12.3 Sourcing out-of-band text tracks
// As the kind, label, and srclang attributes are set, changed, or removed, the text track must update accordingly...
} else if (name == kindAttr)
track()->setKind(value.lower());
else if (name == labelAttr)
track()->setLabel(value);
else if (name == srclangAttr)
track()->setLanguage(value);
else if (name == defaultAttr)
track()->setIsDefault(!value.isNull());
}
if (name == onloadAttr)
setAttributeEventListener(eventNames().loadEvent, createAttributeEventListener(this, name, value));
else if (name == onerrorAttr)
setAttributeEventListener(eventNames().errorEvent, createAttributeEventListener(this, name, value));
else
HTMLElement::parseAttribute(name, value);
}
void HTMLElement::parseAttribute(const QualifiedName& name, const AtomicString& value)
{
if (isIdAttributeName(name) || name == classAttr || name == styleAttr)
return Element::parseAttribute(name, value);
if (name == dirAttr)
dirAttributeChanged(value);
else if (name == tabindexAttr) {
int tabindex = 0;
if (value.isEmpty()) {
clearTabIndexExplicitlyIfNeeded();
if (treeScope().adjustedFocusedElement() == this) {
// We might want to call blur(), but it's dangerous to dispatch
// events here.
document().setNeedsFocusedElementCheck();
}
} else if (parseHTMLInteger(value, tabindex)) {
// Clamp tabindex to the range of 'short' to match Firefox's behavior.
setTabIndexExplicitly(max(static_cast<int>(std::numeric_limits<short>::min()), min(tabindex, static_cast<int>(std::numeric_limits<short>::max()))));
}
} else {
AtomicString eventName = eventNameForAttributeName(name);
if (!eventName.isNull())
setAttributeEventListener(eventName, createAttributeEventListener(this, name, value));
}
}
PassOwnPtr<CSSParserSelector> CSSSelectorParser::consumeCompoundSelector(CSSParserTokenRange& range)
{
OwnPtr<CSSParserSelector> selector;
AtomicString namespacePrefix;
AtomicString elementName;
bool hasNamespace;
if (!consumeName(range, elementName, namespacePrefix, hasNamespace)) {
selector = consumeSimpleSelector(range);
if (!selector)
return nullptr;
}
if (m_context.isHTMLDocument())
elementName = elementName.lower();
while (OwnPtr<CSSParserSelector> nextSelector = consumeSimpleSelector(range)) {
if (selector)
selector = rewriteSpecifiers(selector.release(), nextSelector.release());
else
selector = nextSelector.release();
}
if (!selector) {
if (hasNamespace)
return CSSParserSelector::create(determineNameInNamespace(namespacePrefix, elementName));
return CSSParserSelector::create(QualifiedName(nullAtom, elementName, m_defaultNamespace));
}
if (elementName.isNull())
rewriteSpecifiersWithNamespaceIfNeeded(selector.get());
else
rewriteSpecifiersWithElementName(namespacePrefix, elementName, selector.get());
return selector.release();
}
bool LinkLoader::loadLink(const LinkRelAttribute& relAttribute, const AtomicString& crossOriginMode, const String& type, const KURL& href, Document& document)
{
if (relAttribute.isDNSPrefetch()) {
Settings* settings = document.settings();
// FIXME: The href attribute of the link element can be in "//hostname" form, and we shouldn't attempt
// to complete that as URL <https://bugs.webkit.org/show_bug.cgi?id=48857>.
if (settings && settings->dnsPrefetchingEnabled() && href.isValid() && !href.isEmpty())
prefetchDNS(href.host());
}
// FIXME(crbug.com/323096): Should take care of import.
if ((relAttribute.isLinkPrefetch() || relAttribute.isLinkSubresource()) && href.isValid() && document.frame()) {
if (!m_client->shouldLoadLink())
return false;
Resource::Type type = relAttribute.isLinkSubresource() ? Resource::LinkSubresource : Resource::LinkPrefetch;
FetchRequest linkRequest(ResourceRequest(document.completeURL(href)), FetchInitiatorTypeNames::link);
if (!crossOriginMode.isNull())
linkRequest.setCrossOriginAccessControl(document.securityOrigin(), crossOriginMode);
setResource(document.fetcher()->fetchLinkResource(type, linkRequest));
}
if (const unsigned prerenderRelTypes = prerenderRelTypesFromRelAttribute(relAttribute)) {
if (!m_prerender) {
m_prerender = PrerenderHandle::create(document, this, href, prerenderRelTypes);
} else if (m_prerender->url() != href) {
m_prerender->cancel();
m_prerender = PrerenderHandle::create(document, this, href, prerenderRelTypes);
}
// TODO(gavinp): Handle changes to rel types of existing prerenders.
} else if (m_prerender) {
m_prerender->cancel();
m_prerender.clear();
}
return true;
}
void RenderMathMLFenced::updateFromElement()
{
Element* fenced = static_cast<Element*>(node());
// FIXME: Handle open/close values with more than one character (they should be treated like text).
AtomicString openValue = fenced->getAttribute(MathMLNames::openAttr);
if (openValue.length() > 0)
m_open = openValue[0];
AtomicString closeValue = fenced->getAttribute(MathMLNames::closeAttr);
if (closeValue.length() > 0)
m_close = closeValue[0];
AtomicString separators = fenced->getAttribute(MathMLNames::separatorsAttr);
if (!separators.isNull()) {
StringBuilder characters;
for (unsigned int i = 0; i < separators.length(); i++) {
if (!isSpaceOrNewline(separators[i]))
characters.append(separators[i]);
}
m_separators = !characters.length() ? 0 : characters.toString().impl();
} else {
// The separator defaults to a single comma.
m_separators = StringImpl::create(",");
}
if (isEmpty())
makeFences();
}
AtomicString XMLTreeBuilder::NodeStackItem::namespaceURI(AtomicString prefix)
{
ASSERT(!prefix.isNull());
if (m_scopedNamespaces.contains(prefix))
return m_scopedNamespaces.get(prefix);
return nullAtom;
}
void HTMLDetailsElement::parseAttribute(const QualifiedName& name, const AtomicString& value)
{
if (name == openAttr) {
bool oldValue = m_isOpen;
m_isOpen = !value.isNull();
if (m_isOpen == oldValue)
return;
// Dispatch toggle event asynchronously.
detailsToggleEventSender().cancelEvent(this);
detailsToggleEventSender().dispatchEventSoon(this);
Element* content = ensureUserAgentShadowRoot().getElementById(ShadowElementNames::detailsContent());
ASSERT(content);
if (m_isOpen)
content->removeInlineStyleProperty(CSSPropertyDisplay);
else
content->setInlineStyleProperty(CSSPropertyDisplay, CSSValueNone);
Element* summary = ensureUserAgentShadowRoot().getElementById(ShadowElementNames::detailsSummary());
ASSERT(summary);
// FIXME: DetailsMarkerControl's RenderDetailsMarker has no concept of being updated
// without recreating it causing a repaint. Instead we should change it so we can tell
// it to toggle the open/closed triangle state and avoid reattaching the entire summary.
summary->lazyReattachIfAttached();
return;
}
HTMLElement::parseAttribute(name, value);
}
void HTMLBodyElement::parseAttribute(const QualifiedName& name, const AtomicString& value)
{
if (name == vlinkAttr || name == alinkAttr || name == linkAttr) {
if (value.isNull()) {
if (name == linkAttr)
document().resetLinkColor();
else if (name == vlinkAttr)
document().resetVisitedLinkColor();
else
document().resetActiveLinkColor();
} else {
RGBA32 color;
if (CSSParser::parseColor(color, value, !document().inQuirksMode())) {
if (name == linkAttr)
document().setLinkColor(color);
else if (name == vlinkAttr)
document().setVisitedLinkColor(color);
else
document().setActiveLinkColor(color);
}
}
setNeedsStyleRecalc();
} else if (name == onloadAttr)
document().setWindowAttributeEventListener(eventNames().loadEvent, name, value);
else if (name == onbeforeunloadAttr)
document().setWindowAttributeEventListener(eventNames().beforeunloadEvent, name, value);
else if (name == onunloadAttr)
document().setWindowAttributeEventListener(eventNames().unloadEvent, name, value);
else if (name == onpagehideAttr)
document().setWindowAttributeEventListener(eventNames().pagehideEvent, name, value);
else if (name == onpageshowAttr)
document().setWindowAttributeEventListener(eventNames().pageshowEvent, name, value);
else if (name == onpopstateAttr)
document().setWindowAttributeEventListener(eventNames().popstateEvent, name, value);
else if (name == onblurAttr)
document().setWindowAttributeEventListener(eventNames().blurEvent, name, value);
else if (name == onfocusAttr)
document().setWindowAttributeEventListener(eventNames().focusEvent, name, value);
#if ENABLE(ORIENTATION_EVENTS)
else if (name == onorientationchangeAttr)
document().setWindowAttributeEventListener(eventNames().orientationchangeEvent, name, value);
#endif
else if (name == onhashchangeAttr)
document().setWindowAttributeEventListener(eventNames().hashchangeEvent, name, value);
else if (name == onresizeAttr)
document().setWindowAttributeEventListener(eventNames().resizeEvent, name, value);
else if (name == onscrollAttr)
document().setWindowAttributeEventListener(eventNames().scrollEvent, name, value);
else if (name == onselectionchangeAttr)
document().setAttributeEventListener(eventNames().selectionchangeEvent, name, value);
else if (name == onstorageAttr)
document().setWindowAttributeEventListener(eventNames().storageEvent, name, value);
else if (name == ononlineAttr)
document().setWindowAttributeEventListener(eventNames().onlineEvent, name, value);
else if (name == onofflineAttr)
document().setWindowAttributeEventListener(eventNames().offlineEvent, name, value);
else
HTMLElement::parseAttribute(name, value);
}
void HTMLDetailsElement::parseAttribute(const QualifiedName& name, const AtomicString& value)
{
if (name == openAttr) {
bool oldValue = m_isOpen;
m_isOpen = !value.isNull();
if (m_isOpen == oldValue)
return;
// Dispatch toggle event asynchronously.
detailsToggleEventSender().cancelEvent(this);
detailsToggleEventSender().dispatchEventSoon(this);
Element* content = ensureClosedShadowRoot().getElementById(ShadowElementNames::detailsContent());
ASSERT(content);
if (m_isOpen)
content->removeInlineStyleProperty(CSSPropertyDisplay);
else
content->setInlineStyleProperty(CSSPropertyDisplay, CSSValueNone);
// Invalidate the LayoutDetailsMarker in order to turn the arrow signifying if the
// details element is open or closed.
Element* summary = findMainSummary();
ASSERT(summary);
Element* control = toHTMLSummaryElement(summary)->markerControl();
if (control && control->layoutObject())
control->layoutObject()->setShouldDoFullPaintInvalidation();
return;
}
HTMLElement::parseAttribute(name, value);
}
bool LinkLoader::loadLink(const LinkRelAttribute& relAttribute, const AtomicString& crossOriginMode, const String& type, const String& as, const KURL& href, Document& document)
{
// TODO(yoav): Convert all uses of the CrossOriginAttribute to CrossOriginAttributeValue. crbug.com/486689
// FIXME(crbug.com/463266): We're ignoring type here. Maybe we shouldn't.
dnsPrefetchIfNeeded(relAttribute, href, document);
preconnectIfNeeded(relAttribute, href, document, crossOriginAttributeValue(crossOriginMode));
preloadIfNeeded(relAttribute, href, document, as);
// FIXME(crbug.com/323096): Should take care of import.
if ((relAttribute.isLinkPrefetch() || relAttribute.isLinkSubresource() || relAttribute.isTransitionExitingStylesheet()) && href.isValid() && document.frame()) {
if (!m_client->shouldLoadLink())
return false;
Resource::Type type = relAttribute.isLinkSubresource() ? Resource::LinkSubresource : Resource::LinkPrefetch;
FetchRequest linkRequest(ResourceRequest(document.completeURL(href)), FetchInitiatorTypeNames::link);
if (!crossOriginMode.isNull())
linkRequest.setCrossOriginAccessControl(document.securityOrigin(), crossOriginMode);
setResource(document.fetcher()->fetchLinkResource(type, linkRequest));
}
if (const unsigned prerenderRelTypes = prerenderRelTypesFromRelAttribute(relAttribute)) {
if (!m_prerender) {
m_prerender = PrerenderHandle::create(document, this, href, prerenderRelTypes);
} else if (m_prerender->url() != href) {
m_prerender->cancel();
m_prerender = PrerenderHandle::create(document, this, href, prerenderRelTypes);
}
// TODO(gavinp): Handle changes to rel types of existing prerenders.
} else if (m_prerender) {
m_prerender->cancel();
m_prerender.clear();
}
return true;
}
bool ScriptLoader::fetchScript(const String& sourceUrl, FetchRequest::DeferOption defer)
{
ASSERT(m_element);
RefPtrWillBeRawPtr<Document> elementDocument(m_element->document());
if (!m_element->inDocument() || m_element->document() != elementDocument)
return false;
ASSERT(!m_resource);
if (!stripLeadingAndTrailingHTMLSpaces(sourceUrl).isEmpty()) {
FetchRequest request(ResourceRequest(elementDocument->completeURL(sourceUrl)), m_element->localName());
AtomicString crossOriginMode = m_element->fastGetAttribute(HTMLNames::crossoriginAttr);
if (!crossOriginMode.isNull())
request.setCrossOriginAccessControl(elementDocument->securityOrigin(), crossOriginMode);
request.setCharset(scriptCharset());
bool scriptPassesCSP = elementDocument->contentSecurityPolicy()->allowScriptWithNonce(m_element->fastGetAttribute(HTMLNames::nonceAttr));
if (scriptPassesCSP)
request.setContentSecurityCheck(DoNotCheckContentSecurityPolicy);
request.setDefer(defer);
m_resource = elementDocument->fetcher()->fetchScript(request);
m_isExternalScript = true;
}
if (m_resource)
return true;
dispatchErrorEvent();
return false;
}
void HTMLTrackElement::parseAttribute(const QualifiedName& name,
const AtomicString& oldValue,
const AtomicString& value) {
if (name == srcAttr) {
if (!value.isEmpty())
scheduleLoad();
else if (m_track)
m_track->removeAllCues();
// 4.8.10.12.3 Sourcing out-of-band text tracks
// As the kind, label, and srclang attributes are set, changed, or removed,
// the text track must update accordingly...
} else if (name == kindAttr) {
AtomicString lowerCaseValue = value.lower();
// 'missing value default' ("subtitles")
if (lowerCaseValue.isNull())
lowerCaseValue = TextTrack::subtitlesKeyword();
// 'invalid value default' ("metadata")
else if (!TextTrack::isValidKindKeyword(lowerCaseValue))
lowerCaseValue = TextTrack::metadataKeyword();
track()->setKind(lowerCaseValue);
} else if (name == labelAttr) {
track()->setLabel(value);
} else if (name == srclangAttr) {
track()->setLanguage(value);
} else if (name == idAttr) {
track()->setId(value);
}
HTMLElement::parseAttribute(name, oldValue, value);
}
BString::BString(const AtomicString& s)
{
if (s.isNull())
m_bstr = 0;
else
m_bstr = SysAllocStringLen(s.characters(), s.length());
}
void MediaSourceBase::endOfStream(const AtomicString& error, ExceptionCode& ec)
{
DEFINE_STATIC_LOCAL(const AtomicString, network, ("network", AtomicString::ConstructFromLiteral));
DEFINE_STATIC_LOCAL(const AtomicString, decode, ("decode", AtomicString::ConstructFromLiteral));
// 3.1 http://dvcs.w3.org/hg/html-media/raw-file/tip/media-source/media-source.html#dom-endofstream
// 1. If the readyState attribute is not in the "open" state then throw an
// INVALID_STATE_ERR exception and abort these steps.
if (!isOpen()) {
ec = INVALID_STATE_ERR;
return;
}
MediaSourcePrivate::EndOfStreamStatus eosStatus = MediaSourcePrivate::EosNoError;
if (error.isNull() || error.isEmpty())
eosStatus = MediaSourcePrivate::EosNoError;
else if (error == network)
eosStatus = MediaSourcePrivate::EosNetworkError;
else if (error == decode)
eosStatus = MediaSourcePrivate::EosDecodeError;
else {
ec = INVALID_ACCESS_ERR;
return;
}
// 2. Change the readyState attribute value to "ended".
setReadyState(endedKeyword());
m_private->markEndOfStream(eosStatus);
}
ALWAYS_INLINE void Element::setAttributeInternal(size_t index, const QualifiedName& name, const AtomicString& newValue, SynchronizationOfLazyAttribute inSynchronizationOfLazyAttribute)
{
if (newValue.isNull()) {
if (index != kNotFound)
removeAttributeInternal(index, inSynchronizationOfLazyAttribute);
return;
}
if (index == kNotFound) {
appendAttributeInternal(name, newValue, inSynchronizationOfLazyAttribute);
return;
}
const Attribute& existingAttribute = elementData()->attributes().at(index);
QualifiedName existingAttributeName = existingAttribute.name();
if (newValue == existingAttribute.value())
return;
if (!inSynchronizationOfLazyAttribute)
willModifyAttribute(existingAttributeName, existingAttribute.value(), newValue);
ensureUniqueElementData().attributes().at(index).setValue(newValue);
if (!inSynchronizationOfLazyAttribute)
attributeChanged(existingAttributeName, newValue);
}
void HTMLLinkElement::parseAttribute(const QualifiedName& name, const AtomicString& value)
{
if (name == relAttr) {
m_relAttribute = LinkRelAttribute(value);
process();
} else if (name == hrefAttr) {
process();
} else if (name == typeAttr) {
m_type = value;
process();
} else if (name == sizesAttr) {
setSizes(value);
process();
} else if (name == mediaAttr) {
m_media = value.string().lower();
process();
} else if (name == disabledAttr) {
if (LinkStyle* link = linkStyle())
link->setDisabledState(!value.isNull());
} else if (name == onbeforeloadAttr)
setAttributeEventListener(eventNames().beforeloadEvent, createAttributeEventListener(this, name, value));
else {
if (name == titleAttr) {
if (LinkStyle* link = linkStyle())
link->setSheetTitle(value);
}
HTMLElement::parseAttribute(name, value);
}
}
void HTMLElement::parseAttribute(const QualifiedName& name, const AtomicString& value)
{
if (isIdAttributeName(name) || name == classAttr || name == styleAttr)
return StyledElement::parseAttribute(name, value);
if (name == dirAttr)
dirAttributeChanged(value);
else if (name == tabindexAttr) {
int tabindex = 0;
if (value.isEmpty())
clearTabIndexExplicitlyIfNeeded();
else if (parseHTMLInteger(value, tabindex)) {
// Clamp tabindex to the range of 'short' to match Firefox's behavior.
setTabIndexExplicitly(max(static_cast<int>(std::numeric_limits<short>::min()), min(tabindex, static_cast<int>(std::numeric_limits<short>::max()))));
}
#if ENABLE(MICRODATA)
} else if (name == itempropAttr) {
setItemProp(value);
} else if (name == itemrefAttr) {
setItemRef(value);
} else if (name == itemtypeAttr) {
setItemType(value);
#endif
} else {
AtomicString eventName = eventNameForAttributeName(name);
if (!eventName.isNull())
setAttributeEventListener(eventName, createAttributeEventListener(this, name, value));
}
}
static ALWAYS_INLINE void visitedURLInline(const KURL& base, const AtomicString& attributeURL, Vector<UChar, 512>& buffer)
{
if (attributeURL.isNull())
return;
const UChar* characters = attributeURL.characters();
unsigned length = attributeURL.length();
// This is a poor man's completeURL. Faster with less memory allocation.
// FIXME: It's missing a lot of what completeURL does and a lot of what KURL does.
// For example, it does not handle international domain names properly.
// FIXME: It is wrong that we do not do further processing on strings that have "://" in them:
// 1) The "://" could be in the query or anchor.
// 2) The URL's path could have a "/./" or a "/../" or a "//" sequence in it.
// FIXME: needsTrailingSlash does not properly return true for a URL that has no path, but does
// have a query or anchor.
bool hasColonSlashSlash = containsColonSlashSlash(characters, length);
if (hasColonSlashSlash && !needsTrailingSlash(characters, length)) {
buffer.append(attributeURL.characters(), attributeURL.length());
return;
}
if (hasColonSlashSlash) {
// FIXME: This is incorrect for URLs that have a query or anchor; the "/" needs to go at the
// end of the path, *before* the query or anchor.
buffer.append(characters, length);
buffer.append('/');
return;
}
if (!length)
buffer.append(base.string().characters(), base.string().length());
else {
switch (characters[0]) {
case '/':
buffer.append(base.string().characters(), base.pathStart());
break;
case '#':
buffer.append(base.string().characters(), base.pathEnd());
break;
default:
buffer.append(base.string().characters(), base.pathAfterLastSlash());
break;
}
}
buffer.append(characters, length);
cleanPath(buffer);
if (needsTrailingSlash(buffer.data(), buffer.size())) {
// FIXME: This is incorrect for URLs that have a query or anchor; the "/" needs to go at the
// end of the path, *before* the query or anchor.
buffer.append('/');
}
return;
}
void AppBannerController::BannerPromptRequest(
mojom::blink::AppBannerServicePtr servicePtr,
mojom::blink::AppBannerEventRequest eventRequest,
const Vector<String>& platforms,
const BannerPromptRequestCallback& callback) {
if (!m_frame || !m_frame->document()) {
callback.Run(mojom::blink::AppBannerPromptReply::NONE, "");
return;
}
mojom::AppBannerPromptReply reply =
m_frame->domWindow()->dispatchEvent(BeforeInstallPromptEvent::create(
EventTypeNames::beforeinstallprompt, *m_frame, std::move(servicePtr),
std::move(eventRequest), platforms)) ==
DispatchEventResult::NotCanceled
? mojom::AppBannerPromptReply::NONE
: mojom::AppBannerPromptReply::CANCEL;
AtomicString referrer = SecurityPolicy::generateReferrer(
m_frame->document()->getReferrerPolicy(), KURL(),
m_frame->document()->outgoingReferrer())
.referrer;
callback.Run(reply, referrer.isNull() ? emptyString() : referrer);
}
void HTMLAnchorElement::parseAttribute(const QualifiedName& name, const AtomicString& value)
{
if (name == hrefAttr) {
bool wasLink = isLink();
setIsLink(!value.isNull() && !shouldProhibitLinks(this));
if (wasLink != isLink())
setNeedsStyleRecalc();
if (isLink()) {
String parsedURL = stripLeadingAndTrailingHTMLSpaces(value);
if (document().isDNSPrefetchEnabled()) {
if (protocolIsInHTTPFamily(parsedURL) || parsedURL.startsWith("//"))
prefetchDNS(document().completeURL(parsedURL).host());
}
}
invalidateCachedVisitedLinkHash();
} else if (name == nameAttr || name == titleAttr) {
// Do nothing.
} else if (name == relAttr) {
if (SpaceSplitString::spaceSplitStringContainsValue(value, "noreferrer", true))
m_linkRelations |= RelationNoReferrer;
if (m_relList)
m_relList->updateRelAttribute(value);
}
else
HTMLElement::parseAttribute(name, value);
}
void HTMLLinkElement::parseAttribute(const QualifiedName& name, const AtomicString& value)
{
if (name == relAttr) {
m_relAttribute = LinkRelAttribute(value);
process();
} else if (name == hrefAttr) {
process();
} else if (name == typeAttr) {
m_type = value;
process();
} else if (name == sizesAttr) {
m_sizes->setValue(value);
parseSizesAttribute(value, m_iconSizes);
process();
} else if (name == mediaAttr) {
m_media = value.string().lower();
process();
} else if (name == disabledAttr) {
if (LinkStyle* link = linkStyle())
link->setDisabledState(!value.isNull());
} else {
if (name == titleAttr) {
if (LinkStyle* link = linkStyle())
link->setSheetTitle(value);
}
HTMLElement::parseAttribute(name, value);
}
}
void HTMLAnchorElement::parseAttribute(const QualifiedName& name, const AtomicString& value)
{
if (name == hrefAttr) {
bool wasLink = isLink();
setIsLink(!value.isNull());
if (wasLink || isLink()) {
pseudoStateChanged(CSSSelector::PseudoLink);
pseudoStateChanged(CSSSelector::PseudoVisited);
}
if (wasLink && !isLink() && treeScope().adjustedFocusedElement() == this) {
// We might want to call blur(), but it's dangerous to dispatch
// events here.
document().setNeedsFocusedElementCheck();
}
if (isLink()) {
String parsedURL = stripLeadingAndTrailingHTMLSpaces(value);
if (document().isDNSPrefetchEnabled()) {
if (protocolIs(parsedURL, "http") || protocolIs(parsedURL, "https") || parsedURL.startsWith("//"))
prefetchDNS(document().completeURL(parsedURL).host());
}
}
invalidateCachedVisitedLinkHash();
} else if (name == nameAttr || name == titleAttr) {
// Do nothing.
} else if (name == relAttr)
setRel(value);
else
HTMLElement::parseAttribute(name, value);
}
void HTMLLinkElement::parseAttribute(const QualifiedName& name, const AtomicString& value)
{
if (name == relAttr) {
m_relAttribute = LinkRelAttribute(value);
if (m_relList)
m_relList->attributeValueChanged(value);
process();
return;
}
if (name == hrefAttr) {
bool wasLink = isLink();
setIsLink(!value.isNull() && !shouldProhibitLinks(this));
if (wasLink != isLink())
setNeedsStyleRecalc();
process();
return;
}
if (name == typeAttr) {
m_type = value;
process();
return;
}
if (name == sizesAttr) {
if (m_sizes)
m_sizes->attributeValueChanged(value);
process();
return;
}
if (name == mediaAttr) {
m_media = value.string().convertToASCIILowercase();
process();
if (m_sheet && !isDisabled())
document().styleResolverChanged(DeferRecalcStyle);
return;
}
if (name == disabledAttr) {
setDisabledState(!value.isNull());
return;
}
if (name == titleAttr) {
if (m_sheet)
m_sheet->setTitle(value);
return;
}
HTMLElement::parseAttribute(name, value);
}
void Attr::setValue(const AtomicString& value) {
// Element::setAttribute will remove the attribute if value is null.
DCHECK(!value.isNull());
if (m_element)
m_element->setAttribute(getQualifiedName(), value);
else
m_standaloneValueOrAttachedLocalName = value;
}
bool canHyphenate(const AtomicString& localeIdentifier)
{
if (localeIdentifier.isNull())
return false;
if (availableLocales().contains(localeIdentifier))
return true;
return availableLocales().contains(AtomicString(localeIdentifier.string().convertToASCIILowercase()));
}
void HTMLLinkElement::parseAttribute(const QualifiedName& name, const AtomicString& value)
{
if (name == relAttr) {
m_relAttribute = LinkRelAttribute(value);
if (m_relList)
m_relList->associatedAttributeValueChanged(value);
process();
return;
}
if (name == hrefAttr) {
bool wasLink = isLink();
setIsLink(!value.isNull() && !shouldProhibitLinks(this));
if (wasLink != isLink())
invalidateStyleForSubtree();
process();
return;
}
if (name == typeAttr) {
m_type = value;
process();
return;
}
if (name == sizesAttr) {
if (m_sizes)
m_sizes->associatedAttributeValueChanged(value);
process();
return;
}
if (name == mediaAttr) {
m_media = value.string().convertToASCIILowercase();
process();
if (m_sheet && !isDisabled())
m_styleScope->didChangeActiveStyleSheetCandidates();
return;
}
if (name == disabledAttr) {
setDisabledState(!value.isNull());
return;
}
if (name == titleAttr) {
if (m_sheet)
m_sheet->setTitle(value);
return;
}
HTMLElement::parseAttribute(name, value);
}
AtomicString XMLTreeBuilder::NodeStackItem::namespaceForPrefix(AtomicString prefix, AtomicString fallback)
{
AtomicString uri = fallback;
if (!prefix.isNull() && hasNamespaceURI(prefix))
uri = namespaceURI(prefix);
return uri;
}
CSSSelector::PseudoType CSSSelector::parsePseudoType(const AtomicString& name)
{
if (name.isNull())
return PseudoUnknown;
HashMap<AtomicStringImpl*, CSSSelector::PseudoType>* nameToPseudoType = nameToPseudoTypeMap();
HashMap<AtomicStringImpl*, CSSSelector::PseudoType>::iterator slot = nameToPseudoType->find(name.impl());
return slot == nameToPseudoType->end() ? PseudoUnknown : slot->second;
}
void SpaceSplitString::set(const AtomicString& inputString, bool shouldFoldCase)
{
if (inputString.isNull()) {
clear();
return;
}
m_data = SpaceSplitStringData::create(shouldFoldCase ? inputString.convertToASCIILowercase() : inputString);
}