Single code path for updating invalidation sets.

Allow all selectors to update invalidation sets using updateInvalidationSets
and never fall back to a separate wholeSubtree loop in
collectFeaturesFromSelector. The method for finding the InvalidationSetMode
is dropped completely.

With this change we are now at a point were a whole subtree invalidation is
only necessary for these cases:

1. There are no recognized features in the rightmost compound selector

 - A universal selector: ".a *"
 - Only contains pseudo classes or elements that are not considered
   features:

   ".a ::before", ".a :first-child", etc.

2. The invalidation set component is immediately left of an adjacent
   combinator:

   ".a + .b", ".a ~ .b"

3. The selector has a ::first-letter or ::first-line pseudo

   These are currently depending on style recalc or layout below the
   element they are pseudo elements for.

3. There is a :host-context() in the rightmost compound selector

   :host-context sub-selectors match ascendants of the :host element for
   which we are resolving style, so ":host-context(.a)" is effectively the
   same as ".a :host" which falls under no recognized features in the
   rightmost compound in point 1.

Points 1, 3, and 4 are now handled through
InvalidationSetFeatures::forceSubtree set as a result of feature extraction.
Point 2 is handled by updating InvalidationSetFeatures::adjacent as we
progress past selector combinators.

RuleFeaturesSet::collectFeaturesFromSelector is now back to how it was
before we introduced invalidation sets (without the feature hash sets).
Now, it only counts adjacent combinators and sets a flag when finding
::first-line, so it is possible to squash it into the same method as
updateInvalidationSets() to have a single pass over the selector when
finding rule features (if we want to do that).

The lowered expected node count in the :host-context test is due to the
fact that we only fall back to subtree invalidation when present in the
rightmost compound. ::first-letter/::first-line are always in the rightmost
compound, and :host-context() doesn't need subtree invalidation when in
other compounds. ":host-context(.a) .b" is effectively ".a :host .b".

R=chrishtr@chromium.org
BUG=335247

Review URL: https://codereview.chromium.org/726503003

git-svn-id: svn://svn.chromium.org/blink/trunk@185354 bbb929c8-8fbe-4397-9dbb-9b2b20218538

third_party/WebKit/LayoutTests/fast/css/invalidation/targeted-class-host-context.html

@@ -38,7 +38,7 @@ test(function(){
     assert_equals(getComputedStyle(inner, "").backgroundColor, transparent, "Background color before class change.");
     t2.className = "t2";
     if (window.internals)
-        assert_equals(internals.updateStyleAndReturnAffectedElementCount(), 8, "Element recalc count on class change.");
+        assert_equals(internals.updateStyleAndReturnAffectedElementCount(), 2, "Element recalc count on class change.");
     assert_equals(getComputedStyle(inner, "").backgroundColor, green, "Background color after class change.");
 }, "Matching id descendant of :host-context with class.");
 

third_party/WebKit/Source/core/css/RuleFeature.cpp

@@ -163,6 +163,15 @@ static bool supportsInvalidation(CSSSelector::PseudoType type)
     }
 }
 
+static bool supportsInvalidationWithSelectorList(CSSSelector::PseudoType pseudo)
+{
+    return pseudo == CSSSelector::PseudoAny
+        || pseudo == CSSSelector::PseudoCue
+        || pseudo == CSSSelector::PseudoHost
+        || pseudo == CSSSelector::PseudoHostContext
+        || pseudo == CSSSelector::PseudoNot;
+}
+
 #endif // ENABLE(ASSERT)
 
 static bool requiresSubtreeInvalidation(const CSSSelector& selector)
@@ -200,77 +209,9 @@ void RuleFeature::trace(Visitor* visitor)
     visitor->trace(rule);
 }
 
-static bool supportsInvalidationWithSelectorList(CSSSelector::PseudoType pseudo)
-{
-    return pseudo == CSSSelector::PseudoAny
-        || pseudo == CSSSelector::PseudoCue
-        || pseudo == CSSSelector::PseudoHost
-        || pseudo == CSSSelector::PseudoNot;
-}
-
-// This method is somewhat conservative in what it accepts.
-RuleFeatureSet::InvalidationSetMode RuleFeatureSet::invalidationSetModeForSelector(const CSSSelector& selector)
+bool RuleFeatureSet::extractInvalidationSetFeature(const CSSSelector& selector, InvalidationSetFeatures& features)
 {
-    bool foundCombinator = false;
-    bool foundIdent = false;
-    for (const CSSSelector* component = &selector; component; component = component->tagHistory()) {
-
-        if (component->match() == CSSSelector::Class || component->match() == CSSSelector::Id
-            || (component->match() == CSSSelector::Tag && component->tagQName().localName() != starAtom)
-            || component->isAttributeSelector() || component->isCustomPseudoElement()) {
-            if (!foundCombinator) {
-                // We have found an invalidation set feature in the rightmost compound selector.
-                foundIdent = true;
-            }
-        } else if (supportsInvalidationWithSelectorList(component->pseudoType())) {
-            if (const CSSSelectorList* selectorList = component->selectorList()) {
-                // Features inside :not() are not added to the feature set, so consider it a universal selector.
-                bool foundUniversal = component->pseudoType() == CSSSelector::PseudoNot;
-                for (const CSSSelector* selector = selectorList->first(); selector; selector = CSSSelectorList::next(*selector)) {
-                    // Find the invalidation set mode for each of the selectors in the selector list
-                    // of a :not(), :host(), etc. For instance, ".x :-webkit-any(.a, .b)" yields an
-                    // AddFeatures mode for both ".a" and ".b". ":-webkit-any(.a, *)" yields AddFeatures
-                    // for ".a", but UseSubtreeStyleChange for "*". One sub-selector without invalidation
-                    // set features is sufficient to cause the selector to be a universal selector as far
-                    // the invalidation set is concerned.
-                    InvalidationSetMode subSelectorMode = invalidationSetModeForSelector(*selector);
-
-                    // The sub-selector contained something unskippable, fall back to whole subtree
-                    // recalcs in collectFeaturesFromSelector. subSelectorMode will return
-                    // UseSubtreeStyleChange since there are no combinators inside the selector list,
-                    // so translate it to UseLocalStyleChange if a combinator has been seen in the
-                    // outer context.
-                    //
-                    // FIXME: Is UseSubtreeStyleChange ever needed as input to collectFeaturesFromSelector?
-                    // That is, are there any selectors for which we need to use SubtreeStyleChange for
-                    // changing features when present in the rightmost compound selector?
-                    if (subSelectorMode == UseSubtreeStyleChange)
-                        return foundCombinator ? UseLocalStyleChange : UseSubtreeStyleChange;
-
-                    // We found no features in the sub-selector, only skippable ones (foundIdent was
-                    // false at the end of this method). That is a universal selector as far as the
-                    // invalidation set is concerned.
-                    if (subSelectorMode == UseLocalStyleChange)
-                        foundUniversal = true;
-                }
-                if (!foundUniversal && !foundCombinator) {
-                    // All sub-selectors contained invalidation set features and
-                    // we are in the rightmost compound selector.
-                    foundIdent = true;
-                }
-            }
-        } else if (requiresSubtreeInvalidation(*component)) {
-            return foundCombinator ? UseLocalStyleChange : UseSubtreeStyleChange;
-        }
-        if (component->relation() != CSSSelector::SubSelector)
-            foundCombinator = true;
-    }
-    return foundIdent ? AddFeatures : UseLocalStyleChange;
-}
-
-void RuleFeatureSet::extractInvalidationSetFeature(const CSSSelector& selector, InvalidationSetFeatures& features)
-{
-    if (selector.match() == CSSSelector::Tag)
+    if (selector.match() == CSSSelector::Tag && selector.tagQName().localName() != starAtom)
         features.tagName = selector.tagQName().localName();
     else if (selector.match() == CSSSelector::Id)
         features.id = selector.value();
@@ -280,6 +221,9 @@ void RuleFeatureSet::extractInvalidationSetFeature(const CSSSelector& selector,
         features.attributes.append(selector.attribute().localName());
     else if (selector.isCustomPseudoElement())
         features.customPseudoElement = true;
+    else
+        return false;
+    return true;
 }
 
 RuleFeatureSet::RuleFeatureSet()
@@ -321,38 +265,59 @@ DescendantInvalidationSet* RuleFeatureSet::invalidationSetForSelector(const CSSS
             break;
         }
     }
-    return 0;
+    return nullptr;
 }
 
 // Given a selector, update the descendant invalidation sets for the features found
 // in the selector. The first step is to extract the features from the rightmost
-// compound selector (extractInvalidationSetFeatures). Secondly, those features will be
-// added to the invalidation sets for the features found in the other compound selectors
-// (addFeaturesToInvalidationSets).
+// compound selector (extractInvalidationSetFeatures). 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, we addFeaturesToInvalidationSets for the
+// rightmost compound selector as well.
 
-RuleFeatureSet::InvalidationSetMode RuleFeatureSet::updateInvalidationSets(const CSSSelector& selector)
+void RuleFeatureSet::updateInvalidationSets(const CSSSelector& selector)
 {
-    InvalidationSetMode mode = invalidationSetModeForSelector(selector);
-    if (mode != AddFeatures)
-        return mode;
-
     InvalidationSetFeatures features;
-    if (const CSSSelector* current = extractInvalidationSetFeatures(selector, features, false))
-        addFeaturesToInvalidationSets(*current, features);
-    return AddFeatures;
+    auto result = extractInvalidationSetFeatures(selector, features, false);
+    if (result.first) {
+        features.forceSubtree = result.second == ForceSubtree;
+        addFeaturesToInvalidationSets(*result.first, features);
+    }
 }
 
-const CSSSelector* RuleFeatureSet::extractInvalidationSetFeatures(const CSSSelector& selector, InvalidationSetFeatures& features, bool negated)
+std::pair<const CSSSelector*, RuleFeatureSet::UseFeaturesType>
+RuleFeatureSet::extractInvalidationSetFeatures(const CSSSelector& selector, InvalidationSetFeatures& features, bool negated)
 {
+    bool foundFeatures = false;
     for (const CSSSelector* current = &selector; current; current = current->tagHistory()) {
         if (!negated)
-            extractInvalidationSetFeature(*current, features);
+            foundFeatures |= extractInvalidationSetFeature(*current, features);
         // Initialize the entry in the invalidation set map, if supported.
-        invalidationSetForSelector(*current);
-        if (supportsInvalidationWithSelectorList(current->pseudoType())) {
+        if (!invalidationSetForSelector(*current)) {
+            if (requiresSubtreeInvalidation(*current)) {
+                // Fall back to use subtree invalidations, even for features in the
+                // rightmost compound selector. Returning the start &selector here
+                // will make addFeaturesToInvalidationSets start marking invalidation
+                // sets for subtree recalc for features in the rightmost compound
+                // selector.
+                return std::make_pair(&selector, ForceSubtree);
+            }
             if (const CSSSelectorList* selectorList = current->selectorList()) {
-                for (const CSSSelector* selector = selectorList->first(); selector; selector = CSSSelectorList::next(*selector))
-                    extractInvalidationSetFeatures(*selector, features, current->pseudoType() == CSSSelector::PseudoNot);
+                ASSERT(supportsInvalidationWithSelectorList(current->pseudoType()));
+                const CSSSelector* subSelector = selectorList->first();
+                bool allSubSelectorsHaveFeatures = !!subSelector;
+                for (; subSelector; subSelector = CSSSelectorList::next(*subSelector)) {
+                    auto result = extractInvalidationSetFeatures(*subSelector, features, current->pseudoType() == CSSSelector::PseudoNot);
+                    if (result.first) {
+                        // A non-null selector return means the sub-selector contained a
+                        // selector which requiresSubtreeInvalidation(). Return the rightmost
+                        // selector to mark for subtree recalcs like above.
+                        return std::make_pair(&selector, ForceSubtree);
+                    }
+                    allSubSelectorsHaveFeatures &= result.second == UseFeatures;
+                }
+                foundFeatures |= allSubSelectorsHaveFeatures;
             }
         }
 
@@ -361,9 +326,9 @@ const CSSSelector* RuleFeatureSet::extractInvalidationSetFeatures(const CSSSelec
 
         features.treeBoundaryCrossing = current->isShadowSelector();
         features.adjacent = current->isAdjacentSelector();
-        return current->tagHistory();
+        return std::make_pair(current->tagHistory(), foundFeatures ? UseFeatures : ForceSubtree);
     }
-    return 0;
+    return std::make_pair(nullptr, ForceSubtree);
 }
 
 // Add features extracted from the rightmost compound selector to descendant invalidation
@@ -384,7 +349,7 @@ void RuleFeatureSet::addFeaturesToInvalidationSet(DescendantInvalidationSet& inv
         invalidationSet.setTreeBoundaryCrossing();
     if (features.insertionPointCrossing)
         invalidationSet.setInsertionPointCrossing();
-    if (features.adjacent) {
+    if (features.useSubtreeInvalidation()) {
         invalidationSet.setWholeSubtreeInvalid();
         return;
     }
@@ -434,10 +399,10 @@ void RuleFeatureSet::addContentAttr(const AtomicString& attributeName)
 
 void RuleFeatureSet::collectFeaturesFromRuleData(const RuleData& ruleData)
 {
-    FeatureMetadata metadata;
-    InvalidationSetMode mode = updateInvalidationSets(ruleData.selector());
+    updateInvalidationSets(ruleData.selector());
 
-    collectFeaturesFromSelector(ruleData.selector(), metadata, mode);
+    FeatureMetadata metadata;
+    collectFeaturesFromSelector(ruleData.selector(), metadata);
     m_metadata.add(metadata);
 
     if (metadata.foundSiblingSelector)
@@ -478,17 +443,11 @@ DescendantInvalidationSet& RuleFeatureSet::ensurePseudoInvalidationSet(CSSSelect
     return *addResult.storedValue->value;
 }
 
-void RuleFeatureSet::collectFeaturesFromSelector(const CSSSelector& selector, RuleFeatureSet::FeatureMetadata& metadata, InvalidationSetMode mode)
+void RuleFeatureSet::collectFeaturesFromSelector(const CSSSelector& selector, RuleFeatureSet::FeatureMetadata& metadata)
 {
     unsigned maxDirectAdjacentSelectors = 0;
 
     for (const CSSSelector* current = &selector; current; current = current->tagHistory()) {
-        if (mode != AddFeatures) {
-            if (DescendantInvalidationSet* invalidationSet = invalidationSetForSelector(*current)) {
-                if (mode == UseSubtreeStyleChange)
-                    invalidationSet->setWholeSubtreeInvalid();
-            }
-        }
         if (current->pseudoType() == CSSSelector::PseudoFirstLine)
             metadata.usesFirstLineRules = true;
         if (current->isDirectAdjacentSelector()) {
@@ -501,24 +460,17 @@ void RuleFeatureSet::collectFeaturesFromSelector(const CSSSelector& selector, Ru
         if (current->isSiblingSelector())
             metadata.foundSiblingSelector = true;
 
-        collectFeaturesFromSelectorList(current->selectorList(), metadata, mode);
+        const CSSSelectorList* selectorList = current->selectorList();
+        if (!selectorList)
+            continue;
 
-        if (mode == UseLocalStyleChange && current->relation() != CSSSelector::SubSelector)
-            mode = UseSubtreeStyleChange;
+        for (const CSSSelector* selector = selectorList->first(); selector; selector = CSSSelectorList::next(*selector))
+            collectFeaturesFromSelector(*selector, metadata);
     }
 
     ASSERT(!maxDirectAdjacentSelectors);
 }
 
-void RuleFeatureSet::collectFeaturesFromSelectorList(const CSSSelectorList* selectorList, RuleFeatureSet::FeatureMetadata& metadata, InvalidationSetMode mode)
-{
-    if (!selectorList)
-        return;
-
-    for (const CSSSelector* selector = selectorList->first(); selector; selector = CSSSelectorList::next(*selector))
-        collectFeaturesFromSelector(*selector, metadata, mode);
-}
-
 void RuleFeatureSet::FeatureMetadata::add(const FeatureMetadata& other)
 {
     usesFirstLineRules = usesFirstLineRules || other.usesFirstLineRules;

third_party/WebKit/Source/core/css/RuleFeature.h

@@ -125,23 +125,14 @@ private:
         unsigned maxDirectAdjacentSelectors;
     };
 
-    enum InvalidationSetMode {
-        AddFeatures,
-        UseLocalStyleChange,
-        UseSubtreeStyleChange
-    };
-
-    static InvalidationSetMode invalidationSetModeForSelector(const CSSSelector&);
-
-    void collectFeaturesFromSelector(const CSSSelector&, FeatureMetadata&, InvalidationSetMode);
-    void collectFeaturesFromSelectorList(const CSSSelectorList*, FeatureMetadata&, InvalidationSetMode);
+    void collectFeaturesFromSelector(const CSSSelector&, FeatureMetadata&);
 
     DescendantInvalidationSet& ensureClassInvalidationSet(const AtomicString& className);
     DescendantInvalidationSet& ensureAttributeInvalidationSet(const AtomicString& attributeName);
     DescendantInvalidationSet& ensureIdInvalidationSet(const AtomicString& attributeName);
     DescendantInvalidationSet& ensurePseudoInvalidationSet(CSSSelector::PseudoType);
 
-    InvalidationSetMode updateInvalidationSets(const CSSSelector&);
+    void updateInvalidationSets(const CSSSelector&);
 
     struct InvalidationSetFeatures {
         InvalidationSetFeatures()
@@ -149,7 +140,11 @@ private:
             , treeBoundaryCrossing(false)
             , adjacent(false)
             , insertionPointCrossing(false)
+            , forceSubtree(false)
         { }
+
+        bool useSubtreeInvalidation() const { return forceSubtree || adjacent; }
+
         Vector<AtomicString> classes;
         Vector<AtomicString> attributes;
         AtomicString id;
@@ -158,10 +153,14 @@ private:
         bool treeBoundaryCrossing;
         bool adjacent;
         bool insertionPointCrossing;
+        bool forceSubtree;
     };
 
-    static void extractInvalidationSetFeature(const CSSSelector&, InvalidationSetFeatures&);
-    const CSSSelector* extractInvalidationSetFeatures(const CSSSelector&, InvalidationSetFeatures&, bool negated);
+    static bool extractInvalidationSetFeature(const CSSSelector&, InvalidationSetFeatures&);
+
+    enum UseFeaturesType { UseFeatures, ForceSubtree };
+
+    std::pair<const CSSSelector*, UseFeaturesType> extractInvalidationSetFeatures(const CSSSelector&, InvalidationSetFeatures&, bool negated);
 
     void addFeaturesToInvalidationSet(DescendantInvalidationSet&, const InvalidationSetFeatures&);
     void addFeaturesToInvalidationSets(const CSSSelector&, InvalidationSetFeatures&);