Use invalidation sets for :hover, :active, and :focus.

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 148 matching lines @@
         features.attributes.append(selector.attribute().localName());
     else if (selector.isCustomPseudoElement())
         features.customPseudoElement = true;
 }
 
 RuleFeatureSet::RuleFeatureSet()
     : m_targetedStyleRecalcEnabled(RuntimeEnabledFeatures::targetedStyleRecalcEnabled())
 {
 }
 
-DescendantInvalidationSet* RuleFeatureSet::invalidationSetForSelector(const CSSSelector& selector)
+DescendantInvalidationSet* RuleFeatureSet::invalidationSetForSelector(const CSSSelector& selector, bool seenCombinator)
 {
     if (selector.m_match == CSSSelector::Class)
         return &ensureClassInvalidationSet(selector.value());
     if (selector.isAttributeSelector())
         return &ensureAttributeInvalidationSet(selector.attribute().localName());
     if (selector.m_match == CSSSelector::Id)
         return &ensureIdInvalidationSet(selector.value());
+    if (seenCombinator && selector.m_match == CSSSelector::PseudoClass) {
+        CSSSelector::PseudoType pseudo = selector.pseudoType();
+        if (pseudo == CSSSelector::PseudoHover || pseudo == CSSSelector::PseudoActive || pseudo == CSSSelector::PseudoFocus)
+            return &ensurePseudoInvalidationSet(pseudo);
+    }
     return 0;
 }
 
 RuleFeatureSet::InvalidationSetMode RuleFeatureSet::updateInvalidationSets(const CSSSelector& selector)
 {
     InvalidationSetMode mode = invalidationSetModeForSelector(selector);
     if (mode != AddFeatures)
         return mode;
 
     InvalidationSetFeatures features;
     const CSSSelector* current = extractInvalidationSetFeatures(selector, features);
     if (current) {
         bool wholeSubtree = current->relation() == CSSSelector::DirectAdjacent || current->relation() == CSSSelector::IndirectAdjacent;
         current = current->tagHistory();
         if (current)
             addFeaturesToInvalidationSets(*current, features, wholeSubtree);
     }
     return AddFeatures;
 }
 
 const CSSSelector* RuleFeatureSet::extractInvalidationSetFeatures(const CSSSelector& selector, InvalidationSetFeatures& features)
 {
     const CSSSelector* lastSelector = &selector;
     for (; lastSelector; lastSelector = lastSelector->tagHistory()) {
         extractInvalidationSetFeature(*lastSelector, features);
         // Initialize the entry in the invalidation set map, if supported.
-        invalidationSetForSelector(*lastSelector);
+        invalidationSetForSelector(*lastSelector, false);
         if (lastSelector->pseudoType() == CSSSelector::PseudoHost || lastSelector->pseudoType() == CSSSelector::PseudoAny) {
             if (const CSSSelectorList* selectorList = lastSelector->selectorList()) {
                 for (const CSSSelector* selector = selectorList->first(); selector; selector = CSSSelectorList::next(*selector))
                     extractInvalidationSetFeatures(*selector, features);
             }
         }
 
         if (lastSelector->relation() != CSSSelector::SubSelector)
             break;
     }
     return lastSelector;
 }
 
 void RuleFeatureSet::addFeaturesToInvalidationSets(const CSSSelector& selector, const InvalidationSetFeatures& features, bool wholeSubtree)
 {
     for (const CSSSelector* current = &selector; current; current = current->tagHistory()) {
-        if (DescendantInvalidationSet* invalidationSet = invalidationSetForSelector(*current)) {
+        if (DescendantInvalidationSet* invalidationSet = invalidationSetForSelector(*current, true)) {
             if (wholeSubtree) {
                 invalidationSet->setWholeSubtreeInvalid();
             } else {
                 if (!features.id.isEmpty())
                     invalidationSet->addId(features.id);
                 if (!features.tagName.isEmpty())
                     invalidationSet->addTagName(features.tagName);
                 for (Vector<AtomicString>::const_iterator it = features.classes.begin(); it != features.classes.end(); ++it)
                     invalidationSet->addClass(*it);
                 for (Vector<AtomicString>::const_iterator it = features.attributes.begin(); it != features.attributes.end(); ++it)
@@ skipping 34 matching lines @@
     invalidationSet.setWholeSubtreeInvalid();
 }
 
 void RuleFeatureSet::collectFeaturesFromRuleData(const RuleData& ruleData)
 {
     FeatureMetadata metadata;
     InvalidationSetMode mode = UseSubtreeStyleChange;
     if (m_targetedStyleRecalcEnabled)
         mode = updateInvalidationSets(ruleData.selector());
 
-    collectFeaturesFromSelector(ruleData.selector(), metadata, mode);
+    collectFeaturesFromSelector(ruleData.selector(), metadata, mode, false);
     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)
 {
@@ skipping 12 matching lines @@
 }
 
 DescendantInvalidationSet& RuleFeatureSet::ensureIdInvalidationSet(const AtomicString& id)
 {
     InvalidationSetMap::AddResult addResult = m_idInvalidationSets.add(id, nullptr);
     if (addResult.isNewEntry)
         addResult.storedValue->value = DescendantInvalidationSet::create();
     return *addResult.storedValue->value;
 }
 
+DescendantInvalidationSet& RuleFeatureSet::ensurePseudoInvalidationSet(CSSSelector::PseudoType pseudoType)
+{
+    PseudoTypeInvalidationSetMap::AddResult addResult = m_pseudoInvalidationSets.add(pseudoType, nullptr);
+    if (addResult.isNewEntry)
+        addResult.storedValue->value = DescendantInvalidationSet::create();
+    return *addResult.storedValue->value;
+}
+
 void RuleFeatureSet::collectFeaturesFromSelector(const CSSSelector& selector)
 {
-    collectFeaturesFromSelector(selector, m_metadata, UseSubtreeStyleChange);
+    collectFeaturesFromSelector(selector, m_metadata, UseSubtreeStyleChange, false);
 }
 
-void RuleFeatureSet::collectFeaturesFromSelector(const CSSSelector& selector, RuleFeatureSet::FeatureMetadata& metadata, InvalidationSetMode mode)
+void RuleFeatureSet::collectFeaturesFromSelector(const CSSSelector& selector, RuleFeatureSet::FeatureMetadata& metadata, InvalidationSetMode mode, bool seenCombinator)
 {
     unsigned maxDirectAdjacentSelectors = 0;
 
     for (const CSSSelector* current = &selector; current; current = current->tagHistory()) {
-        if (mode != AddFeatures && (current->m_match == CSSSelector::Class || current->m_match == CSSSelector::Id || current->isAttributeSelector())) {
-            DescendantInvalidationSet* invalidationSet = invalidationSetForSelector(*current);
-            ASSERT(invalidationSet);
-            if (mode == UseSubtreeStyleChange)
-                invalidationSet->setWholeSubtreeInvalid();
+        if (mode != AddFeatures) {
+            if (DescendantInvalidationSet* invalidationSet = invalidationSetForSelector(*current, seenCombinator)) {
+                if (mode == UseSubtreeStyleChange)
+                    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;
         }
         if (current->isSiblingSelector())
             metadata.foundSiblingSelector = true;
 
-        collectFeaturesFromSelectorList(current->selectorList(), metadata, mode);
+        collectFeaturesFromSelectorList(current->selectorList(), metadata, mode, seenCombinator);
 
-        if (mode == UseLocalStyleChange && current->relation() != CSSSelector::SubSelector)
+        if (mode == UseLocalStyleChange && current->relation() != CSSSelector::SubSelector) {
+            seenCombinator = true;
             mode = UseSubtreeStyleChange;
+        }
     }
 
     ASSERT(!maxDirectAdjacentSelectors);
 }
 
-void RuleFeatureSet::collectFeaturesFromSelectorList(const CSSSelectorList* selectorList, RuleFeatureSet::FeatureMetadata& metadata, InvalidationSetMode mode)
+void RuleFeatureSet::collectFeaturesFromSelectorList(const CSSSelectorList* selectorList, RuleFeatureSet::FeatureMetadata& metadata, InvalidationSetMode mode, bool seenCombinator)
 {
     if (!selectorList)
         return;
 
     for (const CSSSelector* selector = selectorList->first(); selector; selector = CSSSelectorList::next(*selector))
-        collectFeaturesFromSelector(*selector, metadata, mode);
+        collectFeaturesFromSelector(*selector, metadata, mode, seenCombinator);
 }
 
 void RuleFeatureSet::FeatureMetadata::add(const FeatureMetadata& other)
 {
     usesFirstLineRules = usesFirstLineRules || other.usesFirstLineRules;
     maxDirectAdjacentSelectors = std::max(maxDirectAdjacentSelectors, other.maxDirectAdjacentSelectors);
 }
 
 void RuleFeatureSet::FeatureMetadata::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)
         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);
     for (InvalidationSetMap::const_iterator it = other.m_idInvalidationSets.begin(); it != other.m_idInvalidationSets.end(); ++it)
         ensureIdInvalidationSet(it->key).combine(*it->value);
+    for (PseudoTypeInvalidationSetMap::const_iterator it = other.m_pseudoInvalidationSets.begin(); it != other.m_pseudoInvalidationSets.end(); ++it)
+        ensurePseudoInvalidationSet(static_cast<CSSSelector::PseudoType>(it->key)).combine(*it->value);

[esprehn, 2014/04/11 20:23:01]

Why do you need the cast?

[rune, 2014/04/11 22:34:36]

It's because of the use of IntHash:

  typedef HashMap<CSSSelector::PseudoType, RefPtr<DescendantInvalidationSet>,
WTF::IntHash<unsigned>, WTF::UnsignedWithZeroKeyHashTraits<unsigned> >
PseudoTypeInvalidationSetMap;

If I change to:

    typedef HashMap<CSSSelector::PseudoType, RefPtr<DescendantInvalidationSet> >
PseudoTypeInvalidationSetMap;

and add:


  namespace WTF {

  template<> struct DefaultHash<WebCore::CSSSelector::PseudoType> {
      typedef IntHash<unsigned> Hash;
  };

  template<> struct HashTraits<WebCore::CSSSelector::PseudoType> :
GenericHashTraits<WebCore::CSSSelector::PseudoType> {
      static const bool emptyValueIsZero = false;
      static const bool needsDestruction = false;
      static WebCore::CSSSelector::PseudoType emptyValue() { return
static_cast<WebCore::CSSSelector::PseudoType>(std::numeric_limits<unsigned>::max());
}
      static void constructDeletedValue(WebCore::CSSSelector::PseudoType& slot)
{ slot =
static_cast<WebCore::CSSSelector::PseudoType>(std::numeric_limits<unsigned>::max()
- 1); }
      static bool isDeletedValue(WebCore::CSSSelector::PseudoType value) {
return value == std::numeric_limits<unsigned>::max() - 1; }
  };

  } // namespace WTF


it works without the cast.

Please enlighten me if there is a simpler way.

 
     m_metadata.add(other.m_metadata);
 
     siblingRules.appendVector(other.siblingRules);
     uncommonAttributeRules.appendVector(other.uncommonAttributeRules);
 }
 
 void RuleFeatureSet::clear()
 {
     siblingRules.clear();
@@ skipping 60 matching lines @@
     if (!oldId.isEmpty()) {
         if (RefPtr<DescendantInvalidationSet> invalidationSet = m_idInvalidationSets.get(oldId))
             m_styleInvalidator.scheduleInvalidation(invalidationSet, element);
     }
     if (!newId.isEmpty()) {
         if (RefPtr<DescendantInvalidationSet> invalidationSet = m_idInvalidationSets.get(newId))
             m_styleInvalidator.scheduleInvalidation(invalidationSet, element);
     }
 }
 
+void RuleFeatureSet::scheduleStyleInvalidationForPseudoChange(CSSSelector::PseudoType pseudo, Element& element)
+{
+    if (RefPtr<DescendantInvalidationSet> invalidationSet = m_pseudoInvalidationSets.get(pseudo))
+        m_styleInvalidator.scheduleInvalidation(invalidationSet, element);
+}
+
 void RuleFeatureSet::addClassToInvalidationSet(const AtomicString& className, Element& element)
 {
     if (RefPtr<DescendantInvalidationSet> invalidationSet = m_classInvalidationSets.get(className))
         m_styleInvalidator.scheduleInvalidation(invalidationSet, element);
 }
 
 StyleInvalidator& RuleFeatureSet::styleInvalidator()
 {
     return m_styleInvalidator;
 }
 
 } // namespace WebCore