Prepare to use invalidation set for adding/removing RuleSets.

third_party/WebKit/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 425 matching lines @@
     // found in the other compound selectors (addFeaturesToInvalidationSets). If
     // we find a feature in the right-most compound selector that requires a
     // subtree recalc, nextCompound will be the rightmost compound and we will
     // addFeaturesToInvalidationSets for that one as well.
 
     InvalidationSetFeatures features;
     InvalidationSetFeatures* siblingFeatures = nullptr;
 
     const CSSSelector* lastInCompound = extractInvalidationSetFeaturesFromCompound(ruleData.selector(), features, Subject);
 
-    if (!features.hasFeatures())
+    if (features.forceSubtree)
+        features.hasFeaturesForRuleSetInvalidation = false;
+    else if (!features.hasFeatures())
         features.forceSubtree = true;
     if (features.hasNthPseudo)
         addFeaturesToInvalidationSet(ensureNthInvalidationSet(), features);
     if (features.hasBeforeOrAfter)
         updateInvalidationSetsForContentAttribute(ruleData);
 
     const CSSSelector* nextCompound = lastInCompound ? lastInCompound->tagHistory() : &ruleData.selector();
-    if (!nextCompound)
+    if (!nextCompound) {
+        if (!features.hasFeaturesForRuleSetInvalidation)
+            m_metadata.needsFullRecalcForRuleSetInvalidation = true;
         return;
+    }
     if (lastInCompound)
         updateFeaturesFromCombinator(*lastInCompound, nullptr, features, siblingFeatures, features);
 
     addFeaturesToInvalidationSets(*nextCompound, siblingFeatures, features);
+
+    if (!features.hasFeaturesForRuleSetInvalidation)
+        m_metadata.needsFullRecalcForRuleSetInvalidation = true;
 }
 
 void RuleFeatureSet::updateInvalidationSetsForContentAttribute(const RuleData& ruleData)
 {
     // If any ::before and ::after rules specify 'content: attr(...)', we
     // need to create invalidation sets for those attributes to have content
     // changes applied through style recalc.
 
     const StylePropertySet& propertySet = ruleData.rule()->properties();
 
@@ skipping 93 matching lines @@
                 features.hasNthPseudo = true;
             else if (position == Subject)
                 invalidationSet->setInvalidatesSelf();
         }
 
         if (extractInvalidationSetFeaturesFromSelectorList(*simpleSelector, features, position) == RequiresSubtreeInvalidation) {
             DCHECK(features.forceSubtree);
             return nullptr;
         }
 
-        if (!simpleSelector->tagHistory() || simpleSelector->relation() != CSSSelector::SubSelector)
+        if (!simpleSelector->tagHistory() || simpleSelector->relation() != CSSSelector::SubSelector) {
+            features.hasFeaturesForRuleSetInvalidation = features.hasTagIdClassOrAttribute();
             return simpleSelector;
+        }
     }
 }
 
 // Add features extracted from the rightmost compound selector to descendant invalidation
 // sets for features found in other compound selectors.
 //
 // We use descendant invalidation for descendants, sibling invalidation for siblings and their subtrees.
 //
 // As we encounter a descendant type of combinator, the features only need to be checked
 // against descendants in the same subtree only. features.adjacent is set to false, and
@@ skipping 25 matching lines @@
 }
 
 
 void RuleFeatureSet::addFeaturesToInvalidationSetsForSelectorList(const CSSSelector& simpleSelector, InvalidationSetFeatures* siblingFeatures, InvalidationSetFeatures& descendantFeatures)
 {
     if (!simpleSelector.selectorList())
         return;
 
     DCHECK(supportsInvalidationWithSelectorList(simpleSelector.getPseudoType()));
 
-    for (const CSSSelector* subSelector = simpleSelector.selectorList()->first(); subSelector; subSelector = CSSSelectorList::next(*subSelector))
+    bool hadFeaturesForRuleSetInvalidation = descendantFeatures.hasFeaturesForRuleSetInvalidation;
+    bool selectorListContainsUniversal = simpleSelector.getPseudoType() == CSSSelector::PseudoNot
+        || simpleSelector.getPseudoType() == CSSSelector::PseudoHostContext;
+
+    for (const CSSSelector* subSelector = simpleSelector.selectorList()->first(); subSelector; subSelector = CSSSelectorList::next(*subSelector)) {
+        descendantFeatures.hasFeaturesForRuleSetInvalidation = false;
+
         addFeaturesToInvalidationSetsForCompoundSelector(*subSelector, siblingFeatures, descendantFeatures);
+
+        if (!descendantFeatures.hasFeaturesForRuleSetInvalidation)
+            selectorListContainsUniversal = true;
+    }
+
+    descendantFeatures.hasFeaturesForRuleSetInvalidation = hadFeaturesForRuleSetInvalidation || !selectorListContainsUniversal;
 }
 
 void RuleFeatureSet::addFeaturesToInvalidationSetsForSimpleSelector(const CSSSelector& simpleSelector, InvalidationSetFeatures* siblingFeatures, InvalidationSetFeatures& descendantFeatures)
 {
     if (InvalidationSet* invalidationSet = invalidationSetForSimpleSelector(simpleSelector, siblingFeatures ? InvalidateSiblings : InvalidateDescendants)) {
         if (!siblingFeatures || invalidationSet == m_nthInvalidationSet) {
             addFeaturesToInvalidationSet(*invalidationSet, descendantFeatures);
             return;
         }
 
@@ skipping 14 matching lines @@
 
     addFeaturesToInvalidationSetsForSelectorList(simpleSelector, siblingFeatures, descendantFeatures);
 }
 
 const CSSSelector* RuleFeatureSet::addFeaturesToInvalidationSetsForCompoundSelector(const CSSSelector& compound, InvalidationSetFeatures* siblingFeatures, InvalidationSetFeatures& descendantFeatures)
 {
     bool compoundHasIdClassOrAttribute = false;
     const CSSSelector* simpleSelector = &compound;
     for (; simpleSelector; simpleSelector = simpleSelector->tagHistory()) {
         addFeaturesToInvalidationSetsForSimpleSelector(*simpleSelector, siblingFeatures, descendantFeatures);
-        if (siblingFeatures)
-            compoundHasIdClassOrAttribute |= simpleSelector->isIdClassOrAttributeSelector();
+        if (simpleSelector->isIdClassOrAttributeSelector())
+            compoundHasIdClassOrAttribute = true;
         if (simpleSelector->relation() != CSSSelector::SubSelector)
             break;
         if (!simpleSelector->tagHistory())
             break;
     }
 
-    if (siblingFeatures && !compoundHasIdClassOrAttribute)
+    if (compoundHasIdClassOrAttribute)
+        descendantFeatures.hasFeaturesForRuleSetInvalidation = true;
+    else if (siblingFeatures)
         addFeaturesToUniversalSiblingInvalidationSet(*siblingFeatures, descendantFeatures);
 
     return simpleSelector;
 }
 
 void RuleFeatureSet::addFeaturesToInvalidationSets(const CSSSelector& selector, InvalidationSetFeatures* siblingFeatures, InvalidationSetFeatures& descendantFeatures)
 {
     // selector is the selector immediately to the left of the rightmost combinator.
     // descendantFeatures has the features of the rightmost compound selector.
 
@@ skipping 92 matching lines @@
         if (!metadata.foundInsertionPointCrossing && current->isAdjacentSelector())
             metadata.foundSiblingSelector = true;
     }
 
     DCHECK(!maxDirectAdjacentSelectors);
     return SelectorMayMatch;
 }
 
 void RuleFeatureSet::FeatureMetadata::add(const FeatureMetadata& other)
 {
-    usesFirstLineRules = usesFirstLineRules || other.usesFirstLineRules;
-    usesWindowInactiveSelector = usesWindowInactiveSelector || other.usesWindowInactiveSelector;
+    usesFirstLineRules |= other.usesFirstLineRules;
+    usesWindowInactiveSelector |= other.usesWindowInactiveSelector;
     maxDirectAdjacentSelectors = std::max(maxDirectAdjacentSelectors, other.maxDirectAdjacentSelectors);
 }
 
 void RuleFeatureSet::FeatureMetadata::clear()
 {
     usesFirstLineRules = false;
     usesWindowInactiveSelector = false;
     foundSiblingSelector = false;
     foundInsertionPointCrossing = false;
+    needsFullRecalcForRuleSetInvalidation = false;
     maxDirectAdjacentSelectors = 0;
 }
 
 void RuleFeatureSet::add(const RuleFeatureSet& other)
 {
     RELEASE_ASSERT(m_isAlive);
     RELEASE_ASSERT(other.m_isAlive);
     RELEASE_ASSERT(&other != this);
     for (const auto& entry : other.m_classInvalidationSets)
         ensureInvalidationSet(m_classInvalidationSets, entry.key, entry.value->type()).combine(*entry.value);
@@ skipping 229 matching lines @@
 
 bool RuleFeatureSet::InvalidationSetFeatures::hasFeatures() const
 {
     return !classes.isEmpty()
         || !attributes.isEmpty()
         || !ids.isEmpty()
         || !tagNames.isEmpty()
         || customPseudoElement;
 }
 
+bool RuleFeatureSet::InvalidationSetFeatures::hasTagIdClassOrAttribute() const
+{
+    return !classes.isEmpty()
+        || !attributes.isEmpty()
+        || !ids.isEmpty()
+        || !tagNames.isEmpty();
+}
+
 } // namespace blink