RuleSet invalidations on single feature only, including tags.

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/)
@@ skipping 329 matching lines @@
   if (lastInCompound.relationIsAffectedByPseudoContent())
     descendantFeatures.contentPseudoCrossing = true;
 }
 
 void RuleFeatureSet::extractInvalidationSetFeaturesFromSimpleSelector(
     const CSSSelector& selector,
     InvalidationSetFeatures& features) {
   if (selector.match() == CSSSelector::Tag &&
       selector.tagQName().localName() != starAtom) {
     features.tagNames.push_back(selector.tagQName().localName());
+    features.setRuleSetInvalidationFeature(
+        selector.tagQName().localName(),
+        InvalidationSetFeatures::RuleSetFeatureType::Tag);
     return;
   }
   if (selector.match() == CSSSelector::Id) {
     features.ids.push_back(selector.value());
+    features.setRuleSetInvalidationFeature(
+        selector.value(), InvalidationSetFeatures::RuleSetFeatureType::Id);
     return;
   }
   if (selector.match() == CSSSelector::Class) {
     features.classes.push_back(selector.value());
+    features.setRuleSetInvalidationFeature(
+        selector.value(), InvalidationSetFeatures::RuleSetFeatureType::Class);
     return;
   }
   if (selector.isAttributeSelector()) {
     features.attributes.push_back(selector.attribute().localName());
+    features.setRuleSetInvalidationFeature(
+        selector.attribute().localName(),
+        InvalidationSetFeatures::RuleSetFeatureType::Attribute);
     return;
   }
   switch (selector.getPseudoType()) {
     case CSSSelector::PseudoWebKitCustomElement:
     case CSSSelector::PseudoBlinkInternalElement:
       features.customPseudoElement = true;
       return;
     case CSSSelector::PseudoBefore:
     case CSSSelector::PseudoAfter:
       features.hasBeforeOrAfter = true;
@@ skipping 77 matching lines @@
   // addFeaturesToInvalidationSets for that one as well.
 
   InvalidationSetFeatures features;
   InvalidationSetFeatures* siblingFeatures = nullptr;
 
   const CSSSelector* lastInCompound =
       extractInvalidationSetFeaturesFromCompound(ruleData.selector(), features,
                                                  Subject);
 
   if (features.forceSubtree)
-    features.hasFeaturesForRuleSetInvalidation = false;
+    features.clearRuleSetInvalidationFeature();
   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 (!features.hasFeaturesForRuleSetInvalidation)
-      m_metadata.needsFullRecalcForRuleSetInvalidation = true;
+    processRuleSetInvalidationFeature(features);
     return;
   }
   if (lastInCompound)
     updateFeaturesFromCombinator(*lastInCompound, nullptr, features,
                                  siblingFeatures, features);
 
   addFeaturesToInvalidationSets(*nextCompound, siblingFeatures, features);
+  processRuleSetInvalidationFeature(features);
+}
 
-  if (!features.hasFeaturesForRuleSetInvalidation)
-    m_metadata.needsFullRecalcForRuleSetInvalidation = true;
+void RuleFeatureSet::processRuleSetInvalidationFeature(
+    const InvalidationSetFeatures& features) {
+  InvalidationSetMap* map = nullptr;
+  switch (features.ruleSetInvalidationFeatureType) {
+    case InvalidationSetFeatures::RuleSetFeatureType::None:
+      m_metadata.needsFullRecalcForRuleSetInvalidation = true;
+      return;
+    case InvalidationSetFeatures::RuleSetFeatureType::Tag: {
+      DescendantInvalidationSet& typeSet = ensureTypeRuleInvalidationSet();
+      typeSet.addTagName(features.ruleSetInvalidationFeature);
+      return;
+    }
+    case InvalidationSetFeatures::RuleSetFeatureType::Attribute:
+      map = &m_attributeInvalidationSets;
+      break;
+    case InvalidationSetFeatures::RuleSetFeatureType::Class:
+      map = &m_classInvalidationSets;
+      break;
+    case InvalidationSetFeatures::RuleSetFeatureType::Id:
+      map = &m_idInvalidationSets;
+      break;
+  }
+
+  DCHECK(map);
+  InvalidationSetMap::const_iterator it =
+      map->find(features.ruleSetInvalidationFeature);
+  if (it == map->end())
+    return;
+
+  DescendantInvalidationSet* descendants;
+  SiblingInvalidationSet* siblings;
+  extractInvalidationSets(it->value.get(), descendants, siblings);
+  if (descendants)
+    descendants->setAppliesToRuleSetInvalidations();
+  if (siblings)
+    siblings->setAppliesToRuleSetInvalidations();
 }
 
 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 51 matching lines @@
     }
     if (compoundFeatures.hasNthPseudo)
       features.hasNthPseudo = true;
     if (!allSubSelectorsHaveFeatures)
       continue;
     if (compoundFeatures.hasFeatures())
       anyFeatures.add(compoundFeatures);
     else
       allSubSelectorsHaveFeatures = false;
   }
-  // Don't add any features if one of the sub-selectors of does not contain
+  if (!selectorList->hasOneSelector())
+    anyFeatures.clearRuleSetInvalidationFeature();
+  // Don't add any features if one of the sub-selectors does not contain
   // any invalidation set features. E.g. :-webkit-any(*, span).
   if (allSubSelectorsHaveFeatures)
     features.add(anyFeatures);
   return NormalInvalidation;
 }
 
 const CSSSelector* RuleFeatureSet::extractInvalidationSetFeaturesFromCompound(
     const CSSSelector& compound,
     InvalidationSetFeatures& features,
     PositionType position,
@@ skipping 36 matching lines @@
 
     if (extractInvalidationSetFeaturesFromSelectorList(*simpleSelector,
                                                        features, position) ==
         RequiresSubtreeInvalidation) {
       DCHECK(features.forceSubtree);
       return nullptr;
     }
 
     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.
@@ skipping 31 matching lines @@
 
 void RuleFeatureSet::addFeaturesToInvalidationSetsForSelectorList(
     const CSSSelector& simpleSelector,
     InvalidationSetFeatures* siblingFeatures,
     InvalidationSetFeatures& descendantFeatures) {
   if (!simpleSelector.selectorList())
     return;
 
   DCHECK(supportsInvalidationWithSelectorList(simpleSelector.getPseudoType()));
 
-  bool hadFeaturesForRuleSetInvalidation =
-      descendantFeatures.hasFeaturesForRuleSetInvalidation;
-  bool selectorListContainsUniversal =
-      simpleSelector.getPseudoType() == CSSSelector::PseudoNot ||
-      simpleSelector.getPseudoType() == CSSSelector::PseudoHostContext;
+  AtomicString prevRuleSetFeature =
+      descendantFeatures.ruleSetInvalidationFeature;
+  InvalidationSetFeatures::RuleSetFeatureType prevRuleSetFeatureType =
+      descendantFeatures.ruleSetInvalidationFeatureType;
 
   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;
+  if (simpleSelector.getPseudoType() == CSSSelector::PseudoNot ||
+      simpleSelector.getPseudoType() == CSSSelector::PseudoHostContext ||
+      !simpleSelector.selectorList()->hasOneSelector()) {
+    descendantFeatures.clearRuleSetInvalidationFeature();
+    descendantFeatures.setRuleSetInvalidationFeature(prevRuleSetFeature,
+                                                     prevRuleSetFeatureType);
+  }
 }
 
 void RuleFeatureSet::addFeaturesToInvalidationSetsForSimpleSelector(
     const CSSSelector& simpleSelector,
     InvalidationSetFeatures* siblingFeatures,
     InvalidationSetFeatures& descendantFeatures) {
   if (InvalidationSet* invalidationSet = invalidationSetForSimpleSelector(
           simpleSelector,
           siblingFeatures ? InvalidateSiblings : InvalidateDescendants)) {
     if (!siblingFeatures || invalidationSet == m_nthInvalidationSet) {
@@ skipping 27 matching lines @@
 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 (simpleSelector->isIdClassOrAttributeSelector())
+    if (simpleSelector->isIdClassOrAttributeSelector()) {
+      descendantFeatures.setRuleSetFeatureFromSimpleSelector(*simpleSelector);
       compoundHasIdClassOrAttribute = true;
+    }
     if (simpleSelector->relation() != CSSSelector::SubSelector)
       break;
     if (!simpleSelector->tagHistory())
       break;
   }
 
-  if (compoundHasIdClassOrAttribute)
-    descendantFeatures.hasFeaturesForRuleSetInvalidation = true;
-  else if (siblingFeatures)
+  if (!compoundHasIdClassOrAttribute && siblingFeatures)
     addFeaturesToUniversalSiblingInvalidationSet(*siblingFeatures,
                                                  descendantFeatures);
 
   return simpleSelector;
 }
 
 void RuleFeatureSet::addFeaturesToInvalidationSets(
     const CSSSelector& selector,
     InvalidationSetFeatures* siblingFeatures,
     InvalidationSetFeatures& descendantFeatures) {
@@ skipping 176 matching lines @@
   m_pseudoInvalidationSets.clear();
   m_universalSiblingInvalidationSet.clear();
   m_nthInvalidationSet.clear();
   m_viewportDependentMediaQueryResults.clear();
   m_deviceDependentMediaQueryResults.clear();
 }
 
 void RuleFeatureSet::collectInvalidationSetsForClass(
     InvalidationLists& invalidationLists,
     Element& element,
-    const AtomicString& className) const {
+    const AtomicString& className,
+    InvalidationSetFilter filter) const {
   InvalidationSetMap::const_iterator it =
       m_classInvalidationSets.find(className);
   if (it == m_classInvalidationSets.end())
     return;
 
   DescendantInvalidationSet* descendants;
   SiblingInvalidationSet* siblings;
   extractInvalidationSets(it->value.get(), descendants, siblings);
 
-  if (descendants) {
+  if (descendants && (filter == InvalidationSetFilter::None ||
+                      descendants->appliesToRuleSetInvalidations())) {
     TRACE_SCHEDULE_STYLE_INVALIDATION(element, *descendants, classChange,
                                       className);
     invalidationLists.descendants.push_back(descendants);
   }
 
-  if (siblings) {
+  if (siblings && (filter == InvalidationSetFilter::None ||
+                   siblings->appliesToRuleSetInvalidations())) {
     TRACE_SCHEDULE_STYLE_INVALIDATION(element, *siblings, classChange,
                                       className);
     invalidationLists.siblings.push_back(siblings);
   }
 }
 
 void RuleFeatureSet::collectSiblingInvalidationSetForClass(
     InvalidationLists& invalidationLists,
     Element& element,
     const AtomicString& className,
@@ skipping 13 matching lines @@
     return;
 
   TRACE_SCHEDULE_STYLE_INVALIDATION(element, *siblingSet, classChange,
                                     className);
   invalidationLists.siblings.push_back(siblingSet);
 }
 
 void RuleFeatureSet::collectInvalidationSetsForId(
     InvalidationLists& invalidationLists,
     Element& element,
-    const AtomicString& id) const {
+    const AtomicString& id,
+    InvalidationSetFilter filter) const {
   InvalidationSetMap::const_iterator it = m_idInvalidationSets.find(id);
   if (it == m_idInvalidationSets.end())
     return;
 
   DescendantInvalidationSet* descendants;
   SiblingInvalidationSet* siblings;
   extractInvalidationSets(it->value.get(), descendants, siblings);
 
-  if (descendants) {
+  if (descendants && (filter == InvalidationSetFilter::None ||
+                      descendants->appliesToRuleSetInvalidations())) {
     TRACE_SCHEDULE_STYLE_INVALIDATION(element, *descendants, idChange, id);
     invalidationLists.descendants.push_back(descendants);
   }
 
-  if (siblings) {
+  if (siblings && (filter == InvalidationSetFilter::None ||
+                   siblings->appliesToRuleSetInvalidations())) {
     TRACE_SCHEDULE_STYLE_INVALIDATION(element, *siblings, idChange, id);
     invalidationLists.siblings.push_back(siblings);
   }
 }
 
 void RuleFeatureSet::collectSiblingInvalidationSetForId(
     InvalidationLists& invalidationLists,
     Element& element,
     const AtomicString& id,
     unsigned minDirectAdjacent) const {
@@ skipping 10 matching lines @@
   if (siblingSet->maxDirectAdjacentSelectors() < minDirectAdjacent)
     return;
 
   TRACE_SCHEDULE_STYLE_INVALIDATION(element, *siblingSet, idChange, id);
   invalidationLists.siblings.push_back(siblingSet);
 }
 
 void RuleFeatureSet::collectInvalidationSetsForAttribute(
     InvalidationLists& invalidationLists,
     Element& element,
-    const QualifiedName& attributeName) const {
+    const QualifiedName& attributeName,
+    InvalidationSetFilter filter) const {
   InvalidationSetMap::const_iterator it =
       m_attributeInvalidationSets.find(attributeName.localName());
   if (it == m_attributeInvalidationSets.end())
     return;
 
   DescendantInvalidationSet* descendants;
   SiblingInvalidationSet* siblings;
   extractInvalidationSets(it->value.get(), descendants, siblings);
 
-  if (descendants) {
+  if (descendants && (filter == InvalidationSetFilter::None ||
+                      descendants->appliesToRuleSetInvalidations())) {
     TRACE_SCHEDULE_STYLE_INVALIDATION(element, *descendants, attributeChange,
                                       attributeName);
     invalidationLists.descendants.push_back(descendants);
   }
 
-  if (siblings) {
+  if (siblings && (filter == InvalidationSetFilter::None ||
+                   siblings->appliesToRuleSetInvalidations())) {
     TRACE_SCHEDULE_STYLE_INVALIDATION(element, *siblings, attributeChange,
                                       attributeName);
     invalidationLists.siblings.push_back(siblings);
   }
 }
 
 void RuleFeatureSet::collectSiblingInvalidationSetForAttribute(
     InvalidationLists& invalidationLists,
     Element& element,
     const QualifiedName& attributeName,
@@ skipping 63 matching lines @@
   if (m_nthInvalidationSet)
     invalidationLists.descendants.push_back(m_nthInvalidationSet);
 }
 
 DescendantInvalidationSet& RuleFeatureSet::ensureNthInvalidationSet() {
   if (!m_nthInvalidationSet)
     m_nthInvalidationSet = DescendantInvalidationSet::create();
   return *m_nthInvalidationSet;
 }
 
+void RuleFeatureSet::collectTypeRuleInvalidationSet(
+    InvalidationLists& invalidationLists,
+    ContainerNode& rootNode) const {
+  if (m_typeRuleInvalidationSet) {
+    invalidationLists.descendants.push_back(m_typeRuleInvalidationSet);
+    TRACE_SCHEDULE_STYLE_INVALIDATION(rootNode, *m_typeRuleInvalidationSet,
+                                      typeInvalidation);
+  }
+}
+
+DescendantInvalidationSet& RuleFeatureSet::ensureTypeRuleInvalidationSet() {
+  if (!m_typeRuleInvalidationSet) {
+    m_typeRuleInvalidationSet = DescendantInvalidationSet::create();
+    m_typeRuleInvalidationSet->setAppliesToRuleSetInvalidations();
+  }
+  return *m_typeRuleInvalidationSet;
+}
+
 void RuleFeatureSet::addFeaturesToUniversalSiblingInvalidationSet(
     const InvalidationSetFeatures& siblingFeatures,
     const InvalidationSetFeatures& descendantFeatures) {
   SiblingInvalidationSet& universalSet =
       ensureUniversalSiblingInvalidationSet();
   addFeaturesToInvalidationSet(universalSet, siblingFeatures);
   universalSet.updateMaxDirectAdjacentSelectors(
       siblingFeatures.maxDirectAdjacentSelectors);
 
   if (&siblingFeatures == &descendantFeatures)
@@ skipping 19 matching lines @@
   maxDirectAdjacentSelectors =
       std::max(maxDirectAdjacentSelectors, other.maxDirectAdjacentSelectors);
   customPseudoElement |= other.customPseudoElement;
   hasBeforeOrAfter |= other.hasBeforeOrAfter;
   treeBoundaryCrossing |= other.treeBoundaryCrossing;
   insertionPointCrossing |= other.insertionPointCrossing;
   forceSubtree |= other.forceSubtree;
   contentPseudoCrossing |= other.contentPseudoCrossing;
   invalidatesSlotted |= other.invalidatesSlotted;
   hasNthPseudo |= other.hasNthPseudo;
+  setRuleSetInvalidationFeature(other.ruleSetInvalidationFeature,
+                                other.ruleSetInvalidationFeatureType);
 }
 
 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();
+void RuleFeatureSet::InvalidationSetFeatures::
+    setRuleSetFeatureFromSimpleSelector(const CSSSelector& selector) {
+  if (selector.match() == CSSSelector::Id) {
+    setRuleSetInvalidationFeature(selector.value(), RuleSetFeatureType::Id);
+    return;
+  }
+  if (selector.match() == CSSSelector::Class) {
+    setRuleSetInvalidationFeature(selector.value(), RuleSetFeatureType::Class);
+    return;
+  }
+  DCHECK(selector.isAttributeSelector());
+  setRuleSetInvalidationFeature(selector.attribute().localName(),
+                                RuleSetFeatureType::Attribute);
 }
 
 }  // namespace blink