Remove rulesets used for style sharing.

After style sharing code is removed, we no longer need the sibling and
uncommon attribute rulesets to reject style sharing. This also means
RuleFeatureSet no longer needs to be traced, so some oilpan cruft could
be removed.

The StyleEngine API UsesSiblingRules() relied on the size of the sibling
ruleset, but it was only used as what looked like an optimization for
:empty selector updates where :empty is found in non-rightmost compound
selectors. However, the presence of :empty itself would add a sibling
selector in the previous code, and :empty in non-rightmost compound not
followed by an adjacent selector would only have de-generate cases like
":empty span" which could never match anything, or ":not(:empty) span"
which would always be true if the whole selector matches. Therefore, it
makes sense to just drop the API/check.

Bug: 721517
Change-Id: I85100850cb8cec56b17947916d7755ebcf3f15ec
Reviewed-on: https://chromium-review.googlesource.com/597689Reviewed-by: nainar <nainar@chromium.org>
Reviewed-by: Morten Stenshorne <mstensho@opera.com>
Commit-Queue: Rune Lillesveen <rune@opera.com>
Cr-Commit-Position: refs/heads/master@{#491344}

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

@@ -172,7 +172,6 @@ bool CSSDefaultStyleSheets::EnsureDefaultStyleSheetsForElement(
   }
 
   DCHECK(!default_style_->Features().HasIdsInSelectors());
-  DCHECK(!default_style_->Features().UsesSiblingRules());
   return changed_default_style;
 }
 

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

@@ -29,20 +29,6 @@ void CSSGlobalRuleSet::InitWatchedSelectorsRuleSet(Document& document) {
   }
 }
 
-static RuleSet* MakeRuleSet(const HeapVector<RuleFeature>& rules) {
-  size_t size = rules.size();
-  if (!size)
-    return nullptr;
-  RuleSet* rule_set = RuleSet::Create();
-  for (size_t i = 0; i < size; ++i) {
-    rule_set->AddRule(rules[i].rule, rules[i].selector_index,
-                      rules[i].has_document_security_origin
-                          ? kRuleHasDocumentSecurityOrigin
-                          : kRuleHasNoSpecialState);
-  }
-  return rule_set;
-}
-
 void CSSGlobalRuleSet::Update(Document& document) {
   if (!is_dirty_)
     return;
@@ -65,25 +51,16 @@ void CSSGlobalRuleSet::Update(Document& document) {
     features_.Add(watched_selectors_rule_set_->Features());
 
   document.GetStyleEngine().CollectScopedStyleFeaturesTo(features_);
-
-  sibling_rule_set_ = MakeRuleSet(features_.SiblingRules());
-  uncommon_attribute_rule_set_ =
-      MakeRuleSet(features_.UncommonAttributeRules());
 }
 
 void CSSGlobalRuleSet::Dispose() {
   features_.Clear();
-  sibling_rule_set_ = nullptr;
-  uncommon_attribute_rule_set_ = nullptr;
   watched_selectors_rule_set_ = nullptr;
   has_fullscreen_ua_style_ = false;
   is_dirty_ = true;
 }
 
 DEFINE_TRACE(CSSGlobalRuleSet) {
-  visitor->Trace(features_);
-  visitor->Trace(sibling_rule_set_);
-  visitor->Trace(uncommon_attribute_rule_set_);
   visitor->Trace(watched_selectors_rule_set_);
 }
 

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

@@ -37,10 +37,6 @@ class CSSGlobalRuleSet : public GarbageCollectedFinalized<CSSGlobalRuleSet> {
     CHECK(features_.IsAlive());
     return features_;
   }
-  RuleSet* SiblingRuleSet() const { return sibling_rule_set_; }
-  RuleSet* UncommonAttributeRuleSet() const {
-    return uncommon_attribute_rule_set_;
-  }
   RuleSet* WatchedSelectorsRuleSet() const {
     return watched_selectors_rule_set_;
   }
@@ -53,8 +49,6 @@ class CSSGlobalRuleSet : public GarbageCollectedFinalized<CSSGlobalRuleSet> {
   // Constructed from rules in all TreeScopes including UA style and style
   // injected from extensions.
   RuleFeatureSet features_;
-  Member<RuleSet> sibling_rule_set_;
-  Member<RuleSet> uncommon_attribute_rule_set_;
 
   // Rules injected from extensions.
   Member<RuleSet> watched_selectors_rule_set_;

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

@@ -342,9 +342,6 @@ void ElementRuleCollector::DidMatchRule(
       return;
     style_->SetHasPseudoStyle(dynamic_pseudo);
   } else {
-    if (style_ && rule_data.ContainsUncommonAttributeSelector())
-      style_->SetUnique();
-
     matched_rules_.push_back(MatchedRule(
         &rule_data, result.specificity, cascade_order,
         match_request.style_sheet_index, match_request.style_sheet));

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

@@ -266,17 +266,6 @@ void ExtractInvalidationSets(InvalidationSet* invalidation_set,
 
 }  // anonymous namespace
 
-RuleFeature::RuleFeature(StyleRule* rule,
-                         unsigned selector_index,
-                         bool has_document_security_origin)
-    : rule(rule),
-      selector_index(selector_index),
-      has_document_security_origin(has_document_security_origin) {}
-
-DEFINE_TRACE(RuleFeature) {
-  visitor->Trace(rule);
-}
-
 RuleFeatureSet::RuleFeatureSet() : is_alive_(true) {}
 
 RuleFeatureSet::~RuleFeatureSet() {
@@ -820,17 +809,6 @@ RuleFeatureSet::SelectorPreMatch RuleFeatureSet::CollectFeaturesFromRuleData(
 
   metadata_.Add(metadata);
 
-  if (metadata.found_sibling_selector) {
-    sibling_rules_.push_back(
-        RuleFeature(rule_data.Rule(), rule_data.SelectorIndex(),
-                    rule_data.HasDocumentSecurityOrigin()));
-  }
-  if (rule_data.ContainsUncommonAttributeSelector()) {
-    uncommon_attribute_rules_.push_back(
-        RuleFeature(rule_data.Rule(), rule_data.SelectorIndex(),
-                    rule_data.HasDocumentSecurityOrigin()));
-  }
-
   UpdateInvalidationSets(rule_data);
   return kSelectorMayMatch;
 }
@@ -851,20 +829,6 @@ RuleFeatureSet::SelectorPreMatch RuleFeatureSet::CollectFeaturesFromSelector(
       case CSSSelector::kPseudoWindowInactive:
         metadata.uses_window_inactive_selector = true;
         break;
-      case CSSSelector::kPseudoEmpty:
-      case CSSSelector::kPseudoFirstChild:
-      case CSSSelector::kPseudoFirstOfType:
-      case CSSSelector::kPseudoLastChild:
-      case CSSSelector::kPseudoLastOfType:
-      case CSSSelector::kPseudoOnlyChild:
-      case CSSSelector::kPseudoOnlyOfType:
-      case CSSSelector::kPseudoNthChild:
-      case CSSSelector::kPseudoNthOfType:
-      case CSSSelector::kPseudoNthLastChild:
-      case CSSSelector::kPseudoNthLastOfType:
-        if (!metadata.found_insertion_point_crossing)
-          metadata.found_sibling_selector = true;
-        break;
       case CSSSelector::kPseudoHost:
       case CSSSelector::kPseudoHostContext:
         if (!found_host_pseudo && relation == CSSSelector::kSubSelector)
@@ -905,10 +869,6 @@ RuleFeatureSet::SelectorPreMatch RuleFeatureSet::CollectFeaturesFromSelector(
         metadata.max_direct_adjacent_selectors = max_direct_adjacent_selectors;
       max_direct_adjacent_selectors = 0;
     }
-
-    if (!metadata.found_insertion_point_crossing &&
-        current->IsAdjacentSelector())
-      metadata.found_sibling_selector = true;
   }
 
   DCHECK(!max_direct_adjacent_selectors);
@@ -925,7 +885,6 @@ void RuleFeatureSet::FeatureMetadata::Add(const FeatureMetadata& other) {
 void RuleFeatureSet::FeatureMetadata::Clear() {
   uses_first_line_rules = false;
   uses_window_inactive_selector = false;
-  found_sibling_selector = false;
   found_insertion_point_crossing = false;
   needs_full_recalc_for_rule_set_invalidation = false;
   max_direct_adjacent_selectors = 0;
@@ -960,8 +919,6 @@ void RuleFeatureSet::Add(const RuleFeatureSet& other) {
 
   metadata_.Add(other.metadata_);
 
-  sibling_rules_.AppendVector(other.sibling_rules_);
-  uncommon_attribute_rules_.AppendVector(other.uncommon_attribute_rules_);
   viewport_dependent_media_query_results_.AppendVector(
       other.viewport_dependent_media_query_results_);
   device_dependent_media_query_results_.AppendVector(
@@ -970,8 +927,6 @@ void RuleFeatureSet::Add(const RuleFeatureSet& other) {
 
 void RuleFeatureSet::Clear() {
   CHECK(is_alive_);
-  sibling_rules_.clear();
-  uncommon_attribute_rules_.clear();
   metadata_.Clear();
   class_invalidation_sets_.clear();
   attribute_invalidation_sets_.clear();
@@ -1214,11 +1169,6 @@ void RuleFeatureSet::AddFeaturesToUniversalSiblingInvalidationSet(
                                  descendant_features);
 }
 
-DEFINE_TRACE(RuleFeatureSet) {
-  visitor->Trace(sibling_rules_);
-  visitor->Trace(uncommon_attribute_rules_);
-}
-
 void RuleFeatureSet::InvalidationSetFeatures::Add(
     const InvalidationSetFeatures& other) {
   classes.AppendVector(other.classes);

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

@@ -38,30 +38,6 @@ class ContainerNode;
 struct InvalidationLists;
 class QualifiedName;
 class RuleData;
-class StyleRule;
-
-struct RuleFeature {
-  DISALLOW_NEW_EXCEPT_PLACEMENT_NEW();
-
- public:
-  RuleFeature(StyleRule*,
-              unsigned selector_index,
-              bool has_document_security_origin);
-
-  DECLARE_TRACE();
-
-  Member<StyleRule> rule;
-  unsigned selector_index;
-  bool has_document_security_origin;
-};
-
-}  // namespace blink
-
-// Declare the VectorTraits specialization before RuleFeatureSet
-// declares its vector members below.
-WTF_ALLOW_MOVE_AND_INIT_WITH_MEM_FUNCTIONS(blink::RuleFeature);
-
-namespace blink {
 
 class CORE_EXPORT RuleFeatureSet {
   DISALLOW_NEW();
@@ -78,7 +54,6 @@ class CORE_EXPORT RuleFeatureSet {
 
   SelectorPreMatch CollectFeaturesFromRuleData(const RuleData&);
 
-  bool UsesSiblingRules() const { return !sibling_rules_.IsEmpty(); }
   bool UsesFirstLineRules() const { return metadata_.uses_first_line_rules; }
   bool UsesWindowInactiveSelector() const {
     return metadata_.uses_window_inactive_selector;
@@ -105,11 +80,6 @@ class CORE_EXPORT RuleFeatureSet {
     return id_invalidation_sets_.Contains(id_value);
   }
 
-  const HeapVector<RuleFeature>& SiblingRules() const { return sibling_rules_; }
-  const HeapVector<RuleFeature>& UncommonAttributeRules() const {
-    return uncommon_attribute_rules_;
-  }
-
   const MediaQueryResultList& ViewportDependentMediaQueryResults() const {
     return viewport_dependent_media_query_results_;
   }
@@ -160,8 +130,6 @@ class CORE_EXPORT RuleFeatureSet {
 
   bool HasIdsInSelectors() const { return id_invalidation_sets_.size() > 0; }
 
-  DECLARE_TRACE();
-
   bool IsAlive() const { return is_alive_; }
 
  protected:
@@ -187,7 +155,6 @@ class CORE_EXPORT RuleFeatureSet {
 
     bool uses_first_line_rules = false;
     bool uses_window_inactive_selector = false;
-    bool found_sibling_selector = false;
     bool found_insertion_point_crossing = false;
     bool needs_full_recalc_for_rule_set_invalidation = false;
     unsigned max_direct_adjacent_selectors = 0;
@@ -295,8 +262,6 @@ class CORE_EXPORT RuleFeatureSet {
   RefPtr<SiblingInvalidationSet> universal_sibling_invalidation_set_;
   RefPtr<DescendantInvalidationSet> nth_invalidation_set_;
   RefPtr<DescendantInvalidationSet> type_rule_invalidation_set_;
-  HeapVector<RuleFeature> sibling_rules_;
-  HeapVector<RuleFeature> uncommon_attribute_rules_;
   MediaQueryResultList viewport_dependent_media_query_results_;
   MediaQueryResultList device_dependent_media_query_results_;
 

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

@@ -19,38 +19,6 @@
 
 namespace blink {
 
-// TODO(sof): consider making these part object helper abstractions
-// available from platform/heap/.
-
-template <typename T>
-class HeapPartObject final
-    : public GarbageCollectedFinalized<HeapPartObject<T>> {
- public:
-  static HeapPartObject* Create() { return new HeapPartObject; }
-
-  T* Get() { return &part_; }
-
-  DEFINE_INLINE_TRACE() { visitor->Trace(part_); }
-
- private:
-  HeapPartObject() {}
-
-  T part_;
-};
-
-template <typename T>
-class PersistentPartObject final {
-  DISALLOW_NEW();
-
- public:
-  PersistentPartObject() : part_(HeapPartObject<T>::Create()) {}
-
-  T* operator->() const { return (*part_).Get(); }
-
- private:
-  Persistent<HeapPartObject<T>> part_;
-};
-
 class RuleFeatureSetTest : public ::testing::Test {
  public:
   RuleFeatureSetTest() {}
@@ -73,25 +41,25 @@ class RuleFeatureSetTest : public ::testing::Test {
         StyleRule::Create(std::move(selector_list),
                           MutableStylePropertySet::Create(kHTMLStandardMode));
     RuleData rule_data(style_rule, 0, 0, kRuleHasNoSpecialState);
-    return rule_feature_set_->CollectFeaturesFromRuleData(rule_data);
+    return rule_feature_set_.CollectFeaturesFromRuleData(rule_data);
   }
 
-  void ClearFeatures() { rule_feature_set_->Clear(); }
+  void ClearFeatures() { rule_feature_set_.Clear(); }
 
   void CollectInvalidationSetsForClass(InvalidationLists& invalidation_lists,
                                        const AtomicString& class_name) const {
     Element* element = Traversal<HTMLElement>::FirstChild(
         *Traversal<HTMLElement>::FirstChild(*document_->body()));
-    rule_feature_set_->CollectInvalidationSetsForClass(invalidation_lists,
-                                                       *element, class_name);
+    rule_feature_set_.CollectInvalidationSetsForClass(invalidation_lists,
+                                                      *element, class_name);
   }
 
   void CollectInvalidationSetsForId(InvalidationLists& invalidation_lists,
                                     const AtomicString& id) const {
     Element* element = Traversal<HTMLElement>::FirstChild(
         *Traversal<HTMLElement>::FirstChild(*document_->body()));
-    rule_feature_set_->CollectInvalidationSetsForId(invalidation_lists,
-                                                    *element, id);
+    rule_feature_set_.CollectInvalidationSetsForId(invalidation_lists, *element,
+                                                   id);
   }
 
   void CollectInvalidationSetsForAttribute(
@@ -99,7 +67,7 @@ class RuleFeatureSetTest : public ::testing::Test {
       const QualifiedName& attribute_name) const {
     Element* element = Traversal<HTMLElement>::FirstChild(
         *Traversal<HTMLElement>::FirstChild(*document_->body()));
-    rule_feature_set_->CollectInvalidationSetsForAttribute(
+    rule_feature_set_.CollectInvalidationSetsForAttribute(
         invalidation_lists, *element, attribute_name);
   }
 
@@ -108,18 +76,18 @@ class RuleFeatureSetTest : public ::testing::Test {
       CSSSelector::PseudoType pseudo) const {
     Element* element = Traversal<HTMLElement>::FirstChild(
         *Traversal<HTMLElement>::FirstChild(*document_->body()));
-    rule_feature_set_->CollectInvalidationSetsForPseudoClass(invalidation_lists,
-                                                             *element, pseudo);
+    rule_feature_set_.CollectInvalidationSetsForPseudoClass(invalidation_lists,
+                                                            *element, pseudo);
   }
 
   void CollectUniversalSiblingInvalidationSet(
       InvalidationLists& invalidation_lists) {
-    rule_feature_set_->CollectUniversalSiblingInvalidationSet(
-        invalidation_lists, 1);
+    rule_feature_set_.CollectUniversalSiblingInvalidationSet(invalidation_lists,
+                                                             1);
   }
 
   void CollectNthInvalidationSet(InvalidationLists& invalidation_lists) {
-    rule_feature_set_->CollectNthInvalidationSet(invalidation_lists);
+    rule_feature_set_.CollectNthInvalidationSet(invalidation_lists);
   }
 
   const HashSet<AtomicString>& ClassSet(
@@ -256,21 +224,13 @@ class RuleFeatureSetTest : public ::testing::Test {
     EXPECT_TRUE(attributes.Contains(attribute));
   }
 
-  void ExpectSiblingRuleCount(unsigned count) {
-    EXPECT_EQ(count, rule_feature_set_->SiblingRules().size());
-  }
-
-  void ExpectUncommonAttributeRuleCount(unsigned count) {
-    EXPECT_EQ(count, rule_feature_set_->UncommonAttributeRules().size());
-  }
-
   void ExpectFullRecalcForRuleSetInvalidation(bool expected) {
     EXPECT_EQ(expected,
-              rule_feature_set_->NeedsFullRecalcForRuleSetInvalidation());
+              rule_feature_set_.NeedsFullRecalcForRuleSetInvalidation());
   }
 
  private:
-  PersistentPartObject<RuleFeatureSet> rule_feature_set_;
+  RuleFeatureSet rule_feature_set_;
   Persistent<Document> document_;
 };
 
@@ -477,143 +437,6 @@ TEST_F(RuleFeatureSetTest, nonMatchingHostContext) {
   ExpectNoInvalidation(invalidation_lists.descendants);
 }
 
-TEST_F(RuleFeatureSetTest, siblingRulesBeforeContentPseudo) {
-  EXPECT_EQ(RuleFeatureSet::kSelectorMayMatch,
-            CollectFeatures("a + b ::content .c"));
-  ExpectSiblingRuleCount(0);
-}
-
-TEST_F(RuleFeatureSetTest, siblingRulesBeforeContentPseudo2) {
-  EXPECT_EQ(RuleFeatureSet::kSelectorMayMatch,
-            CollectFeatures("a + ::content .b"));
-  ExpectSiblingRuleCount(0);
-}
-
-TEST_F(RuleFeatureSetTest, siblingRulesAfterContentPseudo) {
-  EXPECT_EQ(RuleFeatureSet::kSelectorMayMatch,
-            CollectFeatures(".a ::content .b + .c"));
-  ExpectSiblingRuleCount(1);
-}
-
-TEST_F(RuleFeatureSetTest, siblingRulesNthBeforeContentPseudo) {
-  EXPECT_EQ(RuleFeatureSet::kSelectorMayMatch,
-            CollectFeatures(":nth-child(2) ::content .a"));
-  ExpectSiblingRuleCount(0);
-}
-
-TEST_F(RuleFeatureSetTest, siblingRulesNthAfterContentPseudo) {
-  EXPECT_EQ(RuleFeatureSet::kSelectorMayMatch,
-            CollectFeatures(".a ::content :nth-child(2)"));
-  ExpectSiblingRuleCount(1);
-}
-
-TEST_F(RuleFeatureSetTest, siblingRulesBeforeSlotted) {
-  EXPECT_EQ(RuleFeatureSet::kSelectorMayMatch,
-            CollectFeatures(".a + ::slotted(.b)"));
-  ExpectSiblingRuleCount(0);
-}
-
-TEST_F(RuleFeatureSetTest, siblingRulesBeforeHost) {
-  EXPECT_EQ(RuleFeatureSet::kSelectorNeverMatches,
-            CollectFeatures(".a + :host(.b)"));
-  ExpectSiblingRuleCount(0);
-}
-
-TEST_F(RuleFeatureSetTest, siblingRulesBeforeHostContext) {
-  EXPECT_EQ(RuleFeatureSet::kSelectorNeverMatches,
-            CollectFeatures(".a + :host-context(.b)"));
-  ExpectSiblingRuleCount(0);
-}
-
-TEST_F(RuleFeatureSetTest, uncommonAttributeRulesAfterContentPseudo) {
-  EXPECT_EQ(RuleFeatureSet::kSelectorMayMatch,
-            CollectFeatures("div ::content [attr]"));
-  ExpectUncommonAttributeRuleCount(1);
-}
-
-TEST_F(RuleFeatureSetTest, uncommonAttributeRulesBeforeContentPseudo) {
-  EXPECT_EQ(RuleFeatureSet::kSelectorMayMatch,
-            CollectFeatures("[attr] ::content div"));
-  ExpectUncommonAttributeRuleCount(0);
-}
-
-TEST_F(RuleFeatureSetTest, uncommonAttributeRulesSlotted) {
-  EXPECT_EQ(RuleFeatureSet::kSelectorMayMatch,
-            CollectFeatures("::slotted([attr])"));
-  ExpectUncommonAttributeRuleCount(1);
-}
-
-TEST_F(RuleFeatureSetTest, uncommonAttributeRulesBeforeSlotted) {
-  EXPECT_EQ(RuleFeatureSet::kSelectorMayMatch,
-            CollectFeatures("[attr]::slotted(*)"));
-  ExpectUncommonAttributeRuleCount(0);
-}
-
-TEST_F(RuleFeatureSetTest, uncommonAttributeRulesHost) {
-  EXPECT_EQ(RuleFeatureSet::kSelectorMayMatch,
-            CollectFeatures(":host([attr])"));
-  ExpectUncommonAttributeRuleCount(1);
-}
-
-TEST_F(RuleFeatureSetTest, uncommonAttributeRulesBeforeHost) {
-  EXPECT_EQ(RuleFeatureSet::kSelectorNeverMatches,
-            CollectFeatures("[attr] :host"));
-  ExpectUncommonAttributeRuleCount(0);
-}
-
-TEST_F(RuleFeatureSetTest, uncommonAttributeRulesAfterHost) {
-  EXPECT_EQ(RuleFeatureSet::kSelectorNeverMatches,
-            CollectFeatures(":host[attr]"));
-  ExpectUncommonAttributeRuleCount(0);
-}
-
-TEST_F(RuleFeatureSetTest, uncommonAttributeRulesAfterHost2) {
-  EXPECT_EQ(RuleFeatureSet::kSelectorMayMatch, CollectFeatures(":host [attr]"));
-  ExpectUncommonAttributeRuleCount(1);
-}
-
-TEST_F(RuleFeatureSetTest, uncommonAttributeRulesHostBeforePseudo) {
-  EXPECT_EQ(RuleFeatureSet::kSelectorMayMatch,
-            CollectFeatures(":host([attr])::before"));
-  ExpectUncommonAttributeRuleCount(1);
-}
-
-TEST_F(RuleFeatureSetTest, uncommonAttributeRulesHostContext) {
-  EXPECT_EQ(RuleFeatureSet::kSelectorMayMatch,
-            CollectFeatures(":host-context([attr])"));
-  ExpectUncommonAttributeRuleCount(1);
-}
-
-TEST_F(RuleFeatureSetTest, uncommonAttributeRulesBeforeHostContext) {
-  EXPECT_EQ(RuleFeatureSet::kSelectorNeverMatches,
-            CollectFeatures("[attr] :host-context(div)"));
-  ExpectUncommonAttributeRuleCount(0);
-}
-
-TEST_F(RuleFeatureSetTest, uncommonAttributeRulesBeforeHostContext2) {
-  EXPECT_EQ(RuleFeatureSet::kSelectorNeverMatches,
-            CollectFeatures("[attr]:host-context(div)"));
-  ExpectUncommonAttributeRuleCount(0);
-}
-
-TEST_F(RuleFeatureSetTest, uncommonAttributeRulesAfterHostContext) {
-  EXPECT_EQ(RuleFeatureSet::kSelectorNeverMatches,
-            CollectFeatures(":host-context(*)[attr]"));
-  ExpectUncommonAttributeRuleCount(0);
-}
-
-TEST_F(RuleFeatureSetTest, uncommonAttributeRulesAfterHostContext2) {
-  EXPECT_EQ(RuleFeatureSet::kSelectorMayMatch,
-            CollectFeatures(":host-context(*) [attr]"));
-  ExpectUncommonAttributeRuleCount(1);
-}
-
-TEST_F(RuleFeatureSetTest, uncommonAttributeRulesAfterHostContextBeforePseudo) {
-  EXPECT_EQ(RuleFeatureSet::kSelectorMayMatch,
-            CollectFeatures(":host-context([attr])::before"));
-  ExpectUncommonAttributeRuleCount(1);
-}
-
 TEST_F(RuleFeatureSetTest, universalSiblingInvalidationDirectAdjacent) {
   EXPECT_EQ(RuleFeatureSet::kSelectorMayMatch, CollectFeatures("* + .a"));
 

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

@@ -49,57 +49,6 @@ namespace blink {
 
 using namespace HTMLNames;
 
-// -----------------------------------------------------------------
-
-static bool ContainsUncommonAttributeSelector(const CSSSelector&);
-
-static inline bool SelectorListContainsUncommonAttributeSelector(
-    const CSSSelector* selector) {
-  const CSSSelectorList* selector_list = selector->SelectorList();
-  if (!selector_list)
-    return false;
-  for (const CSSSelector* selector = selector_list->First(); selector;
-       selector = CSSSelectorList::Next(*selector)) {
-    if (ContainsUncommonAttributeSelector(*selector))
-      return true;
-  }
-  return false;
-}
-
-static inline bool IsCommonAttributeSelectorAttribute(
-    const QualifiedName& attribute) {
-  // These are explicitly tested for equality in canShareStyleWithElement.
-  return attribute == typeAttr || attribute == readonlyAttr;
-}
-
-static bool ContainsUncommonAttributeSelector(const CSSSelector& selector) {
-  const CSSSelector* current = &selector;
-  for (; current; current = current->TagHistory()) {
-    // Allow certain common attributes (used in the default style) in the
-    // selectors that match the current element.
-    if (current->IsAttributeSelector() &&
-        !IsCommonAttributeSelectorAttribute(current->Attribute()))
-      return true;
-    if (SelectorListContainsUncommonAttributeSelector(current))
-      return true;
-    if (current->RelationIsAffectedByPseudoContent() ||
-        current->GetPseudoType() == CSSSelector::kPseudoSlotted)
-      return false;
-    if (current->Relation() != CSSSelector::kSubSelector) {
-      current = current->TagHistory();
-      break;
-    }
-  }
-
-  for (; current; current = current->TagHistory()) {
-    if (current->IsAttributeSelector())
-      return true;
-    if (SelectorListContainsUncommonAttributeSelector(current))
-      return true;
-  }
-  return false;
-}
-
 static inline PropertyWhitelistType DeterminePropertyWhitelistType(
     const AddRuleFlags add_rule_flags,
     const CSSSelector& selector) {
@@ -124,8 +73,6 @@ RuleData::RuleData(StyleRule* rule,
       is_last_in_array_(false),
       position_(position),
       specificity_(Selector().Specificity()),
-      contains_uncommon_attribute_selector_(
-          blink::ContainsUncommonAttributeSelector(Selector())),
       link_match_type_(Selector().ComputeLinkMatchType()),
       has_document_security_origin_(add_rule_flags &
                                     kRuleHasDocumentSecurityOrigin),
@@ -441,7 +388,6 @@ DEFINE_TRACE(RuleSet) {
   visitor->Trace(placeholder_pseudo_rules_);
   visitor->Trace(universal_rules_);
   visitor->Trace(shadow_host_rules_);
-  visitor->Trace(features_);
   visitor->Trace(page_rules_);
   visitor->Trace(font_face_rules_);
   visitor->Trace(keyframes_rules_);

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

@@ -761,9 +761,7 @@ bool SelectorChecker::CheckPseudoClass(const SelectorCheckingContext& context,
         element.SetStyleAffectedByEmpty();
         if (context.in_rightmost_compound)
           element_style_->SetEmptyState(result);
-        else if (element.GetComputedStyle() &&
-                 (element.GetDocument().GetStyleEngine().UsesSiblingRules() ||
-                  element.GetComputedStyle()->Unique()))
+        else if (element.GetComputedStyle())
           element.MutableComputedStyle()->SetEmptyState(result);
       }
       return result;

third_party/WebKit/Source/core/dom/ElementShadowV0.cpp

@@ -260,7 +260,6 @@ void ElementShadowV0::ClearDistribution() {
 DEFINE_TRACE(ElementShadowV0) {
   visitor->Trace(element_shadow_);
   visitor->Trace(node_to_insertion_points_);
-  visitor->Trace(select_features_);
 }
 
 DEFINE_TRACE_WRAPPERS(ElementShadowV0) {}

third_party/WebKit/Source/core/dom/StyleEngine.h

@@ -168,9 +168,6 @@ class CORE_EXPORT StyleEngine final
   unsigned MaxDirectAdjacentSelectors() const {
     return GetRuleFeatureSet().MaxDirectAdjacentSelectors();
   }
-  bool UsesSiblingRules() const {
-    return GetRuleFeatureSet().UsesSiblingRules();
-  }
   bool UsesFirstLineRules() const {
     return GetRuleFeatureSet().UsesFirstLineRules();
   }