RuleSet invalidations on single feature only, including tags.

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

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc.
  * All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
@@ skipping 16 matching lines @@
 #include "core/css/CSSSelector.h"
 #include "core/css/MediaQueryEvaluator.h"
 #include "core/css/invalidation/InvalidationSet.h"
 #include "platform/heap/Handle.h"
 #include "wtf/Forward.h"
 #include "wtf/HashSet.h"
 #include "wtf/text/AtomicStringHash.h"
 
 namespace blink {
 
+class ContainerNode;
 struct InvalidationLists;
 class QualifiedName;
 class RuleData;
 class StyleRule;
 
 struct RuleFeature {
   DISALLOW_NEW_EXCEPT_PLACEMENT_NEW();
 
  public:
   RuleFeature(StyleRule*,
@@ skipping 68 matching lines @@
     return m_deviceDependentMediaQueryResults;
   }
   MediaQueryResultList& viewportDependentMediaQueryResults() {
     return m_viewportDependentMediaQueryResults;
   }
   MediaQueryResultList& deviceDependentMediaQueryResults() {
     return m_deviceDependentMediaQueryResults;
   }
 
   // Collect descendant and sibling invalidation sets.
-  void collectInvalidationSetsForClass(InvalidationLists&,
-                                       Element&,
-                                       const AtomicString& className) const;
-  void collectInvalidationSetsForId(InvalidationLists&,
-                                    Element&,
-                                    const AtomicString& id) const;
+
+  enum class InvalidationSetFilter {
+    None,
+    RuleSetInvalidation,
+  };
+
+  void collectInvalidationSetsForClass(
+      InvalidationLists&,
+      Element&,
+      const AtomicString& className,
+      InvalidationSetFilter = InvalidationSetFilter::None) const;
+  void collectInvalidationSetsForId(
+      InvalidationLists&,
+      Element&,
+      const AtomicString& id,
+      InvalidationSetFilter = InvalidationSetFilter::None) const;
   void collectInvalidationSetsForAttribute(
       InvalidationLists&,
       Element&,
-      const QualifiedName& attributeName) const;
+      const QualifiedName& attributeName,
+      InvalidationSetFilter = InvalidationSetFilter::None) const;
   void collectInvalidationSetsForPseudoClass(InvalidationLists&,
                                              Element&,
                                              CSSSelector::PseudoType) const;
 
   void collectSiblingInvalidationSetForClass(InvalidationLists&,
                                              Element&,
                                              const AtomicString& className,
                                              unsigned minDirectAdjacent) const;
   void collectSiblingInvalidationSetForId(InvalidationLists&,
                                           Element&,
                                           const AtomicString& id,
                                           unsigned minDirectAdjacent) const;
   void collectSiblingInvalidationSetForAttribute(
       InvalidationLists&,
       Element&,
       const QualifiedName& attributeName,
       unsigned minDirectAdjacent) const;
   void collectUniversalSiblingInvalidationSet(InvalidationLists&,
                                               unsigned minDirectAdjacent) const;
   void collectNthInvalidationSet(InvalidationLists&) const;
+  void collectTypeRuleInvalidationSet(InvalidationLists&, ContainerNode&) const;
 
   bool hasIdsInSelectors() const { return m_idInvalidationSets.size() > 0; }
 
   DECLARE_TRACE();
 
  protected:
   InvalidationSet* invalidationSetForSimpleSelector(const CSSSelector&,
                                                     InvalidationType);
 
  private:
@@ skipping 28 matching lines @@
                                               InvalidationType);
   InvalidationSet& ensureAttributeInvalidationSet(
       const AtomicString& attributeName,
       InvalidationType);
   InvalidationSet& ensureIdInvalidationSet(const AtomicString& id,
                                            InvalidationType);
   InvalidationSet& ensurePseudoInvalidationSet(CSSSelector::PseudoType,
                                                InvalidationType);
   SiblingInvalidationSet& ensureUniversalSiblingInvalidationSet();
   DescendantInvalidationSet& ensureNthInvalidationSet();
+  DescendantInvalidationSet& ensureTypeRuleInvalidationSet();
 
   void updateInvalidationSets(const RuleData&);
   void updateInvalidationSetsForContentAttribute(const RuleData&);
 
   struct InvalidationSetFeatures {
+    enum class RuleSetFeatureType {
+      None,
+      Tag,
+      Attribute,
+      Class,
+      Id,
+    };
+
     DISALLOW_NEW();
 
     void add(const InvalidationSetFeatures& other);
     bool hasFeatures() const;
-    bool hasTagIdClassOrAttribute() const;
+    bool hasRuleSetInvalidationFeature() const {
+      return ruleSetInvalidationFeatureType != RuleSetFeatureType::None;
+    }
+    void setRuleSetFeatureFromSimpleSelector(const CSSSelector&);
+    void setRuleSetInvalidationFeature(const AtomicString& feature,
+                                       RuleSetFeatureType type) {
+      if (type < ruleSetInvalidationFeatureType)
+        return;
+      ruleSetInvalidationFeature = feature;
+      ruleSetInvalidationFeatureType = type;
+    }
+    void clearRuleSetInvalidationFeature() {
+      ruleSetInvalidationFeature = AtomicString();
+      ruleSetInvalidationFeatureType = RuleSetFeatureType::None;
+    }
 
     Vector<AtomicString> classes;
     Vector<AtomicString> attributes;
     Vector<AtomicString> ids;
     Vector<AtomicString> tagNames;
+    AtomicString ruleSetInvalidationFeature;
     unsigned maxDirectAdjacentSelectors = 0;
     bool customPseudoElement = false;
     bool hasBeforeOrAfter = false;
     bool treeBoundaryCrossing = false;
     bool insertionPointCrossing = false;
     bool forceSubtree = false;
     bool contentPseudoCrossing = false;
     bool invalidatesSlotted = false;
     bool hasNthPseudo = false;
-    bool hasFeaturesForRuleSetInvalidation = false;
+    RuleSetFeatureType ruleSetInvalidationFeatureType =
+        InvalidationSetFeatures::RuleSetFeatureType::None;
   };
 
   static void extractInvalidationSetFeature(const CSSSelector&,
                                             InvalidationSetFeatures&);
 
   enum PositionType { Subject, Ancestor };
   enum FeatureInvalidationType {
     NormalInvalidation,
     RequiresSubtreeInvalidation
   };
@@ skipping 33 matching lines @@
       InvalidationSetFeatures& descendantFeatures);
   void addFeaturesToInvalidationSetsForSelectorList(
       const CSSSelector&,
       InvalidationSetFeatures* siblingFeatures,
       InvalidationSetFeatures& descendantFeatures);
   void addFeaturesToUniversalSiblingInvalidationSet(
       const InvalidationSetFeatures& siblingFeatures,
       const InvalidationSetFeatures& descendantFeatures);
 
   void addClassToInvalidationSet(const AtomicString& className, Element&);
+  void processRuleSetInvalidationFeature(const InvalidationSetFeatures&);
 
   FeatureMetadata m_metadata;
   InvalidationSetMap m_classInvalidationSets;
   InvalidationSetMap m_attributeInvalidationSets;
   InvalidationSetMap m_idInvalidationSets;
   PseudoTypeInvalidationSetMap m_pseudoInvalidationSets;
   RefPtr<SiblingInvalidationSet> m_universalSiblingInvalidationSet;
   RefPtr<DescendantInvalidationSet> m_nthInvalidationSet;
+  RefPtr<DescendantInvalidationSet> m_typeRuleInvalidationSet;
   HeapVector<RuleFeature> m_siblingRules;
   HeapVector<RuleFeature> m_uncommonAttributeRules;
   MediaQueryResultList m_viewportDependentMediaQueryResults;
   MediaQueryResultList m_deviceDependentMediaQueryResults;
 
   friend class RuleFeatureSetTest;
 };
 
 }  // namespace blink
 
 #endif  // RuleFeature_h