Simplified compound feature extraction.

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 421 matching lines @@
     // Given a rule, update the descendant invalidation sets for the features
     // found in its selector. The first step is to extract the features from the
     // 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);
+    InvalidationSetFeatures* siblingFeatures = nullptr;
+
+    const CSSSelector* lastInCompound = extractInvalidationSetFeaturesFromCompound(ruleData.selector(), features, Subject);
 
     if (!features.hasFeatures())
         features.forceSubtree = true;
-
-    if (nextCompound)
-        addFeaturesToInvalidationSets(*nextCompound, features);
-    else if (features.hasNthPseudo)
+    if (features.hasNthPseudo)
         addFeaturesToInvalidationSet(ensureNthInvalidationSet(), features);
-
     if (features.hasBeforeOrAfter)
         updateInvalidationSetsForContentAttribute(ruleData);
+
+    const CSSSelector* nextCompound = lastInCompound ? lastInCompound->tagHistory() : &ruleData.selector();
+    if (!nextCompound)
+        return;
+    if (lastInCompound)
+        updateFeaturesFromCombinator(*lastInCompound, nullptr, features, siblingFeatures, features);
+
+    addFeaturesToInvalidationSets(*nextCompound, siblingFeatures, features);
 }
 
 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 11 matching lines @@
     for (auto& item : toCSSValueList(contentValue)) {
         if (!item->isFunctionValue())
             continue;
         const CSSFunctionValue* functionValue = toCSSFunctionValue(item.get());
         if (functionValue->functionType() != CSSValueAttr)
             continue;
         ensureAttributeInvalidationSet(AtomicString(toCSSCustomIdentValue(functionValue->item(0)).value()), InvalidateDescendants).setInvalidatesSelf();
     }
 }
 
-const CSSSelector*
+RuleFeatureSet::FeatureInvalidationType
 RuleFeatureSet::extractInvalidationSetFeaturesFromSelectorList(const CSSSelector& simpleSelector, InvalidationSetFeatures& features, PositionType position)
 {
     const CSSSelectorList* selectorList = simpleSelector.selectorList();
     if (!selectorList)
-        return nullptr;
+        return NormalInvalidation;
 
     DCHECK(supportsInvalidationWithSelectorList(simpleSelector.getPseudoType()));
 
     const CSSSelector* subSelector = selectorList->first();
 
     bool allSubSelectorsHaveFeatures = true;
     InvalidationSetFeatures anyFeatures;
 
     for (; subSelector; subSelector = CSSSelectorList::next(*subSelector)) {
         InvalidationSetFeatures compoundFeatures;
-        if (extractInvalidationSetFeaturesFromCompound(*subSelector, compoundFeatures, position, simpleSelector.getPseudoType())) {
-            // A non-null selector return means the sub-selector contained a
+        if (!extractInvalidationSetFeaturesFromCompound(*subSelector, compoundFeatures, position, simpleSelector.getPseudoType())) {
+            // A null selector return means the sub-selector contained a
             // selector which requiresSubtreeInvalidation().
             DCHECK(compoundFeatures.forceSubtree);
             features.forceSubtree = true;
-            return &simpleSelector;
+            return RequiresSubtreeInvalidation;
         }
         if (allSubSelectorsHaveFeatures && !compoundFeatures.hasFeatures())
             allSubSelectorsHaveFeatures = false;
         else
             anyFeatures.add(compoundFeatures);
         if (compoundFeatures.hasNthPseudo)
             features.hasNthPseudo = true;
     }
     // Don't add any features if one of the sub-selectors of does not contain
     // any invalidation set features. E.g. :-webkit-any(*, span).
     if (allSubSelectorsHaveFeatures)
         features.add(anyFeatures);
-    return nullptr;
+    return NormalInvalidation;
 }
 
 const CSSSelector*
 RuleFeatureSet::extractInvalidationSetFeaturesFromCompound(const CSSSelector& compound, InvalidationSetFeatures& features, PositionType position, CSSSelector::PseudoType pseudo)
 {
+    // Extract invalidation set features and return a pointer to the the last
+    // simple selector of the compound, or nullptr if one of the selectors
+    // requiresSubtreeInvalidation().
+
     const CSSSelector* simpleSelector = &compound;
     for (; simpleSelector; simpleSelector = simpleSelector->tagHistory()) {

[Eric Willigers, 2016/09/11 23:58:03]

Another option would be

  for (;; simpleSelector = simpleSelector->tagHistory()) {
    ...
    if (!simpleSelector->tagHistory() || simpleSelector->relation() !=
CSSSelector::SubSelector)
      return simpleSelector;
  }
}

[rune, 2016/09/12 08:01:58]

Done.

 
         // 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.
+        // rightmost compound selector. Returning nullptr here will make
+        // addFeaturesToInvalidationSets start marking invalidation sets for
+        // subtree recalc for features in the rightmost compound selector.
         if (requiresSubtreeInvalidation(*simpleSelector)) {
             features.forceSubtree = true;
-            return &compound;
+            return nullptr;
         }
 
         // When inside a :not(), we should not use the found features for
         // invalidation because we should invalidate elements _without_ that
         // feature. On the other hand, we should still have invalidation sets
         // for the features since we are able to detect when they change.
         // That is, ".a" should not have ".b" in its invalidation set for
         // ".a :not(.b)", but there should be an invalidation set for ".a" in
         // ":not(.a) .b".
         if (pseudo != CSSSelector::PseudoNot)
             extractInvalidationSetFeaturesFromSimpleSelector(*simpleSelector, features);
 
         // Initialize the entry in the invalidation set map for self-
         // invalidation, if supported.
         if (InvalidationSet* invalidationSet = invalidationSetForSimpleSelector(*simpleSelector, InvalidateDescendants)) {
             if (invalidationSet == m_nthInvalidationSet)
                 features.hasNthPseudo = true;
             else if (position == Subject)
                 invalidationSet->setInvalidatesSelf();
         }
 
-        if (extractInvalidationSetFeaturesFromSelectorList(*simpleSelector, features, position)) {
+        if (extractInvalidationSetFeaturesFromSelectorList(*simpleSelector, features, position) == RequiresSubtreeInvalidation) {
             DCHECK(features.forceSubtree);
-            return &compound;
+            return nullptr;
         }
 
-        if (simpleSelector->relation() == CSSSelector::SubSelector)
-            continue;
-
-        if (position == Subject) {
-            if (features.hasNthPseudo) {
-                DCHECK(m_nthInvalidationSet);
-                if (features.hasFeatures())
-                    addFeaturesToInvalidationSet(*m_nthInvalidationSet, features);
-                else
-                    m_nthInvalidationSet->setWholeSubtreeInvalid();
-            }
-            InvalidationSetFeatures* siblingFeatures = nullptr;
-            updateFeaturesFromCombinator(*simpleSelector, nullptr, features, siblingFeatures, features);
-        }
-        return simpleSelector->tagHistory();
+        if (!simpleSelector->tagHistory())
+            break;
+        if (simpleSelector->relation() != CSSSelector::SubSelector)
+            break;
     }
 
-    return nullptr;
+    DCHECK(simpleSelector);
+    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
 // we start adding features to the descendant invalidation set.
@@ skipping 74 matching lines @@
         if (!simpleSelector->tagHistory())
             break;
     }
 
     if (siblingFeatures && !compoundHasIdClassOrAttribute)
         addFeaturesToUniversalSiblingInvalidationSet(*siblingFeatures, descendantFeatures);
 
     return simpleSelector;
 }
 
-void RuleFeatureSet::addFeaturesToInvalidationSets(const CSSSelector& selector, InvalidationSetFeatures& descendantFeatures)
+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.
 
     InvalidationSetFeatures lastCompoundInSiblingChainFeatures;
-    InvalidationSetFeatures* siblingFeatures = descendantFeatures.maxDirectAdjacentSelectors ? &descendantFeatures : nullptr;
-
     const CSSSelector* compound = &selector;
     while (compound) {
         const CSSSelector* lastInCompound = addFeaturesToInvalidationSetsForCompoundSelector(*compound, siblingFeatures, descendantFeatures);
         DCHECK(lastInCompound);
         updateFeaturesFromCombinator(*lastInCompound, compound, lastCompoundInSiblingChainFeatures, siblingFeatures, descendantFeatures);
         compound = lastInCompound->tagHistory();
     }
 }
 
 RuleFeatureSet::SelectorPreMatch RuleFeatureSet::collectFeaturesFromRuleData(const RuleData& ruleData)
@@ skipping 342 matching lines @@
 bool RuleFeatureSet::InvalidationSetFeatures::hasFeatures() const
 {
     return !classes.isEmpty()
         || !attributes.isEmpty()
         || !ids.isEmpty()
         || !tagNames.isEmpty()
         || customPseudoElement;
 }
 
 } // namespace blink