Matching part for >>> (shadow-piercing descendant combinator).

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 267 matching lines @@
 }
 
 static inline Element* parentOrV0ShadowHostElement(const Element& element) {
   if (element.parentNode() && element.parentNode()->isShadowRoot()) {
     if (toShadowRoot(element.parentNode())->type() != ShadowRootType::V0)
       return nullptr;
   }
   return element.parentOrShadowHostElement();
 }
 
+static inline Element* parentOrOpenShadowHostElement(const Element& element) {
+  if (element.parentNode() && element.parentNode()->isShadowRoot()) {
+    if (toShadowRoot(element.parentNode())->type() != ShadowRootType::Open)
+      return nullptr;
+  }
+  return element.parentOrShadowHostElement();
+}
+
 SelectorChecker::Match SelectorChecker::matchForRelation(
     const SelectorCheckingContext& context,
     MatchResult& result) const {
   SelectorCheckingContext nextContext = prepareNextContextForRelation(context);
 
   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.isSubSelector &&
@@ skipping 133 matching lines @@
           UseCounter::count(context.element->document(),
                             UseCounter::CSSDeepCombinatorAndShadow);
         if (match == SelectorMatches || match == SelectorFailsCompletely)
           return match;
         if (nextSelectorExceedsScope(nextContext))
           return SelectorFailsCompletely;
       }
       return SelectorFailsCompletely;
     }
 
+    case CSSSelector::ShadowPiercingDescendant: {
+      DCHECK(m_isQuerySelector);
+      // TODO(kochi): parentOrOpenShadowHostElement() is necessary because
+      // SelectorQuery can pass V0 shadow roots. All closed shadow roots are
+      // already filtered out, thus once V0 is removed this logic can use
+      // parentOrShadowHostElement() instead.
+      for (nextContext.element =
+               parentOrOpenShadowHostElement(*context.element);
+           nextContext.element;
+           nextContext.element =
+               parentOrOpenShadowHostElement(*nextContext.element)) {
+        Match match = matchSelector(nextContext, result);
+        if (match == SelectorMatches || match == SelectorFailsCompletely)
+          return match;
+        if (nextSelectorExceedsScope(nextContext))
+          break;
+      }
+      return SelectorFailsCompletely;
+    }
+
     case CSSSelector::ShadowSlot: {
       const HTMLSlotElement* slot = findSlotElementInScope(context);
       if (!slot)
         return SelectorFailsCompletely;
 
       nextContext.element = const_cast<HTMLSlotElement*>(slot);
       return matchSelector(nextContext, result);
     }
 
     case CSSSelector::SubSelector:
@@ skipping 826 matching lines @@
 }
 
 bool SelectorChecker::matchesFocusPseudoClass(const Element& element) {
   if (InspectorInstrumentation::forcePseudoState(const_cast<Element*>(&element),
                                                  CSSSelector::PseudoFocus))
     return true;
   return element.isFocused() && isFrameFocused(element);
 }
 
 }  // namespace blink