Use invalidation sets for nth invalidations.

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

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "core/css/RuleFeature.h"
 
 #include "core/css/CSSSelectorList.h"
 #include "core/css/RuleSet.h"
 #include "core/css/StylePropertySet.h"
 #include "core/css/StyleRule.h"
@@ skipping 96 matching lines @@
     {
         Element* element = Traversal<HTMLElement>::firstChild(*Traversal<HTMLElement>::firstChild(*m_document->body()));
         m_ruleFeatureSet->collectInvalidationSetsForPseudoClass(invalidationLists, *element, pseudo);
     }
 
     void collectUniversalSiblingInvalidationSet(InvalidationLists& invalidationLists)
     {
         m_ruleFeatureSet->collectUniversalSiblingInvalidationSet(invalidationLists, 1);
     }
 
+    void collectNthInvalidationSet(InvalidationLists& invalidationLists)
+    {
+        m_ruleFeatureSet->collectNthInvalidationSet(invalidationLists);
+    }
+
     const HashSet<AtomicString>& classSet(const InvalidationSet& invalidationSet)
     {
         return invalidationSet.classSetForTesting();
     }
 
     const HashSet<AtomicString>& idSet(const InvalidationSet& invalidationSet)
     {
         return invalidationSet.idSetForTesting();
     }
 
@@ skipping 17 matching lines @@
         EXPECT_EQ(1u, invalidationSets.size());
         EXPECT_TRUE(invalidationSets[0]->invalidatesSelf());
     }
 
     void expectNoSelfInvalidation(InvalidationSetVector& invalidationSets)
     {
         EXPECT_EQ(1u, invalidationSets.size());
         EXPECT_FALSE(invalidationSets[0]->invalidatesSelf());
     }
 
+    void expectWholeSubtreeInvalidation(InvalidationSetVector& invalidationSets)
+    {
+        EXPECT_EQ(1u, invalidationSets.size());
+        EXPECT_TRUE(invalidationSets[0]->wholeSubtreeInvalid());
+    }
+
     void expectClassInvalidation(const AtomicString& className, InvalidationSetVector& invalidationSets)
     {
         EXPECT_EQ(1u, invalidationSets.size());
         HashSet<AtomicString> classes = classSet(*invalidationSets[0]);
         EXPECT_EQ(1u, classes.size());
         EXPECT_TRUE(classes.contains(className));
     }
 
     void expectSiblingInvalidation(unsigned maxDirectAdjacentSelectors, const AtomicString& siblingName, InvalidationSetVector& invalidationSets)
     {
@@ skipping 552 matching lines @@
 TEST_F(RuleFeatureSetTest, nonUniversalSiblingInvalidationLink)
 {
     EXPECT_EQ(RuleFeatureSet::SelectorMayMatch, collectFeatures("#x:link + .a"));
 
     InvalidationLists invalidationLists;
     collectUniversalSiblingInvalidationSet(invalidationLists);
 
     expectNoInvalidation(invalidationLists.siblings);
 }
 
+TEST_F(RuleFeatureSetTest, nthInvalidationUniversal)
+{
+    EXPECT_EQ(RuleFeatureSet::SelectorMayMatch, collectFeatures(":nth-child(2n)"));
+
+    InvalidationLists invalidationLists;
+    collectNthInvalidationSet(invalidationLists);
+
+    expectNoSelfInvalidation(invalidationLists.descendants);
+    expectWholeSubtreeInvalidation(invalidationLists.descendants);
+}
+
+TEST_F(RuleFeatureSetTest, nthInvalidationClass)
+{
+    EXPECT_EQ(RuleFeatureSet::SelectorMayMatch, collectFeatures(".a:nth-child(2n)"));
+
+    InvalidationLists invalidationLists;
+    collectNthInvalidationSet(invalidationLists);
+
+    expectNoSelfInvalidation(invalidationLists.descendants);
+    expectClassInvalidation("a", invalidationLists.descendants);
+}
+
+TEST_F(RuleFeatureSetTest, nthInvalidationUniversalDescendant)
+{
+    EXPECT_EQ(RuleFeatureSet::SelectorMayMatch, collectFeatures(":nth-child(2n) *"));
+
+    InvalidationLists invalidationLists;
+    collectNthInvalidationSet(invalidationLists);
+
+    expectNoSelfInvalidation(invalidationLists.descendants);
+    expectWholeSubtreeInvalidation(invalidationLists.descendants);
+}
+
+TEST_F(RuleFeatureSetTest, nthInvalidationDescendant)
+{
+    EXPECT_EQ(RuleFeatureSet::SelectorMayMatch, collectFeatures(":nth-child(2n) .a"));
+
+    InvalidationLists invalidationLists;
+    collectNthInvalidationSet(invalidationLists);
+
+    expectNoSelfInvalidation(invalidationLists.descendants);
+    expectClassInvalidation("a", invalidationLists.descendants);
+}
+
+TEST_F(RuleFeatureSetTest, nthInvalidationSibling)
+{
+    EXPECT_EQ(RuleFeatureSet::SelectorMayMatch, collectFeatures(":nth-child(2n) + .a"));
+
+    InvalidationLists invalidationLists;
+    collectNthInvalidationSet(invalidationLists);
+
+    expectNoInvalidation(invalidationLists.siblings);
+    expectNoSelfInvalidation(invalidationLists.descendants);
+    expectClassInvalidation("a", invalidationLists.descendants);
+}
+
+TEST_F(RuleFeatureSetTest, nthInvalidationSiblingDescendant)
+{
+    EXPECT_EQ(RuleFeatureSet::SelectorMayMatch, collectFeatures(":nth-child(2n) + .a .b"));
+
+    InvalidationLists invalidationLists;
+    collectNthInvalidationSet(invalidationLists);
+
+    expectNoInvalidation(invalidationLists.siblings);
+    expectNoSelfInvalidation(invalidationLists.descendants);
+    expectClassInvalidation("b", invalidationLists.descendants);
+}
+
+TEST_F(RuleFeatureSetTest, nthInvalidationNot)
+{
+    EXPECT_EQ(RuleFeatureSet::SelectorMayMatch, collectFeatures(":not(:nth-child(2n))"));
+
+    InvalidationLists invalidationLists;
+    collectNthInvalidationSet(invalidationLists);
+
+    expectNoSelfInvalidation(invalidationLists.descendants);
+    expectWholeSubtreeInvalidation(invalidationLists.descendants);
+}
+
+TEST_F(RuleFeatureSetTest, nthInvalidationNotClass)
+{
+    EXPECT_EQ(RuleFeatureSet::SelectorMayMatch, collectFeatures(".a:not(:nth-child(2n))"));
+
+    InvalidationLists invalidationLists;
+    collectNthInvalidationSet(invalidationLists);
+
+    expectNoSelfInvalidation(invalidationLists.descendants);
+    expectClassInvalidation("a", invalidationLists.descendants);
+}
+
+TEST_F(RuleFeatureSetTest, nthInvalidationNotDescendant)
+{
+    EXPECT_EQ(RuleFeatureSet::SelectorMayMatch, collectFeatures(".blah:not(:nth-child(2n)) .a"));
+
+    InvalidationLists invalidationLists;
+    collectNthInvalidationSet(invalidationLists);
+
+    expectNoSelfInvalidation(invalidationLists.descendants);
+    expectClassInvalidation("a", invalidationLists.descendants);
+}
+
+TEST_F(RuleFeatureSetTest, nthInvalidationAny)
+{
+    EXPECT_EQ(RuleFeatureSet::SelectorMayMatch, collectFeatures(":-webkit-any(#nomatch, :nth-child(2n))"));
+
+    InvalidationLists invalidationLists;
+    collectNthInvalidationSet(invalidationLists);
+
+    expectNoSelfInvalidation(invalidationLists.descendants);
+    expectWholeSubtreeInvalidation(invalidationLists.descendants);
+}
+
+TEST_F(RuleFeatureSetTest, nthInvalidationAnyClass)
+{
+    EXPECT_EQ(RuleFeatureSet::SelectorMayMatch, collectFeatures(".a:-webkit-any(#nomatch, :nth-child(2n))"));
+
+    InvalidationLists invalidationLists;
+    collectNthInvalidationSet(invalidationLists);
+
+    expectNoSelfInvalidation(invalidationLists.descendants);
+    expectClassInvalidation("a", invalidationLists.descendants);
+}
+
+TEST_F(RuleFeatureSetTest, nthInvalidationAnyDescendant)
+{
+    EXPECT_EQ(RuleFeatureSet::SelectorMayMatch, collectFeatures(".blah:-webkit-any(#nomatch, :nth-child(2n)) .a"));
+
+    InvalidationLists invalidationLists;
+    collectNthInvalidationSet(invalidationLists);
+
+    expectNoSelfInvalidation(invalidationLists.descendants);
+    expectClassInvalidation("a", invalidationLists.descendants);
+}
+
 } // namespace blink