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

Source/core/css/resolver/StyleResolver.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 385 matching lines @@
 {
     ASSERT(shadowRoot.host());
     m_styleTree.popStyleCache(shadowRoot);
 }
 
 StyleResolver::~StyleResolver()
 {
     m_viewportStyleResolver->clearDocument();
 }
 
-inline void StyleResolver::collectTreeBoundaryCrossingRules(Element* element, ElementRuleCollector& collector, bool includeEmptyRules)
+inline void StyleResolver::collectTreeBoundaryCrossingRules(Element* element, ElementRuleCollector& collector, bool includeEmptyRules, CascadeOrder cascadeOrder)
 {
     if (m_treeBoundaryCrossingRules.isEmpty())
         return;
 
     RuleRange ruleRange = collector.matchedResult().ranges.authorRuleRange();
 
-    CascadeOrder cascadeOrder = 0;
-
     DocumentOrderedList::iterator it = m_treeBoundaryCrossingRules.end();
     while (it != m_treeBoundaryCrossingRules.begin()) {
         --it;
         const ContainerNode* scopingNode = toContainerNode(*it);
         RuleSet* ruleSet = m_treeBoundaryCrossingRules.ruleSetScopedBy(scopingNode);
         unsigned boundaryBehavior = SelectorChecker::ScopeContainsLastMatchedElement;
 
-        // If a given scoping node is a shadow root and a given element is in a descendant tree of tree hosted by
-        // the scoping node's shadow host, we should use ScopeIsShadowHost.
+        CascadeOrder orderForRule;
+
+        // If a given scoping node is a shadow root and a given element is in a descendant tree of tree
+        // hosted by the scoping node's shadow host, we should use ScopeIsShadowHost.
         if (scopingNode && scopingNode->isShadowRoot()) {
-            if (element->isInDescendantTreeOf(toShadowRoot(scopingNode)->host()))
+            if (element->isInDescendantTreeOf(toShadowRoot(scopingNode)->host())) {
                 boundaryBehavior |= SelectorChecker::ScopeIsShadowHost;
+                orderForRule = cascadeOrder;
+            } else {
+                orderForRule = 0;
+            }
             scopingNode = toShadowRoot(scopingNode)->host();
+        } else {
+            orderForRule = scopingNode->containsIncludingShadowDOM(element) ? cascadeOrder : 0;
         }
-        collector.collectMatchingRules(MatchRequest(ruleSet, includeEmptyRules, scopingNode), ruleRange, static_cast<SelectorChecker::BehaviorAtBoundary>(boundaryBehavior), ignoreCascadeScope, cascadeOrder++);
+        collector.collectMatchingRules(MatchRequest(ruleSet, includeEmptyRules, scopingNode), ruleRange, static_cast<SelectorChecker::BehaviorAtBoundary>(boundaryBehavior), ignoreCascadeScope, orderForRule);
     }
 }
 
 static inline bool applyAuthorStylesOf(const Element* element)
 {
     return element->treeScope().applyAuthorStyles() || (element->shadow() && element->shadow()->applyAuthorStyles());
 }
 
-void StyleResolver::matchAuthorRulesForShadowHost(Element* element, ElementRuleCollector& collector, bool includeEmptyRules, Vector<ScopedStyleResolver*, 8>& resolvers, Vector<ScopedStyleResolver*, 8>& resolversInShadowTree)
-{
-    collector.clearMatchedRules();
-    collector.matchedResult().ranges.lastAuthorRule = collector.matchedResult().matchedProperties.size() - 1;
-
-    CascadeScope cascadeScope = 0;
-    CascadeOrder cascadeOrder = 0;
-    bool applyAuthorStyles = applyAuthorStylesOf(element);
-
-    for (int j = resolversInShadowTree.size() - 1; j >= 0; --j)
-        resolversInShadowTree.at(j)->collectMatchingAuthorRules(collector, includeEmptyRules, applyAuthorStyles, cascadeScope, cascadeOrder++);
-
-    if (resolvers.isEmpty() || resolvers.first()->treeScope() != element->treeScope())
-        ++cascadeScope;
-    cascadeOrder += resolvers.size();
-    for (unsigned i = 0; i < resolvers.size(); ++i)
-        resolvers.at(i)->collectMatchingAuthorRules(collector, includeEmptyRules, applyAuthorStyles, cascadeScope++, --cascadeOrder);
-
-    collectTreeBoundaryCrossingRules(element, collector, includeEmptyRules);
-    collector.sortAndTransferMatchedRules();
-}
-
 void StyleResolver::matchAuthorRules(Element* element, ElementRuleCollector& collector, bool includeEmptyRules)
 {
     collector.clearMatchedRules();
     collector.matchedResult().ranges.lastAuthorRule = collector.matchedResult().matchedProperties.size() - 1;
 
     bool applyAuthorStyles = applyAuthorStylesOf(element);
     if (m_styleTree.hasOnlyScopedResolverForDocument()) {
         m_styleTree.scopedStyleResolverForDocument()->collectMatchingAuthorRules(collector, includeEmptyRules, applyAuthorStyles, ignoreCascadeScope);
-        collectTreeBoundaryCrossingRules(element, collector, includeEmptyRules);
+        // Use 2 for CascadeOrder, because there is only one scopedStyleResolver, i.e.
+        // resolvers.size() == 1 and resolvers.size() + 1 == 2.
+        collectTreeBoundaryCrossingRules(element, collector, includeEmptyRules, 2);
         collector.sortAndTransferMatchedRules();
         return;
     }
 
     Vector<ScopedStyleResolver*, 8> resolvers;
     m_styleTree.resolveScopedStyles(element, resolvers);
-
-    Vector<ScopedStyleResolver*, 8> resolversInShadowTree;
-    m_styleTree.collectScopedResolversForHostedShadowTrees(element, resolversInShadowTree);
-    if (!resolversInShadowTree.isEmpty()) {
-        matchAuthorRulesForShadowHost(element, collector, includeEmptyRules, resolvers, resolversInShadowTree);
-        return;
-    }
-
     if (resolvers.isEmpty())
         return;
-
     CascadeScope cascadeScope = 0;
     CascadeOrder cascadeOrder = resolvers.size();
     for (unsigned i = 0; i < resolvers.size(); ++i, --cascadeOrder) {
         ScopedStyleResolver* resolver = resolvers.at(i);
+        CascadeOrder resolverOrder = resolver->treeScope() == element->treeScope() && resolver->scopingNode().isShadowRoot() ? 0 : cascadeOrder;
         // FIXME: Need to clarify how to treat style scoped.
-        resolver->collectMatchingAuthorRules(collector, includeEmptyRules, applyAuthorStyles, cascadeScope++, resolver->treeScope() == element->treeScope() && resolver->scopingNode().isShadowRoot() ? 0 : cascadeOrder);
+        resolver->collectMatchingAuthorRules(collector, includeEmptyRules, applyAuthorStyles, cascadeScope, resolverOrder);
+        if (resolver->crossingScopeBoundary(element))
+            ++cascadeScope;
     }
 
-    collectTreeBoundaryCrossingRules(element, collector, includeEmptyRules);
+    collectTreeBoundaryCrossingRules(element, collector, includeEmptyRules, resolvers.size() + 1);
     collector.sortAndTransferMatchedRules();
 }
 
 void StyleResolver::matchWatchSelectorRules(ElementRuleCollector& collector)
 {
     if (!m_watchedSelectorsRules)
         return;
 
     collector.clearMatchedRules();
     collector.matchedResult().ranges.lastUserRule = collector.matchedResult().matchedProperties.size() - 1;
@@ skipping 1009 matching lines @@
 bool StyleResolver::mediaQueryAffectedByViewportChange() const
 {
     for (unsigned i = 0; i < m_viewportDependentMediaQueryResults.size(); ++i) {
         if (m_medium->eval(&m_viewportDependentMediaQueryResults[i]->m_expression) != m_viewportDependentMediaQueryResults[i]->m_result)
             return true;
     }
     return false;
 }
 
 } // namespace WebCore