HTMLLinkElement.cpp [plain text]
#include "config.h"
#include "HTMLLinkElement.h"
#include "Attribute.h"
#include "CachedCSSStyleSheet.h"
#include "CachedResource.h"
#include "CachedResourceLoader.h"
#include "CachedResourceRequest.h"
#include "Document.h"
#include "DocumentStyleSheetCollection.h"
#include "Event.h"
#include "EventSender.h"
#include "Frame.h"
#include "FrameLoader.h"
#include "FrameLoaderClient.h"
#include "FrameTree.h"
#include "FrameView.h"
#include "HTMLNames.h"
#include "HTMLParserIdioms.h"
#include "MediaList.h"
#include "MediaQueryEvaluator.h"
#include "Page.h"
#include "RenderStyle.h"
#include "SecurityOrigin.h"
#include "Settings.h"
#include "StyleInheritedData.h"
#include "StyleResolveForDocument.h"
#include "StyleSheetContents.h"
#include <wtf/Ref.h>
#include <wtf/StdLibExtras.h>
namespace WebCore {
using namespace HTMLNames;
static LinkEventSender& linkLoadEventSender()
{
DEPRECATED_DEFINE_STATIC_LOCAL(LinkEventSender, sharedLoadEventSender, (eventNames().loadEvent));
return sharedLoadEventSender;
}
inline HTMLLinkElement::HTMLLinkElement(const QualifiedName& tagName, Document& document, bool createdByParser)
: HTMLElement(tagName, document)
, m_linkLoader(this)
, m_sizes(DOMSettableTokenList::create())
, m_disabledState(Unset)
, m_loading(false)
, m_createdByParser(createdByParser)
, m_isInShadowTree(false)
, m_firedLoad(false)
, m_loadedSheet(false)
, m_pendingSheetType(Unknown)
{
ASSERT(hasTagName(linkTag));
}
PassRefPtr<HTMLLinkElement> HTMLLinkElement::create(const QualifiedName& tagName, Document& document, bool createdByParser)
{
return adoptRef(new HTMLLinkElement(tagName, document, createdByParser));
}
HTMLLinkElement::~HTMLLinkElement()
{
if (m_sheet)
m_sheet->clearOwnerNode();
if (m_cachedSheet)
m_cachedSheet->removeClient(this);
if (inDocument())
document().styleSheetCollection().removeStyleSheetCandidateNode(*this);
linkLoadEventSender().cancelEvent(this);
}
void HTMLLinkElement::setDisabledState(bool disabled)
{
DisabledState oldDisabledState = m_disabledState;
m_disabledState = disabled ? Disabled : EnabledViaScript;
if (oldDisabledState != m_disabledState) {
if (styleSheetIsLoading()) {
if (m_disabledState == Disabled)
removePendingSheet();
if (m_relAttribute.m_isAlternate && m_disabledState == EnabledViaScript)
addPendingSheet(ActiveSheet);
if (!m_relAttribute.m_isAlternate && m_disabledState == EnabledViaScript && oldDisabledState == Disabled)
addPendingSheet(ActiveSheet);
return;
}
if (!m_sheet && m_disabledState == EnabledViaScript)
process();
else
document().styleResolverChanged(DeferRecalcStyle); }
}
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)
setDisabledState(!value.isNull());
else if (name == onbeforeloadAttr)
setAttributeEventListener(eventNames().beforeloadEvent, name, value);
else {
if (name == titleAttr && m_sheet)
m_sheet->setTitle(value);
HTMLElement::parseAttribute(name, value);
}
}
bool HTMLLinkElement::shouldLoadLink()
{
Ref<Document> originalDocument(document());
if (!dispatchBeforeLoadEvent(getNonEmptyURLAttribute(hrefAttr)))
return false;
if (!inDocument() || &document() != &originalDocument.get())
return false;
return true;
}
void HTMLLinkElement::process()
{
if (!inDocument() || m_isInShadowTree) {
ASSERT(!m_sheet);
return;
}
String type = m_type.lower();
URL url = getNonEmptyURLAttribute(hrefAttr);
if (!m_linkLoader.loadLink(m_relAttribute, type, m_sizes->toString(), url, &document()))
return;
bool acceptIfTypeContainsTextCSS = document().page() && document().page()->settings().treatsAnyTextCSSLinkAsStylesheet();
if (m_disabledState != Disabled && (m_relAttribute.m_isStyleSheet || (acceptIfTypeContainsTextCSS && type.contains("text/css")))
&& document().frame() && url.isValid()) {
String charset = getAttribute(charsetAttr);
if (charset.isEmpty() && document().frame())
charset = document().charset();
if (m_cachedSheet) {
removePendingSheet();
m_cachedSheet->removeClient(this);
m_cachedSheet = 0;
}
if (!shouldLoadLink())
return;
m_loading = true;
bool mediaQueryMatches = true;
if (!m_media.isEmpty()) {
RefPtr<RenderStyle> documentStyle;
if (document().hasLivingRenderTree())
documentStyle = Style::resolveForDocument(document());
RefPtr<MediaQuerySet> media = MediaQuerySet::createAllowingDescriptionSyntax(m_media);
MediaQueryEvaluator evaluator(document().frame()->view()->mediaType(), document().frame(), documentStyle.get());
mediaQueryMatches = evaluator.eval(media.get());
}
bool isActive = mediaQueryMatches && !isAlternate();
addPendingSheet(isActive ? ActiveSheet : InactiveSheet);
ResourceLoadPriority priority = isActive ? ResourceLoadPriorityUnresolved : ResourceLoadPriorityVeryLow;
CachedResourceRequest request(ResourceRequest(document().completeURL(url)), charset, priority);
request.setInitiator(this);
m_cachedSheet = document().cachedResourceLoader()->requestCSSStyleSheet(request);
if (m_cachedSheet)
m_cachedSheet->addClient(this);
else {
m_loading = false;
removePendingSheet();
}
} else if (m_sheet) {
clearSheet();
document().styleResolverChanged(DeferRecalcStyle);
}
}
void HTMLLinkElement::clearSheet()
{
ASSERT(m_sheet);
ASSERT(m_sheet->ownerNode() == this);
m_sheet->clearOwnerNode();
m_sheet = 0;
}
Node::InsertionNotificationRequest HTMLLinkElement::insertedInto(ContainerNode& insertionPoint)
{
HTMLElement::insertedInto(insertionPoint);
if (!insertionPoint.inDocument())
return InsertionDone;
m_isInShadowTree = isInShadowTree();
if (m_isInShadowTree)
return InsertionDone;
document().styleSheetCollection().addStyleSheetCandidateNode(*this, m_createdByParser);
process();
return InsertionDone;
}
void HTMLLinkElement::removedFrom(ContainerNode& insertionPoint)
{
HTMLElement::removedFrom(insertionPoint);
if (!insertionPoint.inDocument())
return;
m_linkLoader.released();
if (m_isInShadowTree) {
ASSERT(!m_sheet);
return;
}
document().styleSheetCollection().removeStyleSheetCandidateNode(*this);
if (m_sheet)
clearSheet();
if (styleSheetIsLoading())
removePendingSheet(RemovePendingSheetNotifyLater);
if (document().hasLivingRenderTree())
document().styleResolverChanged(DeferRecalcStyleIfNeeded);
}
void HTMLLinkElement::finishParsingChildren()
{
m_createdByParser = false;
HTMLElement::finishParsingChildren();
}
void HTMLLinkElement::setCSSStyleSheet(const String& href, const URL& baseURL, const String& charset, const CachedCSSStyleSheet* cachedStyleSheet)
{
if (!inDocument()) {
ASSERT(!m_sheet);
return;
}
Ref<HTMLLinkElement> protect(*this);
CSSParserContext parserContext(document(), baseURL, charset);
if (RefPtr<StyleSheetContents> restoredSheet = const_cast<CachedCSSStyleSheet*>(cachedStyleSheet)->restoreParsedStyleSheet(parserContext)) {
ASSERT(restoredSheet->isCacheable());
ASSERT(!restoredSheet->isLoading());
m_sheet = CSSStyleSheet::create(restoredSheet.releaseNonNull(), this);
m_sheet->setMediaQueries(MediaQuerySet::createAllowingDescriptionSyntax(m_media));
m_sheet->setTitle(title());
m_loading = false;
sheetLoaded();
notifyLoadedSheetAndAllCriticalSubresources(false);
return;
}
Ref<StyleSheetContents> styleSheet(StyleSheetContents::create(href, parserContext));
m_sheet = CSSStyleSheet::create(styleSheet.get(), this);
m_sheet->setMediaQueries(MediaQuerySet::createAllowingDescriptionSyntax(m_media));
m_sheet->setTitle(title());
styleSheet.get().parseAuthorStyleSheet(cachedStyleSheet, document().securityOrigin());
m_loading = false;
styleSheet.get().notifyLoadedSheet(cachedStyleSheet);
styleSheet.get().checkLoaded();
if (styleSheet.get().isCacheable())
const_cast<CachedCSSStyleSheet*>(cachedStyleSheet)->saveParsedStyleSheet(styleSheet.get());
}
bool HTMLLinkElement::styleSheetIsLoading() const
{
if (m_loading)
return true;
if (!m_sheet)
return false;
return m_sheet->contents().isLoading();
}
void HTMLLinkElement::linkLoaded()
{
dispatchEvent(Event::create(eventNames().loadEvent, false, false));
}
void HTMLLinkElement::linkLoadingErrored()
{
dispatchEvent(Event::create(eventNames().errorEvent, false, false));
}
bool HTMLLinkElement::sheetLoaded()
{
if (!styleSheetIsLoading()) {
removePendingSheet();
return true;
}
return false;
}
void HTMLLinkElement::dispatchPendingLoadEvents()
{
linkLoadEventSender().dispatchPendingEvents();
}
void HTMLLinkElement::dispatchPendingEvent(LinkEventSender* eventSender)
{
ASSERT_UNUSED(eventSender, eventSender == &linkLoadEventSender());
if (m_loadedSheet)
linkLoaded();
else
linkLoadingErrored();
}
void HTMLLinkElement::notifyLoadedSheetAndAllCriticalSubresources(bool errorOccurred)
{
if (m_firedLoad)
return;
m_loadedSheet = !errorOccurred;
linkLoadEventSender().dispatchEventSoon(this);
m_firedLoad = true;
}
void HTMLLinkElement::startLoadingDynamicSheet()
{
ASSERT(m_pendingSheetType < ActiveSheet);
addPendingSheet(ActiveSheet);
}
bool HTMLLinkElement::isURLAttribute(const Attribute& attribute) const
{
return attribute.name().localName() == hrefAttr || HTMLElement::isURLAttribute(attribute);
}
URL HTMLLinkElement::href() const
{
return document().completeURL(getAttribute(hrefAttr));
}
String HTMLLinkElement::rel() const
{
return getAttribute(relAttr);
}
String HTMLLinkElement::target() const
{
return getAttribute(targetAttr);
}
String HTMLLinkElement::type() const
{
return getAttribute(typeAttr);
}
IconType HTMLLinkElement::iconType() const
{
return m_relAttribute.m_iconType;
}
String HTMLLinkElement::iconSizes() const
{
return m_sizes->toString();
}
void HTMLLinkElement::addSubresourceAttributeURLs(ListHashSet<URL>& urls) const
{
HTMLElement::addSubresourceAttributeURLs(urls);
if (m_relAttribute.m_iconType != InvalidIcon)
return;
if (!m_relAttribute.m_isStyleSheet)
return;
addSubresourceURL(urls, href());
if (CSSStyleSheet* styleSheet = const_cast<HTMLLinkElement*>(this)->sheet())
styleSheet->contents().addSubresourceStyleURLs(urls);
}
void HTMLLinkElement::addPendingSheet(PendingSheetType type)
{
if (type <= m_pendingSheetType)
return;
m_pendingSheetType = type;
if (m_pendingSheetType == InactiveSheet)
return;
document().styleSheetCollection().addPendingSheet();
}
void HTMLLinkElement::removePendingSheet(RemovePendingSheetNotificationType notification)
{
PendingSheetType type = m_pendingSheetType;
m_pendingSheetType = Unknown;
if (type == Unknown)
return;
if (type == InactiveSheet) {
document().styleSheetCollection().updateActiveStyleSheets(DocumentStyleSheetCollection::OptimizedUpdate);
return;
}
document().styleSheetCollection().removePendingSheet(
notification == RemovePendingSheetNotifyImmediately
? DocumentStyleSheetCollection::RemovePendingSheetNotifyImmediately
: DocumentStyleSheetCollection::RemovePendingSheetNotifyLater);
}
DOMSettableTokenList* HTMLLinkElement::sizes() const
{
return m_sizes.get();
}
void HTMLLinkElement::setSizes(const String& value)
{
m_sizes->setValue(value);
}
}