Selectors in styles in shadowRoots should match in all of the host's shadowRoots.

Source/core/css/resolver/ScopedStyleTree.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All rights reserved.
  * Copyright (C) 2012 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
@@ skipping 48 matching lines @@
 
     if (addResult.isNewEntry) {
         addResult.iterator->value = ScopedStyleResolver::create(scopingNode);
         if (scopingNode.isDocumentNode())
             m_scopedResolverForDocument = addResult.iterator->value.get();
     }
     isNewEntry = addResult.isNewEntry;
     return addResult.iterator->value.get();
 }
 
+// To make younger shadow root act as a child of its older shadow root.
+ContainerNode* ScopedStyleTree::traverseParent(const ContainerNode* node) const
+{
+    if (node->isShadowRoot()) {
+        const ShadowRoot* shadowRoot = toShadowRoot(node);
+        if (shadowRoot->isOldest())
+            return shadowRoot->host();
+        return shadowRoot->olderShadowRoot();
+    }
+
+    ContainerNode* parent = node->parentOrShadowHostNode();
+    return parent && parent->isShadowRoot() ? toShadowRoot(parent)->owner()->youngestShadowRoot() : parent;
+}
+
+static inline bool containsIncludingShadowRoots(const ContainerNode* node1, const ContainerNode* node2)
+{
+    ASSERT(node1);
+    ASSERT(node2);
+
+    // If node1 is a older shadow root and node2 is an younger shadow root hosted by the
+    // same shadow host, treat as if node1 contains node2.
+    if (node1->isShadowRoot()) {
+        Node* host = toShadowRoot(node1)->host();
+        return host != node2 && host->containsIncludingShadowDOM(node2);
+    }
+    return node1->containsIncludingShadowDOM(node2);
+}
+
 void ScopedStyleTree::setupScopedStylesTree(ScopedStyleResolver* target)
 {
     ASSERT(target);
 
     const ContainerNode& scopingNode = target->scopingNode();
 
     // Since StyleResolver creates RuleSets according to styles' document
     // order, a parent of the given ScopedRuleData has been already
     // prepared.
-    for (ContainerNode* node = scopingNode.parentOrShadowHostNode(); node; node = node->parentOrShadowHostNode()) {
+    for (ContainerNode* node = traverseParent(&scopingNode); node; node = traverseParent(node)) {
         if (ScopedStyleResolver* scopedResolver = scopedStyleResolverFor(*node)) {
             target->setParent(scopedResolver);
             break;
         }
         if (node->isDocumentNode()) {
             bool dummy;
             ScopedStyleResolver* scopedResolver = addScopedStyleResolver(*node, dummy);
             target->setParent(scopedResolver);
             setupScopedStylesTree(scopedResolver);
             break;
         }
     }
 
     if (m_buildInDocumentOrder)
         return;
 
     // Reparent all nodes whose scoping node is contained by target's one.
     for (HashMap<const ContainerNode*, OwnPtr<ScopedStyleResolver> >::iterator it = m_authorStyles.begin(); it != m_authorStyles.end(); ++it) {
         if (it->value == target)
             continue;
         ASSERT(it->key->inDocument());
-        if (it->value->parent() == target->parent() && scopingNode.containsIncludingShadowDOM(it->key))
+        if (it->value->parent() == target->parent() && containsIncludingShadowRoots(&scopingNode, it->key))
             it->value->setParent(target);
     }
 }
 
 void ScopedStyleTree::clear()
 {
     m_authorStyles.clear();
     m_scopedResolverForDocument = 0;
     m_cache.clear();
 }
 
 void ScopedStyleTree::resolveScopedStyles(const Element* element, Vector<ScopedStyleResolver*, 8>& resolvers)
 {
     for (ScopedStyleResolver* scopedResolver = scopedResolverFor(element); scopedResolver; scopedResolver = scopedResolver->parent())
         resolvers.append(scopedResolver);
 }
 
-void ScopedStyleTree::collectScopedResolversForHostedShadowTrees(const Element* element, Vector<ScopedStyleResolver*, 8>& resolvers)
-{
-    ElementShadow* shadow = element->shadow();
-    if (!shadow)
-        return;
-
-    // Adding scoped resolver for active shadow roots for shadow host styling.
-    for (ShadowRoot* shadowRoot = shadow->youngestShadowRoot(); shadowRoot; shadowRoot = shadowRoot->olderShadowRoot()) {
-        if (shadowRoot->hasScopedHTMLStyleChild()) {
-            if (ScopedStyleResolver* resolver = scopedStyleResolverFor(*shadowRoot))
-                resolvers.append(resolver);
-        }
-        if (!shadowRoot->containsShadowElements())
-            break;
-    }
-}
-
 void ScopedStyleTree::resolveScopedKeyframesRules(const Element* element, Vector<ScopedStyleResolver*, 8>& resolvers)
 {
     Document& document = element->document();
     TreeScope& treeScope = element->treeScope();
     bool applyAuthorStyles = treeScope.applyAuthorStyles();
 
-    // Add resolvers for shadow roots hosted by the given element.
-    collectScopedResolversForHostedShadowTrees(element, resolvers);
-
     // Add resolvers while walking up DOM tree from the given element.
-    for (ScopedStyleResolver* scopedResolver = scopedResolverFor(element); scopedResolver; scopedResolver = scopedResolver->parent()) {
-        if (scopedResolver->treeScope() == treeScope || (applyAuthorStyles && scopedResolver->treeScope() == document))
+    ScopedStyleResolver* scopedResolver = scopedResolverFor(element);
+    for (; scopedResolver; scopedResolver = scopedResolver->parent()) {
+        if (scopedResolver->treeScope() == treeScope
+            || (scopedResolver->scopingNode().isShadowRoot() && toShadowRoot(&scopedResolver->scopingNode())->host() == element)
+            || (applyAuthorStyles && scopedResolver->treeScope() == document))
             resolvers.append(scopedResolver);
     }
 }
 
 inline ScopedStyleResolver* ScopedStyleTree::enclosingScopedStyleResolverFor(const ContainerNode* scopingNode)
 {
-    for (; scopingNode; scopingNode = scopingNode->parentOrShadowHostNode()) {
-        if (ScopedStyleResolver* scopedStyleResolver = scopedStyleResolverFor(*scopingNode))
+    const ContainerNode* node;
+    // FIXME: we should split "style tree" traversal logic out from this method.
+    if (isShadowHost(scopingNode)) {
+        node = toElement(scopingNode)->shadow()->youngestShadowRoot();
+    } else {
+        node = scopingNode->isShadowRoot() ? toShadowRoot(scopingNode)->owner()->youngestShadowRoot() : scopingNode;
+    }
+    for (; node; node = traverseParent(node)) {
+        if (ScopedStyleResolver* scopedStyleResolver = scopedStyleResolverFor(*node))
             return scopedStyleResolver;
     }
     return 0;
 }
 
 void ScopedStyleTree::resolveStyleCache(const ContainerNode* scopingNode)
 {
     m_cache.scopedResolver = enclosingScopedStyleResolverFor(scopingNode);
     m_cache.nodeForScopedStyles = scopingNode;
 }
 
 void ScopedStyleTree::pushStyleCache(const ContainerNode& scopingNode, const ContainerNode* parent)
 {
     if (m_authorStyles.isEmpty())
         return;
 
     if (!cacheIsValid(parent)) {
         resolveStyleCache(&scopingNode);
         return;
     }
 
     ScopedStyleResolver* scopedResolver = scopedStyleResolverFor(scopingNode);
     if (scopedResolver)
         m_cache.scopedResolver = scopedResolver;
     m_cache.nodeForScopedStyles = &scopingNode;
 }
 
+static inline bool shadowRootHasTheSameShadowHost(const ContainerNode& node, const Node* host)
+{
+    if (!node.isShadowRoot())
+        return false;
+    return toShadowRoot(&node)->host() == host;
+}
+
 void ScopedStyleTree::popStyleCache(const ContainerNode& scopingNode)
 {
     if (!cacheIsValid(&scopingNode))
         return;
 
-    if (m_cache.scopedResolver && m_cache.scopedResolver->scopingNode() == scopingNode)
-        m_cache.scopedResolver = m_cache.scopedResolver->parent();
+    if (!scopingNode.isShadowRoot()) {
+        if (m_cache.scopedResolver && m_cache.scopedResolver->scopingNode() == scopingNode)
+            m_cache.scopedResolver = m_cache.scopedResolver->parent();
+
+        m_cache.nodeForScopedStyles = scopingNode.parentOrShadowHostNode();
+        return;
+    }
+
+    const ShadowRoot* shadowRoot = toShadowRoot(&scopingNode);
+    const Node* host = shadowRoot->host();
+
+    // If a given scoping node is the oldest shadow root and cached resolver's scoping node
+    // is a shadow root (mostly, the youngest shadow root) hosted by the same host of
+    // the given shadow root, update cacheed resolver.
+    if (m_cache.scopedResolver
+        && shadowRoot->isOldest()
+        && shadowRootHasTheSameShadowHost(m_cache.scopedResolver->scopingNode(), host)) {
+        ScopedStyleResolver* resolver = m_cache.scopedResolver;
+
+        while (shadowRootHasTheSameShadowHost(resolver->scopingNode(), host))
+            resolver = resolver->parent();
+
+        m_cache.scopedResolver = resolver;
+    }
+
     m_cache.nodeForScopedStyles = scopingNode.parentOrShadowHostNode();
 }
 
 void ScopedStyleTree::collectFeaturesTo(RuleFeatureSet& features)
 {
     for (HashMap<const ContainerNode*, OwnPtr<ScopedStyleResolver> >::iterator it = m_authorStyles.begin(); it != m_authorStyles.end(); ++it)
         it->value->collectFeaturesTo(features);
 }
 
 inline void ScopedStyleTree::reparentNodes(const ScopedStyleResolver* oldParent, ScopedStyleResolver* newParent)
@@ skipping 15 matching lines @@
         return;
 
     reparentNodes(resolverRemoved, resolverRemoved->parent());
     if (m_cache.scopedResolver == resolverRemoved)
         m_cache.clear();
 
     m_authorStyles.remove(scopingNode);
 }
 
 } // namespace WebCore