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 314 matching lines @@
         lastCompoundInAdjacentChainFeatures = InvalidationSetFeatures();
 
     siblingFeatures = nullptr;
 
     if (lastInCompound.isShadowSelector())
         descendantFeatures.treeBoundaryCrossing = true;
     if (lastInCompound.relation() == CSSSelector::ShadowSlot || lastInCompound.relationIsAffectedByPseudoContent())
         descendantFeatures.insertionPointCrossing = true;
     if (lastInCompound.relationIsAffectedByPseudoContent())
         descendantFeatures.contentPseudoCrossing = true;
+    if (lastInCompound.relationIsAffectedByPseudoContent() || lastInCompound.isShadowSelector())
+        descendantFeatures.hasInvalidationSetFeaturesInScope = false;
 }
 
 void RuleFeatureSet::extractInvalidationSetFeaturesFromSimpleSelector(const CSSSelector& selector, InvalidationSetFeatures& features)
 {
     if (selector.match() == CSSSelector::Tag && selector.tagQName().localName() != starAtom) {
         features.tagNames.append(selector.tagQName().localName());
         return;
     }
     if (selector.match() == CSSSelector::Id) {
         features.ids.append(selector.value());
@@ skipping 89 matching lines @@
     // rightmost compound selector (extractInvalidationSetFeaturesFromCompound).
     // Secondly, add those features to the invalidation sets for the features
     // 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;
     const CSSSelector* nextCompound = extractInvalidationSetFeaturesFromCompound(ruleData.selector(), features, Subject);
 
-    if (!features.hasFeatures())
+    if (features.forceSubtree)
+        features.hasInvalidationSetFeaturesInScope = false;
+    else if (!features.hasFeatures())
         features.forceSubtree = true;
 
     if (nextCompound)
         addFeaturesToInvalidationSets(*nextCompound, features);
     else if (features.hasNthPseudo)
         addFeaturesToInvalidationSet(ensureNthInvalidationSet(), features);
 
     if (features.hasBeforeOrAfter)
         updateInvalidationSetsForContentAttribute(ruleData);
+
+    if (!features.hasInvalidationSetFeaturesInScope)
+        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 99 matching lines @@
             continue;
 
         if (position == Subject) {
             if (features.hasNthPseudo) {
                 DCHECK(m_nthInvalidationSet);
                 if (features.hasFeatures())
                     addFeaturesToInvalidationSet(*m_nthInvalidationSet, features);
                 else
                     m_nthInvalidationSet->setWholeSubtreeInvalid();
             }
+            features.hasInvalidationSetFeaturesInScope = features.hasFeatures();
             InvalidationSetFeatures* siblingFeatures = nullptr;
             updateFeaturesFromCombinator(*simpleSelector, nullptr, features, siblingFeatures, features);
         }
         return simpleSelector->tagHistory();
     }
 
+    features.hasInvalidationSetFeaturesInScope = features.hasFeatures();
     return nullptr;
 }
 
 // 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 hadInvalidationSetFeaturesInScope = descendantFeatures.hasInvalidationSetFeaturesInScope;
+    bool selectorListContainsUniversal = simpleSelector.getPseudoType() == CSSSelector::PseudoNot
+        || simpleSelector.getPseudoType() == CSSSelector::PseudoHostContext;
+
+    for (const CSSSelector* subSelector = simpleSelector.selectorList()->first(); subSelector; subSelector = CSSSelectorList::next(*subSelector)) {
+        descendantFeatures.hasInvalidationSetFeaturesInScope = false;
+
         addFeaturesToInvalidationSetsForCompoundSelector(*subSelector, siblingFeatures, descendantFeatures);
+
+        if (!descendantFeatures.hasInvalidationSetFeaturesInScope)
+            selectorListContainsUniversal = true;
+    }
+
+    descendantFeatures.hasInvalidationSetFeaturesInScope = hadInvalidationSetFeaturesInScope || !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.hasInvalidationSetFeaturesInScope = true;
+    else if (siblingFeatures)
         addFeaturesToUniversalSiblingInvalidationSet(*siblingFeatures, descendantFeatures);
 
     return simpleSelector;
 }
 
 void RuleFeatureSet::addFeaturesToInvalidationSets(const CSSSelector& selector, InvalidationSetFeatures& descendantFeatures)
 {
     // selector is the selector immediately to the left of the rightmost combinator.
     // descendantFeatures has the features of the rightmost compound selector.
 
@@ skipping 94 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 230 matching lines @@
 bool RuleFeatureSet::InvalidationSetFeatures::hasFeatures() const
 {
     return !classes.isEmpty()
         || !attributes.isEmpty()
         || !ids.isEmpty()
         || !tagNames.isEmpty()
         || customPseudoElement;
 }
 
 } // namespace blink