Prepare to use invalidation set for adding/removing RuleSets.

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 67 matching lines @@
 
     RuleFeatureSet::SelectorPreMatch collectFeatures(const String& selectorText)
     {
         CSSSelectorList selectorList = CSSParser::parseSelector(strictCSSParserContext(), nullptr, selectorText);
 
         StyleRule* styleRule = StyleRule::create(std::move(selectorList), MutableStylePropertySet::create(HTMLStandardMode));
         RuleData ruleData(styleRule, 0, 0, RuleHasNoSpecialState);
         return m_ruleFeatureSet->collectFeaturesFromRuleData(ruleData);
     }
 
+    void clearFeatures()
+    {
+        m_ruleFeatureSet->clear();
+    }
+
     void collectInvalidationSetsForClass(InvalidationLists& invalidationLists, const AtomicString& className) const
     {
         Element* element = Traversal<HTMLElement>::firstChild(*Traversal<HTMLElement>::firstChild(*m_document->body()));
         m_ruleFeatureSet->collectInvalidationSetsForClass(invalidationLists, *element, className);
     }
 
     void collectInvalidationSetsForId(InvalidationLists& invalidationLists, const AtomicString& id) const
     {
         Element* element = Traversal<HTMLElement>::firstChild(*Traversal<HTMLElement>::firstChild(*m_document->body()));
         m_ruleFeatureSet->collectInvalidationSetsForId(invalidationLists, *element, id);
@@ skipping 150 matching lines @@
     void expectSiblingRuleCount(unsigned count)
     {
         EXPECT_EQ(count, m_ruleFeatureSet->siblingRules.size());
     }
 
     void expectUncommonAttributeRuleCount(unsigned count)
     {
         EXPECT_EQ(count, m_ruleFeatureSet->uncommonAttributeRules.size());
     }
 
+    void expectFullRecalcForRuleSetInvalidation(bool expected)
+    {
+        EXPECT_EQ(expected, m_ruleFeatureSet->needsFullRecalcForRuleSetInvalidation());
+    }
+
 private:
     PersistentPartObject<RuleFeatureSet> m_ruleFeatureSet;
     Persistent<Document> m_document;
 };
 
 TEST_F(RuleFeatureSetTest, interleavedDescendantSibling1)
 {
     EXPECT_EQ(RuleFeatureSet::SelectorMayMatch, collectFeatures(".p"));
 
     InvalidationLists invalidationLists;
@@ skipping 630 matching lines @@
 {
     EXPECT_EQ(RuleFeatureSet::SelectorMayMatch, collectFeatures(".blah:-webkit-any(#nomatch, :nth-child(2n)) .a"));
 
     InvalidationLists invalidationLists;
     collectNthInvalidationSet(invalidationLists);
 
     expectNoSelfInvalidation(invalidationLists.descendants);
     expectClassInvalidation("a", invalidationLists.descendants);
 }
 
+TEST_F(RuleFeatureSetTest, RuleSetInvalidationTypeSelector)
+{
+    EXPECT_EQ(RuleFeatureSet::SelectorMayMatch, collectFeatures("div"));
+    expectFullRecalcForRuleSetInvalidation(false);
+    clearFeatures();
+
+    EXPECT_EQ(RuleFeatureSet::SelectorMayMatch, collectFeatures("* div"));
+    expectFullRecalcForRuleSetInvalidation(false);
+    clearFeatures();
+
+    EXPECT_EQ(RuleFeatureSet::SelectorMayMatch, collectFeatures("body *"));
+    expectFullRecalcForRuleSetInvalidation(true);
+}
+
+TEST_F(RuleFeatureSetTest, RuleSetInvalidationClassIdAttr)
+{
+    EXPECT_EQ(RuleFeatureSet::SelectorMayMatch, collectFeatures(".c"));
+    expectFullRecalcForRuleSetInvalidation(false);
+    clearFeatures();
+
+    EXPECT_EQ(RuleFeatureSet::SelectorMayMatch, collectFeatures(".c *"));
+    expectFullRecalcForRuleSetInvalidation(false);
+    clearFeatures();
+
+    EXPECT_EQ(RuleFeatureSet::SelectorMayMatch, collectFeatures("#i"));
+    expectFullRecalcForRuleSetInvalidation(false);
+    clearFeatures();
+
+    EXPECT_EQ(RuleFeatureSet::SelectorMayMatch, collectFeatures("#i *"));
+    expectFullRecalcForRuleSetInvalidation(false);
+    clearFeatures();
+
+    EXPECT_EQ(RuleFeatureSet::SelectorMayMatch, collectFeatures("[attr]"));
+    expectFullRecalcForRuleSetInvalidation(false);
+    clearFeatures();
+
+    EXPECT_EQ(RuleFeatureSet::SelectorMayMatch, collectFeatures("[attr] *"));
+    expectFullRecalcForRuleSetInvalidation(false);
+}
+
+TEST_F(RuleFeatureSetTest, RuleSetInvalidationHoverActiveFocus)
+{
+    EXPECT_EQ(RuleFeatureSet::SelectorMayMatch, collectFeatures(":hover:active:focus"));
+    expectFullRecalcForRuleSetInvalidation(true);
+}
+
+TEST_F(RuleFeatureSetTest, RuleSetInvalidationHostContext)
+{
+    EXPECT_EQ(RuleFeatureSet::SelectorMayMatch, collectFeatures(":host-context(.x)"));
+    expectFullRecalcForRuleSetInvalidation(true);
+    clearFeatures();
+
+    EXPECT_EQ(RuleFeatureSet::SelectorMayMatch, collectFeatures(":host-context(.x) .y"));
+    expectFullRecalcForRuleSetInvalidation(false);
+}
+
+TEST_F(RuleFeatureSetTest, RuleSetInvalidationHost)
+{
+    EXPECT_EQ(RuleFeatureSet::SelectorMayMatch, collectFeatures(":host(.x)"));
+    expectFullRecalcForRuleSetInvalidation(false);
+    clearFeatures();
+
+    EXPECT_EQ(RuleFeatureSet::SelectorMayMatch, collectFeatures(":host(*) .y"));
+    expectFullRecalcForRuleSetInvalidation(false);
+    clearFeatures();
+
+    EXPECT_EQ(RuleFeatureSet::SelectorMayMatch, collectFeatures(":host(.x) .y"));
+    expectFullRecalcForRuleSetInvalidation(false);
+}
+
+TEST_F(RuleFeatureSetTest, RuleSetInvalidationNot)
+{
+    EXPECT_EQ(RuleFeatureSet::SelectorMayMatch, collectFeatures(":not(.x)"));
+    expectFullRecalcForRuleSetInvalidation(true);
+    clearFeatures();
+
+    EXPECT_EQ(RuleFeatureSet::SelectorMayMatch, collectFeatures(":not(.x) :hover"));
+    expectFullRecalcForRuleSetInvalidation(true);
+    clearFeatures();
+
+    EXPECT_EQ(RuleFeatureSet::SelectorMayMatch, collectFeatures(":not(.x) .y"));
+    expectFullRecalcForRuleSetInvalidation(false);
+    clearFeatures();
+
+    EXPECT_EQ(RuleFeatureSet::SelectorMayMatch, collectFeatures(":not(.x) + .y"));
+    expectFullRecalcForRuleSetInvalidation(false);
+}
+
+TEST_F(RuleFeatureSetTest, RuleSetInvalidationCustomPseudo)
+{
+    EXPECT_EQ(RuleFeatureSet::SelectorMayMatch, collectFeatures("::-webkit-slider-thumb"));
+    expectFullRecalcForRuleSetInvalidation(true);
+    clearFeatures();
+
+    EXPECT_EQ(RuleFeatureSet::SelectorMayMatch, collectFeatures(".x::-webkit-slider-thumb"));
+    expectFullRecalcForRuleSetInvalidation(false);
+    clearFeatures();
+
+    EXPECT_EQ(RuleFeatureSet::SelectorMayMatch, collectFeatures(".x + ::-webkit-slider-thumb"));
+    expectFullRecalcForRuleSetInvalidation(false);
+}
+
+TEST_F(RuleFeatureSetTest, RuleSetInvalidationDeep)
+{
+    EXPECT_EQ(RuleFeatureSet::SelectorMayMatch, collectFeatures("* /deep/ .x"));
+    expectFullRecalcForRuleSetInvalidation(true);
+    clearFeatures();
+
+    EXPECT_EQ(RuleFeatureSet::SelectorMayMatch, collectFeatures("body /deep/ .x"));
+    expectFullRecalcForRuleSetInvalidation(true);
+    clearFeatures();
+
+    EXPECT_EQ(RuleFeatureSet::SelectorMayMatch, collectFeatures("#x /deep/ .y"));
+    expectFullRecalcForRuleSetInvalidation(false);
+    clearFeatures();
+
+    EXPECT_EQ(RuleFeatureSet::SelectorMayMatch, collectFeatures("#x /deep/ *"));
+    expectFullRecalcForRuleSetInvalidation(false);
+}
+
+TEST_F(RuleFeatureSetTest, RuleSetInvalidationShadow)
+{
+    EXPECT_EQ(RuleFeatureSet::SelectorMayMatch, collectFeatures("*::shadow .x"));
+    expectFullRecalcForRuleSetInvalidation(true);
+    clearFeatures();
+
+    EXPECT_EQ(RuleFeatureSet::SelectorMayMatch, collectFeatures(".x::shadow *"));
+    expectFullRecalcForRuleSetInvalidation(false);
+    clearFeatures();
+
+    EXPECT_EQ(RuleFeatureSet::SelectorMayMatch, collectFeatures("[x] ::shadow .y"));
+    expectFullRecalcForRuleSetInvalidation(false);
+}
+
+TEST_F(RuleFeatureSetTest, RuleSetInvalidationContent)
+{
+    EXPECT_EQ(RuleFeatureSet::SelectorMayMatch, collectFeatures("*::content .x"));
+    expectFullRecalcForRuleSetInvalidation(true);
+    clearFeatures();
+
+    EXPECT_EQ(RuleFeatureSet::SelectorMayMatch, collectFeatures(".x::content *"));
+    expectFullRecalcForRuleSetInvalidation(false);
+    clearFeatures();
+
+    EXPECT_EQ(RuleFeatureSet::SelectorMayMatch, collectFeatures("[x] ::content .y"));
+    expectFullRecalcForRuleSetInvalidation(false);

[rune, 2016/09/14 07:47:31]

This is not going to work since we're collecting features for tree boundary
crossing rules for the m_treeBoundaryCrossingRuleSet, not the stylesheet
ruleset.

+}
+
+TEST_F(RuleFeatureSetTest, RuleSetInvalidationSlotted)
+{
+    EXPECT_EQ(RuleFeatureSet::SelectorMayMatch, collectFeatures("::slotted(*)"));
+    expectFullRecalcForRuleSetInvalidation(true);
+    clearFeatures();
+
+    EXPECT_EQ(RuleFeatureSet::SelectorMayMatch, collectFeatures("::slotted(.y)"));
+    expectFullRecalcForRuleSetInvalidation(false);
+    clearFeatures();
+
+    EXPECT_EQ(RuleFeatureSet::SelectorMayMatch, collectFeatures(".x::slotted(.y)"));
+    expectFullRecalcForRuleSetInvalidation(false);
+    clearFeatures();
+
+    EXPECT_EQ(RuleFeatureSet::SelectorMayMatch, collectFeatures("[x] ::slotted(.y)"));
+    expectFullRecalcForRuleSetInvalidation(false);
+}
+
+TEST_F(RuleFeatureSetTest, RuleSetInvalidationAnyPseudo)
+{
+    EXPECT_EQ(RuleFeatureSet::SelectorMayMatch, collectFeatures(":-webkit-any(*, #x)"));
+    expectFullRecalcForRuleSetInvalidation(true);
+    clearFeatures();
+
+    EXPECT_EQ(RuleFeatureSet::SelectorMayMatch, collectFeatures(".x:-webkit-any(*, #y)"));
+    expectFullRecalcForRuleSetInvalidation(false);
+    clearFeatures();
+
+    EXPECT_EQ(RuleFeatureSet::SelectorMayMatch, collectFeatures(":-webkit-any(:-webkit-any(.a, .b), #x)"));
+    expectFullRecalcForRuleSetInvalidation(false);
+    clearFeatures();
+
+    EXPECT_EQ(RuleFeatureSet::SelectorMayMatch, collectFeatures(":-webkit-any(:-webkit-any(.a, *), #x)"));
+    expectFullRecalcForRuleSetInvalidation(true);
+    clearFeatures();
+
+    EXPECT_EQ(RuleFeatureSet::SelectorMayMatch, collectFeatures(":-webkit-any(*, .a) *"));
+    expectFullRecalcForRuleSetInvalidation(true);
+}
+
 } // namespace blink