HTMLStyleElement.cpp [plain text]
#include "config.h"
#include "HTMLStyleElement.h"
#include "Attribute.h"
#include "ContextFeatures.h"
#include "Document.h"
#include "Event.h"
#include "EventSender.h"
#include "HTMLNames.h"
#include "MediaList.h"
#include "ScriptEventListener.h"
#include "ScriptableDocumentParser.h"
#include "ShadowRoot.h"
#include "StyleSheetContents.h"
namespace WebCore {
using namespace HTMLNames;
static StyleEventSender& styleLoadEventSender()
{
DEFINE_STATIC_LOCAL(StyleEventSender, sharedLoadEventSender, (eventNames().loadEvent));
return sharedLoadEventSender;
}
inline HTMLStyleElement::HTMLStyleElement(const QualifiedName& tagName, Document* document, bool createdByParser)
: HTMLElement(tagName, document)
, StyleElement(document, createdByParser)
, m_firedLoad(false)
, m_loadedSheet(false)
, m_scopedStyleRegistrationState(NotRegistered)
{
ASSERT(hasTagName(styleTag));
}
HTMLStyleElement::~HTMLStyleElement()
{
StyleElement::clearDocumentData(document(), this);
styleLoadEventSender().cancelEvent(this);
}
PassRefPtr<HTMLStyleElement> HTMLStyleElement::create(const QualifiedName& tagName, Document* document, bool createdByParser)
{
return adoptRef(new HTMLStyleElement(tagName, document, createdByParser));
}
void HTMLStyleElement::parseAttribute(const QualifiedName& name, const AtomicString& value)
{
if (name == titleAttr && m_sheet)
m_sheet->setTitle(value);
else if (name == scopedAttr && ContextFeatures::styleScopedEnabled(document()))
scopedAttributeChanged(!value.isNull());
else if (name == mediaAttr && inDocument() && document()->renderer() && m_sheet) {
m_sheet->setMediaQueries(MediaQuerySet::createAllowingDescriptionSyntax(value));
document()->styleResolverChanged(RecalcStyleImmediately);
} else
HTMLElement::parseAttribute(name, value);
}
void HTMLStyleElement::scopedAttributeChanged(bool scoped)
{
ASSERT(ContextFeatures::styleScopedEnabled(document()));
if (!inDocument())
return;
if (scoped) {
if (m_scopedStyleRegistrationState == RegisteredInShadowRoot)
unregisterWithScopingNode(containingShadowRoot());
if (m_scopedStyleRegistrationState != RegisteredAsScoped)
registerWithScopingNode(true);
return;
}
if (m_scopedStyleRegistrationState == RegisteredAsScoped)
unregisterWithScopingNode(parentNode());
if (isInShadowTree() && m_scopedStyleRegistrationState != RegisteredInShadowRoot)
registerWithScopingNode(false);
}
void HTMLStyleElement::finishParsingChildren()
{
StyleElement::finishParsingChildren(this);
HTMLElement::finishParsingChildren();
}
void HTMLStyleElement::registerWithScopingNode(bool scoped)
{
ASSERT(m_scopedStyleRegistrationState == NotRegistered);
ASSERT(inDocument());
if (m_scopedStyleRegistrationState != NotRegistered)
return;
ContainerNode* scope = scoped ? parentNode() : containingShadowRoot();
if (!scope)
return;
if (!scope->isElementNode() && !scope->isShadowRoot()) {
ASSERT_NOT_REACHED();
return;
}
scope->registerScopedHTMLStyleChild();
if (scope->isShadowRoot())
scope->shadowHost()->setNeedsStyleRecalc();
else
scope->setNeedsStyleRecalc();
if (inDocument() && !document()->parsing() && document()->renderer())
document()->styleResolverChanged(DeferRecalcStyle);
m_scopedStyleRegistrationState = scoped ? RegisteredAsScoped : RegisteredInShadowRoot;
}
void HTMLStyleElement::unregisterWithScopingNode(ContainerNode* scope)
{
ASSERT(m_scopedStyleRegistrationState != NotRegistered || !ContextFeatures::styleScopedEnabled(document()));
if (!isRegisteredAsScoped())
return;
ASSERT(scope);
if (scope) {
ASSERT(scope->hasScopedHTMLStyleChild());
scope->unregisterScopedHTMLStyleChild();
scope->setNeedsStyleRecalc();
}
if (inDocument() && !document()->parsing() && document()->renderer())
document()->styleResolverChanged(DeferRecalcStyle);
m_scopedStyleRegistrationState = NotRegistered;
}
Node::InsertionNotificationRequest HTMLStyleElement::insertedInto(ContainerNode* insertionPoint)
{
HTMLElement::insertedInto(insertionPoint);
if (insertionPoint->inDocument()) {
StyleElement::insertedIntoDocument(document(), this);
if (m_scopedStyleRegistrationState == NotRegistered && (scoped() || isInShadowTree()))
registerWithScopingNode(scoped());
}
return InsertionDone;
}
void HTMLStyleElement::removedFrom(ContainerNode* insertionPoint)
{
HTMLElement::removedFrom(insertionPoint);
if (m_scopedStyleRegistrationState != NotRegistered) {
ContainerNode* scope;
if (m_scopedStyleRegistrationState == RegisteredInShadowRoot) {
scope = containingShadowRoot();
if (!scope)
scope = insertionPoint->containingShadowRoot();
} else
scope = parentNode() ? parentNode() : insertionPoint;
unregisterWithScopingNode(scope);
}
if (insertionPoint->inDocument())
StyleElement::removedFromDocument(document(), this);
}
void HTMLStyleElement::childrenChanged(bool changedByParser, Node* beforeChange, Node* afterChange, int childCountDelta)
{
HTMLElement::childrenChanged(changedByParser, beforeChange, afterChange, childCountDelta);
StyleElement::childrenChanged(this);
}
const AtomicString& HTMLStyleElement::media() const
{
return getAttribute(mediaAttr);
}
const AtomicString& HTMLStyleElement::type() const
{
return getAttribute(typeAttr);
}
bool HTMLStyleElement::scoped() const
{
return fastHasAttribute(scopedAttr) && ContextFeatures::styleScopedEnabled(document());
}
void HTMLStyleElement::setScoped(bool scopedValue)
{
setBooleanAttribute(scopedAttr, scopedValue);
}
Element* HTMLStyleElement::scopingElement() const
{
if (!scoped())
return 0;
ContainerNode* parentOrShadowHost = parentOrShadowHostNode();
if (!parentOrShadowHost || !parentOrShadowHost->isElementNode())
return 0;
return toElement(parentOrShadowHost);
}
void HTMLStyleElement::dispatchPendingLoadEvents()
{
styleLoadEventSender().dispatchPendingEvents();
}
void HTMLStyleElement::dispatchPendingEvent(StyleEventSender* eventSender)
{
ASSERT_UNUSED(eventSender, eventSender == &styleLoadEventSender());
if (m_loadedSheet)
dispatchEvent(Event::create(eventNames().loadEvent, false, false));
else
dispatchEvent(Event::create(eventNames().errorEvent, false, false));
}
void HTMLStyleElement::notifyLoadedSheetAndAllCriticalSubresources(bool errorOccurred)
{
if (m_firedLoad)
return;
m_loadedSheet = !errorOccurred;
styleLoadEventSender().dispatchEventSoon(this);
m_firedLoad = true;
}
void HTMLStyleElement::addSubresourceAttributeURLs(ListHashSet<KURL>& urls) const
{
HTMLElement::addSubresourceAttributeURLs(urls);
if (CSSStyleSheet* styleSheet = const_cast<HTMLStyleElement*>(this)->sheet())
styleSheet->contents()->addSubresourceStyleURLs(urls);
}
bool HTMLStyleElement::disabled() const
{
if (!m_sheet)
return false;
return m_sheet->disabled();
}
void HTMLStyleElement::setDisabled(bool setDisabled)
{
if (CSSStyleSheet* styleSheet = sheet())
styleSheet->setDisabled(setDisabled);
}
}