Don't add siblingRules with combinator left of ::content.

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 26 matching lines @@
 
     void updateInvalidationSets(const String& selectorText)
     {
         CSSSelectorList selectorList = CSSParser::parseSelector(strictCSSParserContext(), nullptr, selectorText);
 
         RefPtrWillBeRawPtr<StyleRule> styleRule = StyleRule::create(std::move(selectorList), MutableStylePropertySet::create(HTMLStandardMode));
         RuleData ruleData(styleRule.get(), 0, 0, RuleHasNoSpecialState);
         m_ruleFeatureSet.updateInvalidationSets(ruleData);
     }
 
+    void collectFeatures(const String& selectorText)
+    {
+        CSSSelectorList selectorList = CSSParser::parseSelector(strictCSSParserContext(), nullptr, selectorText);
+
+        RefPtrWillBeRawPtr<StyleRule> styleRule = StyleRule::create(std::move(selectorList), MutableStylePropertySet::create(HTMLStandardMode));
+        RuleData ruleData(styleRule.get(), 0, 0, RuleHasNoSpecialState);
+        m_ruleFeatureSet.collectFeaturesFromRuleData(ruleData);
+    }
+
     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 106 matching lines @@
     }
 
     void expectAttributeInvalidation(const AtomicString& attribute, InvalidationSetVector& invalidationSets)
     {
         EXPECT_EQ(1u, invalidationSets.size());
         HashSet<AtomicString> attributes = attributeSet(*invalidationSets[0]);
         EXPECT_EQ(1u, attributes.size());
         EXPECT_TRUE(attributes.contains(attribute));
     }
 
+    void expectSiblingRuleCount(unsigned count)
+    {
+        EXPECT_EQ(count, m_ruleFeatureSet.siblingRules.size());
+    }
+
     DEFINE_INLINE_TRACE()
     {
 #if ENABLE(OILPAN)
         visitor->trace(m_ruleFeatureSet);
         visitor->trace(m_document);
 #endif
     }
 
 private:
     RuleFeatureSet m_ruleFeatureSet;
@@ skipping 147 matching lines @@
     collectInvalidationSetsForClass(invalidationLists, "a");
     expectClassInvalidation("c", invalidationLists.descendants);
 
     updateInvalidationSets(".a .b");
 
     invalidationLists.descendants.clear();
     collectInvalidationSetsForClass(invalidationLists, "a");
     expectClassesInvalidation("b", "c", invalidationLists.descendants);
 }
 
+TEST_F(RuleFeatureSetTest, siblingRulesBeforeContentPseudo)
+{
+    collectFeatures("a + b ::content .c");
+    expectSiblingRuleCount(0);
+}
+
+TEST_F(RuleFeatureSetTest, siblingRulesAfterContentPseudo)
+{
+    collectFeatures(".a ::content .b + .c");
+    expectSiblingRuleCount(1);
+}
+
+TEST_F(RuleFeatureSetTest, siblingRulesNthBeforeContentPseudo)
+{
+    collectFeatures(":nth-child(2) ::content .a");
+    expectSiblingRuleCount(0);
+}
+
+TEST_F(RuleFeatureSetTest, siblingRulesNthAfterContentPseudo)
+{
+    collectFeatures(".a ::content :nth-child(2)");
+    expectSiblingRuleCount(1);
+}
+
+TEST_F(RuleFeatureSetTest, siblingRulesBeforeDeep)
+{
+    collectFeatures("a + b /deep/ .c");
+    expectSiblingRuleCount(1);
+}
+
+TEST_F(RuleFeatureSetTest, siblingRulesAfterDeep)
+{
+    collectFeatures(".a /deep/ .b + .c");
+    expectSiblingRuleCount(1);
+}
+
+TEST_F(RuleFeatureSetTest, siblingRulesBeforeShadow)
+{
+    collectFeatures(".a + .b::shadow .c");
+    expectSiblingRuleCount(1);
+}
+
+TEST_F(RuleFeatureSetTest, siblingRulesAfterShadow)
+{
+    collectFeatures(".a ::shadow .b + .c");
+    expectSiblingRuleCount(1);
+}
+
+TEST_F(RuleFeatureSetTest, siblingRulesBeforeSlotted)
+{
+    collectFeatures(".a + ::slotted(.b)");
+    expectSiblingRuleCount(1);
+}
+
 } // namespace blink