Revert of Remove scoped styles.

Source/core/html/HTMLStyleElement.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2001 Dirk Mueller (mueller@kde.org)
  * Copyright (C) 2003, 2010 Apple Inc. All rights reserved.
  *           (C) 2007 Rob Buis (buis@kde.org)
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
@@ skipping 31 matching lines @@
 {
     DEFINE_STATIC_LOCAL(StyleEventSender, sharedLoadEventSender, (EventTypeNames::load));
     return sharedLoadEventSender;
 }
 
 inline HTMLStyleElement::HTMLStyleElement(Document& document, bool createdByParser)
     : HTMLElement(styleTag, document)
     , StyleElement(&document, createdByParser)
     , m_firedLoad(false)
     , m_loadedSheet(false)
+    , m_scopedStyleRegistrationState(NotRegistered)
 {
     ScriptWrappable::init(this);
 }
 
 HTMLStyleElement::~HTMLStyleElement()
 {
+    // During tear-down, willRemove isn't called, so m_scopedStyleRegistrationState may still be RegisteredAsScoped or RegisteredInShadowRoot here.
+    // Therefore we can't ASSERT(m_scopedStyleRegistrationState == NotRegistered).
 #if !ENABLE(OILPAN)
     StyleElement::clearDocumentData(document(), this);
 #endif
 
     styleLoadEventSender().cancelEvent(this);
 }
 
 PassRefPtrWillBeRawPtr<HTMLStyleElement> HTMLStyleElement::create(Document& document, bool createdByParser)
 {
     return adoptRefWillBeRefCountedGarbageCollected(new HTMLStyleElement(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().isActive() && m_sheet) {
         m_sheet->setMediaQueries(MediaQuerySet::create(value));
         document().modifiedStyleSheet(m_sheet.get());
     } else {
         HTMLElement::parseAttribute(name, value);
     }
 }
 
+void HTMLStyleElement::scopedAttributeChanged(bool scoped)
+{
+    ASSERT(ContextFeatures::styleScopedEnabled(&document()));
+
+    if (!inDocument())
+        return;
+
+    if (scoped) {
+        if (m_scopedStyleRegistrationState == RegisteredAsScoped)
+            return;
+
+        // As any <style> in a shadow tree is treated as "scoped",
+        // need to remove the <style> from its shadow root.
+        ContainerNode* scopingNode = 0;
+        if (m_scopedStyleRegistrationState == RegisteredInShadowRoot) {
+            scopingNode = containingShadowRoot();
+            unregisterWithScopingNode(scopingNode);
+        }
+        document().styleEngine()->removeStyleSheetCandidateNode(this, scopingNode, treeScope());
+        registerWithScopingNode(true);
+
+        document().styleEngine()->addStyleSheetCandidateNode(this, false);
+        document().modifiedStyleSheet(sheet());
+        return;
+    }
+
+    // If the <style> was scoped, need to remove the <style> from the scoping
+    // element, i.e. the parent node.
+    if (m_scopedStyleRegistrationState != RegisteredAsScoped)
+        return;
+
+    unregisterWithScopingNode(parentNode());
+    document().styleEngine()->removeStyleSheetCandidateNode(this, parentNode(), treeScope());
+
+    // As any <style> in a shadow tree is treated as "scoped",
+    // need to add the <style> to its shadow root.
+    if (isInShadowTree())
+        registerWithScopingNode(false);
+
+    document().styleEngine()->addStyleSheetCandidateNode(this, false);
+    // FIXME: currently need to use FullStyleUpdate here.
+    // Because ShadowTreeStyleSheetCollection doesn't know old scoping node.
+    // So setNeedsStyleRecalc for old scoping node is not invoked.
+    document().modifiedStyleSheet(sheet());
+}
+
 void HTMLStyleElement::finishParsingChildren()
 {
     StyleElement::finishParsingChildren(this);
     HTMLElement::finishParsingChildren();
 }
 
+void HTMLStyleElement::registerWithScopingNode(bool scoped)
+{
+    // Note: We cannot rely on the 'scoped' element already being present when this method is invoked.
+    // Therefore we cannot rely on 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()) {
+        // DocumentFragment nodes should never be inDocument,
+        // <style> should not be a child of Document, PI or some such.
+        ASSERT_NOT_REACHED();
+        return;
+    }
+    scope->registerScopedHTMLStyleChild();
+    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();
+    }
+
+    m_scopedStyleRegistrationState = NotRegistered;
+}
+
 Node::InsertionNotificationRequest HTMLStyleElement::insertedInto(ContainerNode* insertionPoint)
 {
     HTMLElement::insertedInto(insertionPoint);
-    if (insertionPoint->inDocument() && isInShadowTree()) {
-        if (ShadowRoot* scope = containingShadowRoot())
-            scope->registerScopedHTMLStyleChild();
+    if (insertionPoint->inDocument()) {
+        if (m_scopedStyleRegistrationState == NotRegistered && (scoped() || isInShadowTree()))
+            registerWithScopingNode(scoped());
     }
     return InsertionShouldCallDidNotifySubtreeInsertions;
 }
 
 void HTMLStyleElement::removedFrom(ContainerNode* insertionPoint)
 {
     HTMLElement::removedFrom(insertionPoint);
 
-    ShadowRoot* scopingNode = containingShadowRoot();
-    if (!scopingNode)
-        scopingNode = insertionPoint->containingShadowRoot();
+    // In the current implementation, <style scoped> is only registered if the node is in the document.
+    // That is, because willRemove() is also called if an ancestor is removed from the document.
+    // Now, if we want to register <style scoped> even if it's not inDocument,
+    // we'd need to find a way to discern whether that is the case, or whether <style scoped> itself is about to be removed.
+    ContainerNode* scopingNode = 0;
+    if (m_scopedStyleRegistrationState != NotRegistered) {
+        if (m_scopedStyleRegistrationState == RegisteredInShadowRoot) {
+            scopingNode = containingShadowRoot();
+            if (!scopingNode)
+                scopingNode = insertionPoint->containingShadowRoot();
+        } else {
+            scopingNode = parentNode() ? parentNode() : insertionPoint;
+        }
 
-    if (scopingNode)
-        scopingNode->unregisterScopedHTMLStyleChild();
+        unregisterWithScopingNode(scopingNode);
+    }
 
-    if (!insertionPoint->inDocument())
-        return;
-
-    TreeScope* containingScope = containingShadowRoot();
-    StyleElement::removedFromDocument(document(), this, scopingNode, containingScope ? *containingScope : insertionPoint->treeScope());
+    if (insertionPoint->inDocument()) {
+        TreeScope* containingScope = containingShadowRoot();
+        StyleElement::removedFromDocument(document(), this, scopingNode, containingScope ? *containingScope : insertionPoint->treeScope());
+    }
 }
 
 void HTMLStyleElement::didNotifySubtreeInsertionsToDocument()
 {
     StyleElement::processStyleSheet(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);
+}
+
 ContainerNode* HTMLStyleElement::scopingNode()
 {
     if (!inDocument())
         return 0;
 
-    if (isInShadowTree())
+    if (!isRegisteredAsScoped())
+        return &document();
+
+    if (isRegisteredInShadowRoot())
         return containingShadowRoot();
 
-    return &document();
+    return parentNode();
 }
 
 void HTMLStyleElement::dispatchPendingLoadEvents()
 {
     styleLoadEventSender().dispatchPendingEvents();
 }
 
 void HTMLStyleElement::dispatchPendingEvent(StyleEventSender* eventSender)
 {
     ASSERT_UNUSED(eventSender, eventSender == &styleLoadEventSender());
@@ skipping 23 matching lines @@
         styleSheet->setDisabled(setDisabled);
 }
 
 void HTMLStyleElement::trace(Visitor* visitor)
 {
     StyleElement::trace(visitor);
     HTMLElement::trace(visitor);
 }
 
 }