Put unqualified pseudos into the more specific rulesets.

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

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 2004-2005 Allan Sandfeld Jensen (kde@carewolf.com)
  * Copyright (C) 2006, 2007 Nicholas Shanks (webkit@nickshanks.com)
  * Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012 Apple Inc. All
  * rights reserved.
  * Copyright (C) 2007 Alexey Proskuryakov <ap@webkit.org>
  * Copyright (C) 2007, 2008 Eric Seidel <eric@webkit.org>
  * Copyright (C) 2008, 2009 Torch Mobile Inc. All rights reserved.
  * (http://www.torchmobile.com/)
@@ skipping 129 matching lines @@
 void RuleSet::AddToRuleSet(const AtomicString& key,
                            PendingRuleMap& map,
                            const RuleData& rule_data) {
   Member<HeapLinkedStack<RuleData>>& rules =
       map.insert(key, nullptr).stored_value->value;
   if (!rules)
     rules = new HeapLinkedStack<RuleData>;
   rules->Push(rule_data);
 }
 
-static void ExtractValuesforSelector(const CSSSelector* selector,
-                                     AtomicString& id,
-                                     AtomicString& class_name,
-                                     AtomicString& custom_pseudo_element_name,
-                                     AtomicString& tag_name) {
+static void ExtractSelectorValues(const CSSSelector* selector,
+                                  AtomicString& id,
+                                  AtomicString& class_name,
+                                  AtomicString& custom_pseudo_element_name,
+                                  AtomicString& tag_name,
+                                  CSSSelector::PseudoType& pseudoType) {

[rune, 2017/05/10 08:46:02]

camelCase?

   switch (selector->Match()) {
     case CSSSelector::kId:
       id = selector->Value();
       break;
     case CSSSelector::kClass:
       class_name = selector->Value();
       break;
     case CSSSelector::kTag:
       if (selector->TagQName().LocalName() != g_star_atom)
         tag_name = selector->TagQName().LocalName();
       break;
+    case CSSSelector::kPseudoClass:
+    case CSSSelector::kPseudoElement:
+    case CSSSelector::kPagePseudoClass:
+      // Must match the cases in RuleSet::FindBestRuleSetAndAdd.
+      switch (selector->GetPseudoType()) {
+        case CSSSelector::kPseudoCue:
+        case CSSSelector::kPseudoLink:
+        case CSSSelector::kPseudoVisited:
+        case CSSSelector::kPseudoAnyLink:
+        case CSSSelector::kPseudoFocus:
+        case CSSSelector::kPseudoPlaceholder:
+        case CSSSelector::kPseudoHost:
+        case CSSSelector::kPseudoHostContext:
+          pseudoType = selector->GetPseudoType();
+          break;
+        case CSSSelector::kPseudoWebKitCustomElement:
+        case CSSSelector::kPseudoBlinkInternalElement:
+          custom_pseudo_element_name = selector->Value();
+          break;
+        default:
+          break;
+      }
     default:
       break;
   }
-  if (selector->GetPseudoType() == CSSSelector::kPseudoWebKitCustomElement ||
-      selector->GetPseudoType() == CSSSelector::kPseudoBlinkInternalElement)
-    custom_pseudo_element_name = selector->Value();
 }
 
 bool RuleSet::FindBestRuleSetAndAdd(const CSSSelector& component,
                                     RuleData& rule_data) {
   AtomicString id;
   AtomicString class_name;
   AtomicString custom_pseudo_element_name;
   AtomicString tag_name;
+  CSSSelector::PseudoType pseudoType = CSSSelector::kPseudoUnknown;

[rune, 2017/05/10 08:46:02]

camelCase?

 
 #ifndef NDEBUG
   all_rules_.push_back(rule_data);
 #endif
 
   const CSSSelector* it = &component;
   for (; it && it->Relation() == CSSSelector::kSubSelector;
-       it = it->TagHistory())
-    ExtractValuesforSelector(it, id, class_name, custom_pseudo_element_name,
-                             tag_name);
-  if (it)
-    ExtractValuesforSelector(it, id, class_name, custom_pseudo_element_name,
-                             tag_name);
+       it = it->TagHistory()) {
+    ExtractSelectorValues(it, id, class_name, custom_pseudo_element_name,
+                          tag_name, pseudoType);
+  }
+  if (it) {
+    ExtractSelectorValues(it, id, class_name, custom_pseudo_element_name,
+                          tag_name, pseudoType);
+  }
 
   // Prefer rule sets in order of most likely to apply infrequently.
   if (!id.IsEmpty()) {
     AddToRuleSet(id, EnsurePendingRules()->id_rules, rule_data);
     return true;
   }
+
   if (!class_name.IsEmpty()) {
     AddToRuleSet(class_name, EnsurePendingRules()->class_rules, rule_data);
     return true;
   }
+
   if (!custom_pseudo_element_name.IsEmpty()) {
     // Custom pseudos come before ids and classes in the order of tagHistory,
     // and have a relation of ShadowPseudo between them. Therefore we should
-    // never be a situation where extractValuesforSelector finsd id and
+    // never be a situation where ExtractSelectorValues finds id and
     // className in addition to custom pseudo.
     DCHECK(id.IsEmpty());
     DCHECK(class_name.IsEmpty());
     AddToRuleSet(custom_pseudo_element_name,
                  EnsurePendingRules()->shadow_pseudo_element_rules, rule_data);
     return true;
   }
 
-  switch (component.GetPseudoType()) {
+  switch (pseudoType) {

[rune, 2017/05/10 08:46:02]

So, if I read this correctly:

"[attr]:visited" will now end up in link_pseudo_class_rules_, while it used to
end up in universal, while ":visited" ended up in link_pseudo_class_rules_ both
before and after this change?

Could you add a unit test for the former case?

     case CSSSelector::kPseudoCue:
       cue_pseudo_rules_.push_back(rule_data);
       return true;
     case CSSSelector::kPseudoLink:
     case CSSSelector::kPseudoVisited:
     case CSSSelector::kPseudoAnyLink:
       link_pseudo_class_rules_.push_back(rule_data);
       return true;
     case CSSSelector::kPseudoFocus:
       focus_pseudo_class_rules_.push_back(rule_data);

[rune, 2017/05/10 08:46:02]

You say that you remove the html.css ":focus" rule from the universal bucket. I
was wondering why this didn't happen without this patch since ":focus" is a
single simple selector and would have been matched by the
component.GetPseudoType() switch?

Is it because the default @namespace in html.css generates an implicit type
selector?

Anyway, I think this means affected-by-focus will not be set for the focus-ring
rule in html.css which explains your test failures.

Should we just drop the affected-by-focus flag assuming it's always true?

Thinking about the default namespace, that means the universal :focus in
html.css only applies to elements in the html namespace. Is that correct?

       return true;
     case CSSSelector::kPseudoPlaceholder:
       placeholder_pseudo_rules_.push_back(rule_data);
       return true;
+    case CSSSelector::kPseudoHost:
+    case CSSSelector::kPseudoHostContext:
+      shadow_host_rules_.push_back(rule_data);
+      return true;
     default:
       break;
   }
 
   if (!tag_name.IsEmpty()) {
     AddToRuleSet(tag_name, EnsurePendingRules()->tag_rules, rule_data);
     return true;
   }
 
-  if (component.IsHostPseudoClass()) {
-    shadow_host_rules_.push_back(rule_data);
-    return true;
-  }
-
   return false;
 }
 
 void RuleSet::AddRule(StyleRule* rule,
                       unsigned selector_index,
                       AddRuleFlags add_rule_flags) {
   RuleData rule_data(rule, selector_index, rule_count_++, add_rule_flags);
   if (features_.CollectFeaturesFromRuleData(rule_data) ==
       RuleFeatureSet::kSelectorNeverMatches)
     return;
@@ skipping 177 matching lines @@
 }
 
 #ifndef NDEBUG
 void RuleSet::Show() const {
   for (const auto& rule : all_rules_)
     rule.Selector().Show();
 }
 #endif
 
 }  // namespace blink