Make a '::distributed' pseudo element the first-ever client who can accept a relative selector.

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/)
  * Copyright (c) 2011, Code Aurora Forum. All rights reserved.
  * Copyright (C) Research In Motion Limited 2011. All rights reserved.
@@ skipping 194 matching lines @@
             if (context.scope && context.scope->treeScope() == context.element->treeScope() && (context.behaviorAtBoundary & BoundaryBehaviorMask) != StaysWithinTreeScope)
                 return SelectorFailsCompletely;
             Element* shadowHostNode = context.element->shadowHost();
             if (!shadowHostNode)
                 return SelectorFailsCompletely;
             nextContext.element = shadowHostNode;
             nextContext.isSubSelector = false;
             nextContext.elementStyle = 0;
             return match(nextContext, ignoreDynamicPseudo, siblingTraversalStrategy);
         }
-    case CSSSelector::ShadowDistributed:
-        {
-            Vector<InsertionPoint*, 8> insertionPoints;
-            for (Element* element = context.element; element; element = element->parentElement()) {
-                insertionPoints.clear();
-                collectInsertionPointsWhereNodeIsDistributed(element, insertionPoints);
-                for (size_t i = 0; i < insertionPoints.size(); ++i) {
-                    nextContext.element = insertionPoints[i];
-                    nextContext.isSubSelector = false;
-                    nextContext.elementStyle = 0;
-                    if (match(nextContext, ignoreDynamicPseudo, siblingTraversalStrategy) == SelectorMatches)
-                        return SelectorMatches;
-                }
-            }
-            return SelectorFailsCompletely;
+    case CSSSelector::ShadowVirtualDescendant:
+        for (Element* element = context.element; element; element = element->parentElement()) {
+            if (matchForVirtualChild(element, siblingTraversalStrategy, ignoreDynamicPseudo, nextContext) == SelectorMatches)
+                return SelectorMatches;
         }
+        return SelectorFailsCompletely;
+    case CSSSelector::ShadowVirtualChild:
+        return matchForVirtualChild(context.element, siblingTraversalStrategy, ignoreDynamicPseudo, nextContext);
     }
 
     ASSERT_NOT_REACHED();
     return SelectorFailsCompletely;
 }
 
+template<typename SiblingTraversalStrategy>
+SelectorChecker::Match SelectorChecker::matchForVirtualChild(const Element* element, const SiblingTraversalStrategy& siblingTraversalStrategy, PseudoId& dynamicPseudo, SelectorCheckingContext& nextContext) const

[dglazkov, 2013/05/22 17:43:43]

This is interesting. Right now, it's clear that "virtual scoping root" is a very
shadow DOM-specific concept.

However, it might be helpful to think how would we implement _both_ .find and
::distributed()? I think we we would come up with some way to supply the
mechanism for matching "virtual scoping root" in the SelectorCheckingContext,
right?

And then we'd check some bit on the selector (that is now overloaded in
Relation) in Descendant/Child code and traverse up using that mechanism, rather
than parentElement.

This seems to be a slightly different approach from what you have. Can you help
me understand why I am wrong? :)

+{
+    Vector<InsertionPoint*, 8> insertionPoints;
+    collectInsertionPointsWhereNodeIsDistributed(element, insertionPoints);
+    for (size_t i = 0; i < insertionPoints.size(); ++i) {
+        nextContext.element = insertionPoints[i];
+        nextContext.isSubSelector = false;
+        nextContext.elementStyle = 0;
+        if (match(nextContext, dynamicPseudo, siblingTraversalStrategy) == SelectorMatches)
+            return SelectorMatches;
+    }
+    return SelectorFailsCompletely;
+}
+
 static inline bool containsHTMLSpace(const AtomicString& string)
 {
     for (unsigned i = 0; i < string.length(); i++)
         if (isHTMLSpace(string[i]))
             return true;
     return false;
 }
 
 static bool attributeValueMatches(const Attribute* attributeItem, CSSSelector::Match match, const AtomicString& selectorValue, bool caseSensitive)
 {
@@ skipping 654 matching lines @@
     return element->focused() && isFrameFocused(element);
 }
 
 template
 SelectorChecker::Match SelectorChecker::match(const SelectorCheckingContext&, PseudoId&, const DOMSiblingTraversalStrategy&) const;
 
 template
 SelectorChecker::Match SelectorChecker::match(const SelectorCheckingContext&, PseudoId&, const ShadowDOMSiblingTraversalStrategy&) const;
 
 }