Implement ::shadow pseudo element and replace /shadow/ with ::shadow.

Source/core/css/SelectorChecker.cpp

Index: Source/core/css/SelectorChecker.cpp
diff --git a/Source/core/css/SelectorChecker.cpp b/Source/core/css/SelectorChecker.cpp
index 36d9f5f8c2ddee0301070505f5bd4d84b48fe9e4..5dbb69ca71d004e0cef91b5c7463b6a0f5748594 100644
--- a/Source/core/css/SelectorChecker.cpp
+++ b/Source/core/css/SelectorChecker.cpp
@@ -154,6 +154,9 @@ SelectorChecker::Match SelectorChecker::match(const SelectorCheckingContext& con
         } else if (context.selector->isContentPseudoElement()) {
             if (!context.element->isInShadowTree() || !context.element->isInsertionPoint())
                 return SelectorFailsLocally;
+        } else if (context.selector->isShadowPseudoElement()) {
+            if (!context.element->isInShadowTree())
+                return SelectorFailsLocally;

[rune, 2014/03/25 20:58:21]

You're just checking for isInShadowTree(). Won't that make selectors like
"::shadow ::shadow ::shadow" match inside the same shadow dom fragment given
that the shadow tree is deep enough?

Also, according to the spec, ::shadow should just match the shadow root. So
"::shadow > div" should only match divs that are direct children of the shadow
root.

[tasak, 2014/03/26 11:01:46]

If we have "::shadow ::shadow ::shadow span", CSSParser takes the rule as if
"*::shadow *::shadow *::shadow span". (This is the same behavior as custom
pseudo elements, e.g. ::cue.)

So the selector matches only spans in a shadow tree of a shadow tree of a
shadow.

Anyway, I will add a layout test for this.
Yeah. So I modified the code for Child relation in SelectorChecker.cpp, because
I would like not to enlarge the size of CSSSelector.

So I cannot add any more relations (e.g. ChildWithShadowPseudoElement or
something) / any more bits (e.g. affectedByPseudoShadowElement or something) to
CSSSelector.

And I have another reason. context.selector's type is "Element*", not
"ContainerNode*" or "Node*". We cannot store "ShadowRoot" in context.element.

         } else {
             if ((!context.elementStyle && m_mode == ResolvingStyle) || m_mode == QueryingRules)
                 return SelectorFailsLocally;
@@ -211,6 +214,11 @@ static inline SelectorChecker::SelectorCheckingContext prepareNextContextForRela
     return nextContext;
 }
 
+static inline bool isAuthorShadowRoot(const Node* node)
+{
+    return node && node->isShadowRoot() && toShadowRoot(node)->type() == ShadowRoot::AuthorShadowRoot;
+}
+
 template<typename SiblingTraversalStrategy>
 SelectorChecker::Match SelectorChecker::matchForSubSelector(const SelectorCheckingContext& context, const SiblingTraversalStrategy& siblingTraversalStrategy, MatchResult* result) const
 {
@@ -231,6 +239,11 @@ SelectorChecker::Match SelectorChecker::matchForSubSelector(const SelectorChecki
     return match(nextContext, siblingTraversalStrategy, result);
 }
 
+static bool selectorMatchesShadowRoot(const CSSSelector* selector)
+{
+    return selector && selector->isShadowPseudoElement();
+}
+
 template<typename SiblingTraversalStrategy>
 SelectorChecker::Match SelectorChecker::matchForRelation(const SelectorCheckingContext& context, const SiblingTraversalStrategy& siblingTraversalStrategy, MatchResult* result) const
 {
@@ -255,6 +268,14 @@ SelectorChecker::Match SelectorChecker::matchForRelation(const SelectorCheckingC
         }
         nextContext.isSubSelector = false;
         nextContext.elementStyle = 0;
+
+        if (selectorMatchesShadowRoot(nextContext.selector)) {
+            if (!isAuthorShadowRoot(context.element->containingShadowRoot()))
+                return SelectorFailsCompletely;
+            nextContext.element = context.element;
+            return this->match(nextContext, siblingTraversalStrategy, result);
+        }
+
         for (nextContext.element = parentElement(context); nextContext.element; nextContext.element = parentElement(nextContext)) {
             Match match = this->match(nextContext, siblingTraversalStrategy, result);
             if (match == SelectorMatches || match == SelectorFailsCompletely)
@@ -268,12 +289,18 @@ SelectorChecker::Match SelectorChecker::matchForRelation(const SelectorCheckingC
             if (context.selector->relationIsAffectedByPseudoContent())
                 return matchForShadowDistributed(context.element, siblingTraversalStrategy, nextContext, result);
 
-            nextContext.element = parentElement(context);
-            if (!nextContext.element)
-                return SelectorFailsCompletely;
-
             nextContext.isSubSelector = false;
             nextContext.elementStyle = 0;
+            nextContext.element = parentElement(context);
+            if (!nextContext.element) {
+                if (!selectorMatchesShadowRoot(nextContext.selector))

[dglazkov, 2014/03/25 17:10:53]

This is effectively copy-paste code from CSSSelector::Descendant, right?

Why don't we have this up at the top of SelectorChecker::checkOne, where we
check other types of pseudos?

[tasak, 2014/03/26 11:01:46]

I see. I created a new method for this.
Because we cannot store any shadow root in context.element. Shadow roots are not
elements.

To do so, it is ok to replace all "Element*" with "ContainerNode*"?

I think, we don't have enough time to change context.element to take
"ContainerNode*" (i.e. replace context.element with context.node?). I'm afraid
of causing too many regressions.

+                    return SelectorFailsCompletely;
+                if (isAuthorShadowRoot(context.element->parentNode())) {
+                    nextContext.element = context.element;
+                    return match(nextContext, siblingTraversalStrategy, result);
+                }
+                return SelectorFailsCompletely;
+            }
             return match(nextContext, siblingTraversalStrategy, result);
         }
     case CSSSelector::DirectAdjacent:
@@ -304,7 +331,6 @@ SelectorChecker::Match SelectorChecker::matchForRelation(const SelectorCheckingC
         return SelectorFailsAllSiblings;
 
     case CSSSelector::ShadowPseudo:
-    case CSSSelector::Shadow:
         {
             // If we're in the same tree-scope as the scoping element, then following a shadow descendant combinator would escape that and thus the scope.
             if (context.scope && context.scope->treeScope() == context.element->treeScope() && (context.behaviorAtBoundary & BoundaryBehaviorMask) != StaysWithinTreeScope)