Current work-in-progress crbug.com/567021

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 350 matching lines @@
 // 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.
 
 void RuleFeatureSet::updateInvalidationSets(const RuleData& ruleData)
 {
     InvalidationSetFeatures features;
     auto result = extractInvalidationSetFeatures(ruleData.selector(), features, Subject);
 
-    if (result.first) {
-        features.forceSubtree = result.second == ForceSubtree;
+    if (result.second == ForceSubtree) {
+        features.forceSubtree = true;
+        features.containsIdClassAttributeOrTypeInScope = false;
+    }
+
+    if (result.first)
         addFeaturesToInvalidationSets(result.first, features.adjacent ? &features : nullptr, features);
-    }
+
+    if (!features.containsIdClassAttributeOrTypeInScope)
+        m_metadata.needsFullRecalcForRuleSetInvalidation = true;
 
     // If any ::before and ::after rules specify 'content: attr(...)', we
     // need to create invalidation sets for those attributes.
     if (features.hasBeforeOrAfter)
         updateInvalidationSetsForContentAttribute(ruleData);
 }
 
 void RuleFeatureSet::updateInvalidationSetsForContentAttribute(const RuleData& ruleData)
 {
     const StylePropertySet& propertySet = ruleData.rule()->properties();
@@ skipping 57 matching lines @@
                     }
                     allSubSelectorsHaveFeatures &= result.second == UseFeatures;
                 }
                 foundFeatures |= allSubSelectorsHaveFeatures;
             }
         }
 
         if (current->relation() == CSSSelector::SubSelector)
             continue;
 
-        features.treeBoundaryCrossing = current->isShadowSelector();
+        features.containsIdClassAttributeOrTypeInScope |= foundFeatures;
+        if (current->isShadowSelector()) {
+            features.treeBoundaryCrossing = true;
+            features.containsIdClassAttributeOrTypeInScope = false;
+        }
         if (current->relationIsAffectedByPseudoContent()) {
             features.contentPseudoCrossing = true;
             features.insertionPointCrossing = true;
+            features.containsIdClassAttributeOrTypeInScope = false;
         }
+
         features.adjacent = current->isAdjacentSelector();
         if (current->relation() == CSSSelector::DirectAdjacent)
             features.maxDirectAdjacentSelectors = 1;
         return std::make_pair(current->tagHistory(), foundFeatures ? UseFeatures : ForceSubtree);
     }
-    return std::make_pair(nullptr,  foundFeatures ? UseFeatures : ForceSubtree);
+    features.containsIdClassAttributeOrTypeInScope |= foundFeatures;
+    return std::make_pair(nullptr, foundFeatures ? UseFeatures : ForceSubtree);
 }
 
 // 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 29 matching lines @@
 void RuleFeatureSet::addFeaturesToInvalidationSets(const CSSSelector* selector, InvalidationSetFeatures* siblingFeatures, InvalidationSetFeatures& descendantFeatures)
 {
     const CSSSelector* lastCompoundSelectorInAdjacentChain = selector;
 
     // We set siblingFeatures to &localFeatures if we find a rightmost sibling combinator.
     InvalidationSetFeatures localFeatures;
 
     for (const CSSSelector* current = selector; current; current = current->tagHistory()) {
         InvalidationType type = siblingFeatures ? InvalidateSiblings : InvalidateDescendants;
         if (InvalidationSet* invalidationSet = invalidationSetForSelector(*current, type)) {
+            if (current->match() == CSSSelector::Id || current->match() == CSSSelector::Class || current->match() >= CSSSelector::FirstAttributeSelectorMatch)
+                descendantFeatures.containsIdClassAttributeOrTypeInScope = true;
             if (siblingFeatures) {
                 SiblingInvalidationSet* siblingInvalidationSet = toSiblingInvalidationSet(invalidationSet);
                 siblingInvalidationSet->updateMaxDirectAdjacentSelectors(siblingFeatures->maxDirectAdjacentSelectors);
 
                 addFeaturesToInvalidationSet(*invalidationSet, *siblingFeatures);
                 if (siblingFeatures == &descendantFeatures)
                     siblingInvalidationSet->setInvalidatesSelf();
                 else
                     addFeaturesToInvalidationSet(siblingInvalidationSet->ensureSiblingDescendants(), descendantFeatures);
             } else {
                 addFeaturesToInvalidationSet(*invalidationSet, descendantFeatures);
             }
         } else {
             if (current->isHostPseudoClass())
                 descendantFeatures.treeBoundaryCrossing = true;
             if (current->isInsertionPointCrossing())
                 descendantFeatures.insertionPointCrossing = true;
             if (const CSSSelectorList* selectorList = current->selectorList()) {
                 ASSERT(supportsInvalidationWithSelectorList(current->getPseudoType()));
+                bool didContain = descendantFeatures.containsIdClassAttributeOrTypeInScope;
                 for (const CSSSelector* subSelector = selectorList->first(); subSelector; subSelector = CSSSelectorList::next(*subSelector))
                     addFeaturesToInvalidationSets(subSelector, siblingFeatures, descendantFeatures);
+                if (current->getPseudoType() == CSSSelector::PseudoNot || current->getPseudoType() == CSSSelector::PseudoHostContext)
+                    descendantFeatures.containsIdClassAttributeOrTypeInScope = didContain;
+                else
+                    descendantFeatures.containsIdClassAttributeOrTypeInScope |= didContain;
             }
         }
 
         if (current->relation() == CSSSelector::SubSelector)
             continue;
 
         if (current->relationIsAffectedByPseudoContent() || current->relation() == CSSSelector::ShadowSlot) {
             descendantFeatures.insertionPointCrossing = true;
             descendantFeatures.contentPseudoCrossing = true;
+            descendantFeatures.containsIdClassAttributeOrTypeInScope = false;
         }
-        if (current->isShadowSelector())
+        if (current->isShadowSelector()) {
             descendantFeatures.treeBoundaryCrossing = true;
+            descendantFeatures.containsIdClassAttributeOrTypeInScope = false;
+        }
         if (!current->isAdjacentSelector()) {
             lastCompoundSelectorInAdjacentChain = current->tagHistory();
             siblingFeatures = nullptr;
             continue;
         }
 
         if (siblingFeatures) {
             if (siblingFeatures->maxDirectAdjacentSelectors == UINT_MAX)
                 continue;
 
@@ skipping 107 matching lines @@
     usesWindowInactiveSelector = 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)
 {
     for (const auto& entry : other.m_classInvalidationSets)
         ensureInvalidationSet(m_classInvalidationSets, entry.key, entry.value->type()).combine(*entry.value);
     for (const auto& entry : other.m_attributeInvalidationSets)
         ensureInvalidationSet(m_attributeInvalidationSets, entry.key, entry.value->type()).combine(*entry.value);
     for (const auto& entry : other.m_idInvalidationSets)
         ensureInvalidationSet(m_idInvalidationSets, entry.key, entry.value->type()).combine(*entry.value);
     for (const auto& entry : other.m_pseudoInvalidationSets)
         ensureInvalidationSet(m_pseudoInvalidationSets, static_cast<CSSSelector::PseudoType>(entry.key), entry.value->type()).combine(*entry.value);
 
     m_metadata.add(other.m_metadata);
 
     siblingRules.appendVector(other.siblingRules);
     uncommonAttributeRules.appendVector(other.uncommonAttributeRules);
+    viewportDependentMediaQueryResults.appendVector(other.viewportDependentMediaQueryResults);
+    deviceDependentMediaQueryResults.appendVector(other.deviceDependentMediaQueryResults);
 }
 
 void RuleFeatureSet::clear()
 {
     siblingRules.clear();
     uncommonAttributeRules.clear();
     m_metadata.clear();
     m_classInvalidationSets.clear();
     m_attributeInvalidationSets.clear();
     m_idInvalidationSets.clear();
@@ skipping 81 matching lines @@
     if (siblings) {
         TRACE_SCHEDULE_STYLE_INVALIDATION(element, *siblings, pseudoChange, pseudo);
         invalidationLists.siblings.append(siblings);
     }
 }
 
 DEFINE_TRACE(RuleFeatureSet)
 {
     visitor->trace(siblingRules);
     visitor->trace(uncommonAttributeRules);
+    visitor->trace(viewportDependentMediaQueryResults);
+    visitor->trace(deviceDependentMediaQueryResults);
 }
 
 } // namespace blink