Scopeless matching of :host rules for style sharing.

third_party/WebKit/Source/core/css/SelectorChecker.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, 2013 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 293 matching lines @@
 
   CSSSelector::RelationType relation = context.selector->Relation();
 
   // Disable :visited matching when we see the first link or try to match
   // anything else than an ancestors.
   if (!context.is_sub_selector &&
       (context.element->IsLink() || (relation != CSSSelector::kDescendant &&
                                      relation != CSSSelector::kChild)))
     next_context.visited_match_type = kVisitedMatchDisabled;
 
+  // The ParentElement() method will walk up to the host element for :host() and
+  // :host-context() rules in the same scope as the element we are matching.
+  // For kSharingRules, we don't know which scope the rules came from, so we are
+  // using nullptr as scope. This is a workaround to make ParentElement() walk
+  // up to the host when matching :host rules by assuming the scope of the :host
+  // rule is the same as the element we are matching rules for.
+  if (mode_ == kSharingRules && next_context.selector->IsHostPseudoClass())
+    next_context.scope = next_context.element->ContainingShadowRoot();
+
   next_context.in_rightmost_compound = false;
   next_context.is_sub_selector = false;
   next_context.previous_element = context.element;
   next_context.pseudo_id = kPseudoIdNone;
 
   switch (relation) {
     case CSSSelector::kDescendant:
       if (context.selector->RelationIsAffectedByPseudoContent()) {
         for (Element* element = context.element; element;
              element = element->parentElement()) {
           if (MatchForPseudoContent(next_context, *element, result) ==
               kSelectorMatches)
             return kSelectorMatches;
         }
         return kSelectorFailsCompletely;
       }
 
       if (next_context.selector->GetPseudoType() == CSSSelector::kPseudoShadow)
         return MatchForPseudoShadow(
             next_context, context.element->ContainingShadowRoot(), result);
 
-      for (next_context.element = ParentElement(context); next_context.element;
+      for (next_context.element = ParentElement(next_context);

[kochi, 2017/04/19 10:21:12]

This looks like a bug, but is this for bug 711539?

[rune, 2017/04/19 22:49:47]

The element is initially the same for context and next_context, so it doesn't
matter. The reason I changed which to start from was that I wanted to modify the
scope member and context was const.

[kochi, 2017/04/20 10:45:21]

Acknowledged.

+           next_context.element;
            next_context.element = ParentElement(next_context)) {
         MatchStatus match = MatchSelector(next_context, result);
         if (match == kSelectorMatches || match == kSelectorFailsCompletely)
           return match;
         if (NextSelectorExceedsScope(next_context))
           return kSelectorFailsCompletely;
       }
       return kSelectorFailsCompletely;
     case CSSSelector::kChild: {
       if (context.selector->RelationIsAffectedByPseudoContent())
         return MatchForPseudoContent(next_context, *context.element, result);
 
       if (next_context.selector->GetPseudoType() == CSSSelector::kPseudoShadow)
         return MatchForPseudoShadow(next_context, context.element->parentNode(),
                                     result);
 
-      next_context.element = ParentElement(context);
+      next_context.element = ParentElement(next_context);

[kochi, 2017/04/19 10:21:12]

Ditto

       if (!next_context.element)
         return kSelectorFailsCompletely;
       return MatchSelector(next_context, result);
     }
     case CSSSelector::kDirectAdjacent:
       // Shadow roots can't have sibling elements
       if (next_context.selector->GetPseudoType() == CSSSelector::kPseudoShadow)
         return kSelectorFailsCompletely;
 
       if (mode_ == kResolvingStyle) {
@@ skipping 988 matching lines @@
 bool SelectorChecker::MatchesFocusPseudoClass(const Element& element) {
   bool force_pseudo_state = false;
   probe::forcePseudoState(const_cast<Element*>(&element),
                           CSSSelector::kPseudoFocus, &force_pseudo_state);
   if (force_pseudo_state)
     return true;
   return element.IsFocused() && IsFrameFocused(element);
 }
 
 }  // namespace blink