Add support for attribute selectors in TargetedStyleRecalc.

Source/core/css/RuleFeature.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 2004-2005 Allan Sandfeld Jensen (kde@carewolf.com)
  * Copyright (C) 2006, 2007 Nicholas Shanks (webkit@nickshanks.com)
  * Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012 Apple Inc. All rights reserved.
  * Copyright (C) 2007 Alexey Proskuryakov <ap@webkit.org>
  * Copyright (C) 2007, 2008 Eric Seidel <eric@webkit.org>
  * Copyright (C) 2008, 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
  * Copyright (c) 2011, Code Aurora Forum. All rights reserved.
  * Copyright (C) Research In Motion Limited 2011. All rights reserved.
@@ skipping 16 matching lines @@
  */
 
 #include "config.h"
 #include "core/css/RuleFeature.h"
 
 #include "HTMLNames.h"
 #include "RuntimeEnabledFeatures.h"
 #include "core/css/CSSSelector.h"
 #include "core/css/CSSSelectorList.h"
 #include "core/css/RuleSet.h"
-#include "core/css/invalidation/StyleInvalidator.h"
-#include "core/dom/Document.h"
 #include "core/dom/Element.h"
-#include "core/dom/ElementTraversal.h"
 #include "core/dom/Node.h"
-#include "core/dom/NodeRenderStyle.h"
-#include "core/dom/shadow/ElementShadow.h"
-#include "core/dom/shadow/ShadowRoot.h"
-#include "core/rendering/RenderObject.h"
 #include "wtf/BitVector.h"
 
 namespace WebCore {
 
 static bool isSkippableComponentForInvalidation(const CSSSelector& selector)
 {
     if (selector.m_match == CSSSelector::Tag
         || selector.m_match == CSSSelector::Id
         || selector.isAttributeSelector())
         return true;
@@ skipping 53 matching lines @@
 }
 
 // This method is somewhat conservative in what it accepts.
 RuleFeatureSet::InvalidationSetMode RuleFeatureSet::supportsClassDescendantInvalidation(const CSSSelector& selector)
 {
     bool foundDescendantRelation = false;
     bool foundIdent = false;
     for (const CSSSelector* component = &selector; component; component = component->tagHistory()) {
 
         // FIXME: next up: Tag and Id.
-        if (component->m_match == CSSSelector::Class) {
+        if (component->m_match == CSSSelector::Class || component->isAttributeSelector()) {
             if (!foundDescendantRelation)
                 foundIdent = true;
         } else if (!isSkippableComponentForInvalidation(*component)) {
             return foundDescendantRelation ? UseLocalStyleChange : UseSubtreeStyleChange;
         }
         switch (component->relation()) {
         case CSSSelector::Descendant:
         case CSSSelector::Child:
         case CSSSelector::Shadow:
         case CSSSelector::ShadowDeep:
             foundDescendantRelation = true;
             // Fall through!
         case CSSSelector::SubSelector:
             continue;
         default:
             return UseLocalStyleChange;
         }
     }
     return foundIdent ? AddFeatures : UseLocalStyleChange;
 }
 
-void extractClassIdOrTag(const CSSSelector& selector, Vector<AtomicString>& classes, AtomicString& id, AtomicString& tagName)
+void extractClassIdTagOrAttribute(const CSSSelector& selector, Vector<AtomicString>& classes, AtomicString& id, AtomicString& tagName, Vector<AtomicString>& attributes)
 {
     if (selector.m_match == CSSSelector::Tag)
         tagName = selector.tagQName().localName();
     else if (selector.m_match == CSSSelector::Id)
         id = selector.value();
     else if (selector.m_match == CSSSelector::Class)
         classes.append(selector.value());
+    else if (selector.isAttributeSelector())
+        attributes.append(selector.attribute().localName());
 }
 
 RuleFeatureSet::RuleFeatureSet()
     : m_targetedStyleRecalcEnabled(RuntimeEnabledFeatures::targetedStyleRecalcEnabled())
 {
 }
 
-RuleFeatureSet::InvalidationSetMode RuleFeatureSet::updateClassInvalidationSets(const CSSSelector& selector)
+DescendantInvalidationSet* RuleFeatureSet::invalidationSetForSelector(const CSSSelector& selector)
+{
+    if (selector.m_match == CSSSelector::Class)
+        return &ensureClassInvalidationSet(selector.value());
+    if (selector.isAttributeSelector())
+        return &ensureAttributeInvalidationSet(selector.attribute().localName());
+    return 0;
+}
+
+RuleFeatureSet::InvalidationSetMode RuleFeatureSet::updateInvalidationSets(const CSSSelector& selector)
 {
     InvalidationSetMode mode = supportsClassDescendantInvalidation(selector);
     if (mode != AddFeatures)
         return mode;
 
     Vector<AtomicString> classes;
     AtomicString id;
     AtomicString tagName;
+    Vector<AtomicString> attributes;
 
     const CSSSelector* lastSelector = &selector;
     for (; lastSelector; lastSelector = lastSelector->tagHistory()) {
-        extractClassIdOrTag(*lastSelector, classes, id, tagName);
-        if (lastSelector->m_match == CSSSelector::Class)
-            ensureClassInvalidationSet(lastSelector->value());
+        extractClassIdTagOrAttribute(*lastSelector, classes, id, tagName, attributes);
+        // Initialize the entry in the invalidation set map, if supported.
+        invalidationSetForSelector(*lastSelector);
+
         if (lastSelector->relation() != CSSSelector::SubSelector)
             break;
     }
 
     if (!lastSelector)
         return AddFeatures;
-
     for (const CSSSelector* current = lastSelector->tagHistory(); current; current = current->tagHistory()) {
-        if (current->m_match == CSSSelector::Class) {
-            DescendantInvalidationSet& invalidationSet = ensureClassInvalidationSet(current->value());
+        if (DescendantInvalidationSet* invalidationSet = invalidationSetForSelector(*current)) {
             if (!id.isEmpty())
-                invalidationSet.addId(id);
+                invalidationSet->addId(id);
             if (!tagName.isEmpty())
-                invalidationSet.addTagName(tagName);
-            for (Vector<AtomicString>::const_iterator it = classes.begin(); it != classes.end(); ++it) {
-                invalidationSet.addClass(*it);
-            }
+                invalidationSet->addTagName(tagName);
+            for (Vector<AtomicString>::const_iterator it = classes.begin(); it != classes.end(); ++it)
+                invalidationSet->addClass(*it);
+            for (Vector<AtomicString>::const_iterator it = attributes.begin(); it != attributes.end(); ++it)
+                invalidationSet->addAttribute(*it);
         }
     }
     return AddFeatures;
 }
 
-void RuleFeatureSet::addAttributeInASelector(const AtomicString& attributeName)
+void RuleFeatureSet::addContentAttr(const AtomicString& attributeName)
 {
-    m_metadata.attrsInRules.add(attributeName);
+    DescendantInvalidationSet& invalidationSet = ensureAttributeInvalidationSet(attributeName);
+    invalidationSet.setWholeSubtreeInvalid();
 }
 
 void RuleFeatureSet::collectFeaturesFromRuleData(const RuleData& ruleData)
 {
     FeatureMetadata metadata;
     InvalidationSetMode mode = UseSubtreeStyleChange;
     if (m_targetedStyleRecalcEnabled)
-        mode = updateClassInvalidationSets(ruleData.selector());
+        mode = updateInvalidationSets(ruleData.selector());
 
     collectFeaturesFromSelector(ruleData.selector(), metadata, mode);
     m_metadata.add(metadata);
 
     if (metadata.foundSiblingSelector)
         siblingRules.append(RuleFeature(ruleData.rule(), ruleData.selectorIndex(), ruleData.hasDocumentSecurityOrigin()));
     if (ruleData.containsUncommonAttributeSelector())
         uncommonAttributeRules.append(RuleFeature(ruleData.rule(), ruleData.selectorIndex(), ruleData.hasDocumentSecurityOrigin()));
 }
 
 DescendantInvalidationSet& RuleFeatureSet::ensureClassInvalidationSet(const AtomicString& className)
 {
     InvalidationSetMap::AddResult addResult = m_classInvalidationSets.add(className, nullptr);
     if (addResult.isNewEntry)
         addResult.storedValue->value = DescendantInvalidationSet::create();
     return *addResult.storedValue->value;
 }
 
+DescendantInvalidationSet& RuleFeatureSet::ensureAttributeInvalidationSet(const AtomicString& attributeName)
+{
+    InvalidationSetMap::AddResult addResult = m_attributeInvalidationSets.add(attributeName, nullptr);
+    if (addResult.isNewEntry)
+        addResult.storedValue->value = DescendantInvalidationSet::create();
+    return *addResult.storedValue->value;
+}
 void RuleFeatureSet::collectFeaturesFromSelector(const CSSSelector& selector)
 {
     collectFeaturesFromSelector(selector, m_metadata, UseSubtreeStyleChange);
 }
 
 void RuleFeatureSet::collectFeaturesFromSelector(const CSSSelector& selector, RuleFeatureSet::FeatureMetadata& metadata, InvalidationSetMode mode)
 {
     unsigned maxDirectAdjacentSelectors = 0;
 
     for (const CSSSelector* current = &selector; current; current = current->tagHistory()) {
         if (current->m_match == CSSSelector::Id) {
             metadata.idsInRules.add(current->value());
-        } else if (current->m_match == CSSSelector::Class && mode != AddFeatures) {
-            DescendantInvalidationSet& invalidationSet = ensureClassInvalidationSet(current->value());
+        } else if (mode != AddFeatures && (current->m_match == CSSSelector::Class || current->isAttributeSelector())) {
+            DescendantInvalidationSet* invalidationSet = invalidationSetForSelector(*current);
+            ASSERT(invalidationSet);
             if (mode == UseSubtreeStyleChange)
-                invalidationSet.setWholeSubtreeInvalid();
-        } else if (current->isAttributeSelector()) {
-            metadata.attrsInRules.add(current->attribute().localName());
+                invalidationSet->setWholeSubtreeInvalid();
         }
         if (current->pseudoType() == CSSSelector::PseudoFirstLine)
             metadata.usesFirstLineRules = true;
         if (current->isDirectAdjacentSelector()) {
             maxDirectAdjacentSelectors++;
         } else if (maxDirectAdjacentSelectors) {
             if (maxDirectAdjacentSelectors > metadata.maxDirectAdjacentSelectors)
                 metadata.maxDirectAdjacentSelectors = maxDirectAdjacentSelectors;
             maxDirectAdjacentSelectors = 0;
         }
@@ skipping 19 matching lines @@
 }
 
 void RuleFeatureSet::FeatureMetadata::add(const FeatureMetadata& other)
 {
     usesFirstLineRules = usesFirstLineRules || other.usesFirstLineRules;
     maxDirectAdjacentSelectors = std::max(maxDirectAdjacentSelectors, other.maxDirectAdjacentSelectors);
 
     HashSet<AtomicString>::const_iterator end = other.idsInRules.end();
     for (HashSet<AtomicString>::const_iterator it = other.idsInRules.begin(); it != end; ++it)
         idsInRules.add(*it);
-    end = other.attrsInRules.end();
-    for (HashSet<AtomicString>::const_iterator it = other.attrsInRules.begin(); it != end; ++it)
-        attrsInRules.add(*it);
 }
 
 void RuleFeatureSet::FeatureMetadata::clear()
 {
     idsInRules.clear();
-    attrsInRules.clear();
     usesFirstLineRules = false;
     foundSiblingSelector = false;
     maxDirectAdjacentSelectors = 0;
 }
 
 void RuleFeatureSet::add(const RuleFeatureSet& other)
 {
-    for (InvalidationSetMap::const_iterator it = other.m_classInvalidationSets.begin(); it != other.m_classInvalidationSets.end(); ++it) {
+    for (InvalidationSetMap::const_iterator it = other.m_classInvalidationSets.begin(); it != other.m_classInvalidationSets.end(); ++it)
         ensureClassInvalidationSet(it->key).combine(*it->value);
-    }
+    for (InvalidationSetMap::const_iterator it = other.m_attributeInvalidationSets.begin(); it != other.m_attributeInvalidationSets.end(); ++it)
+        ensureAttributeInvalidationSet(it->key).combine(*it->value);
 
     m_metadata.add(other.m_metadata);
 
     siblingRules.appendVector(other.siblingRules);
     uncommonAttributeRules.appendVector(other.uncommonAttributeRules);
 }
 
 void RuleFeatureSet::clear()
 {
     siblingRules.clear();
     uncommonAttributeRules.clear();
     m_metadata.clear();
     m_classInvalidationSets.clear();
+    m_attributeInvalidationSets.clear();
     m_pendingInvalidationMap.clear();
 }
 
 void RuleFeatureSet::scheduleStyleInvalidationForClassChange(const SpaceSplitString& changedClasses, Element* element)
 {
     unsigned changedSize = changedClasses.size();
     for (unsigned i = 0; i < changedSize; ++i) {
         addClassToInvalidationSet(changedClasses[i], element);
     }
 }
@@ skipping 24 matching lines @@
     }
 
     for (unsigned i = 0; i < oldClasses.size(); ++i) {
         if (remainingClassBits.quickGet(i))
             continue;
         // Class was removed.
         addClassToInvalidationSet(oldClasses[i], element);
     }
 }
 
+void RuleFeatureSet::scheduleStyleInvalidationForAttributeChange(const QualifiedName& attributeName, Element* element)
+{
+    if (RefPtr<DescendantInvalidationSet> invalidationSet = m_attributeInvalidationSets.get(attributeName.localName())) {
+        ensurePendingInvalidationList(element).append(invalidationSet);
+        element->setNeedsStyleInvalidation();
+    }
+}
+
 void RuleFeatureSet::addClassToInvalidationSet(const AtomicString& className, Element* element)
 {
     if (RefPtr<DescendantInvalidationSet> invalidationSet = m_classInvalidationSets.get(className)) {
         ensurePendingInvalidationList(element).append(invalidationSet);
         element->setNeedsStyleInvalidation();
     }
 }
 
 RuleFeatureSet::InvalidationList& RuleFeatureSet::ensurePendingInvalidationList(Element* element)
 {
@@ skipping 10 matching lines @@
     if (node->isElementNode())
         m_pendingInvalidationMap.remove(toElement(node));
 }
 
 RuleFeatureSet::PendingInvalidationMap& RuleFeatureSet::pendingInvalidationMap()
 {
     return m_pendingInvalidationMap;
 }
 
 } // namespace WebCore