Get rid of TreeBoundaryCrossingRules.

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 106 matching lines @@
 }
 
 static StylePropertySet* rightToLeftDeclaration()
 {
     DEFINE_STATIC_REF_WILL_BE_PERSISTENT(MutableStylePropertySet, rightToLeftDecl, (MutableStylePropertySet::create()));
     if (rightToLeftDecl->isEmpty())
         rightToLeftDecl->setProperty(CSSPropertyDirection, CSSValueRtl);
     return rightToLeftDecl;
 }
 
-static void collectScopedResolversForHostedShadowTrees(const Element* element, WillBeHeapVector<RawPtrWillBeMember<ScopedStyleResolver>, 8>& resolvers)
+static void collectScopedResolversForHostedShadowTrees(const Element& element, WillBeHeapVector<RawPtrWillBeMember<ScopedStyleResolver>, 8>& resolvers)
 {
-    ElementShadow* shadow = element->shadow();
+    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->numberOfStyles() > 0) {
             if (ScopedStyleResolver* resolver = shadowRoot->scopedStyleResolver())
                 resolvers.append(resolver);
         }
     }
 }
 
+static void collectScopedResolversForTreeBoundaryCrossingRules(const Element& element, WillBeHeapVector<RawPtrWillBeMember<ScopedStyleResolver>, 8>& resolversInOuterScopes, WillBeHeapVector<RawPtrWillBeMember<ScopedStyleResolver>, 8>& resolversInDistributedScopes)
+{
+    // TODO(rune@opera.com): TreeScope::treeScopeInComposedTree can potentially be expensive as its doing
+    // composed tree traversal to find the closest tree-scope for the element in the composed tree. Getting the
+    // ancestor tree-scopes are much cheaper as we do the composed tree traversal for each TreeScope once and then cache
+    // its composed tree parent scope as a member.
+    for (TreeScope* scope = TreeScope::treeScopeInComposedTree(element); scope; scope = scope->composedParent()) {
+        if (scope == element.treeScope())
+            continue;
+        ScopedStyleResolver* resolver = scope->scopedStyleResolver();
+        if (!resolver || !resolver->hasTreeBoundaryCrossingRules())
+            continue;
+        if (element.treeScope().isInclusiveAncestorOf(resolver->treeScope()))
+            resolversInDistributedScopes.append(resolver);
+        else
+            resolversInOuterScopes.append(resolver);
+    }
+}
+
 StyleResolver::StyleResolver(Document& document)
     : m_document(document)
     , m_viewportStyleResolver(ViewportStyleResolver::create(&document))
     , m_needCollectFeatures(false)
     , m_printMediaType(false)
     , m_styleResourceLoader(&document)
     , m_styleSharingDepth(0)
     , m_styleResolverStatsSequence(0)
     , m_accessCount(0)
 {
@@ skipping 74 matching lines @@
 
 void StyleResolver::resetRuleFeatures()
 {
     // Need to recreate RuleFeatureSet.
     m_features.clear();
     m_siblingRuleSet.clear();
     m_uncommonAttributeRuleSet.clear();
     m_needCollectFeatures = true;
 }
 
-void StyleResolver::addTreeBoundaryCrossingScope(ContainerNode& scope)
-{
-    m_treeBoundaryCrossingRules.addScope(scope);
-}
-
 void StyleResolver::resetAuthorStyle(TreeScope& treeScope)
 {
-    m_treeBoundaryCrossingRules.removeScope(treeScope.rootNode());
     resetRuleFeatures();
 
     ScopedStyleResolver* resolver = treeScope.scopedStyleResolver();
     if (!resolver)
         return;
 
     if (treeScope.rootNode().isDocumentNode()) {
         resolver->resetAuthorStyle();
         return;
     }
@@ skipping 98 matching lines @@
 }
 
 StyleResolver::~StyleResolver()
 {
 }
 
 static inline ScopedStyleResolver* scopedResolverFor(const Element* element)
 {
     // Ideally, returning element->treeScope().scopedStyleResolver() should be
     // enough, but ::cue and custom pseudo elements like ::-webkit-meter-bar pierce
-    // through a shadow dom boundary, yet they are not part of m_treeBoundaryCrossingRules.
+    // through a shadow dom boundary, yet they are not part of treeBoundaryCrossingRules.
     // The assumption here is that these rules only pierce through one boundary and
     // that the scope of these elements do not have a style resolver due to the fact
     // that VTT scopes and UA shadow trees don't have <style> elements. This is
     // backed up by the ASSERTs below.
     //
     // FIXME: Make ::cue and custom pseudo elements part of boundary crossing rules
     // when moving those rules to ScopedStyleResolver as part of issue 401359.
 
     TreeScope* treeScope = &element->treeScope();
     if (ScopedStyleResolver* resolver = treeScope->scopedStyleResolver()) {
         ASSERT(element->shadowPseudoId().isEmpty());
         ASSERT(!element->isVTTElement());
         return resolver;
     }
 
     treeScope = treeScope->parentTreeScope();
     if (!treeScope)
         return nullptr;
     if (element->shadowPseudoId().isEmpty() && !element->isVTTElement())
         return nullptr;
     return treeScope->scopedStyleResolver();
 }
 
 void StyleResolver::matchAuthorRules(Element* element, ElementRuleCollector& collector, bool includeEmptyRules)
 {
-    collector.clearMatchedRules();
     collector.matchedResult().ranges.lastAuthorRule = collector.matchedResult().matchedProperties.size() - 1;
 
-    CascadeOrder cascadeOrder = 0;
     WillBeHeapVector<RawPtrWillBeMember<ScopedStyleResolver>, 8> resolversInShadowTree;
-    collectScopedResolversForHostedShadowTrees(element, resolversInShadowTree);
+    WillBeHeapVector<RawPtrWillBeMember<ScopedStyleResolver>, 8> resolversInOuterScopes;
+    WillBeHeapVector<RawPtrWillBeMember<ScopedStyleResolver>, 8> resolversInDistributedScopes;
+
+    collectScopedResolversForHostedShadowTrees(*element, resolversInShadowTree);
+    if (document().styleEngine().hasTreeBoundaryCrossingRules())
+        collectScopedResolversForTreeBoundaryCrossingRules(*element, resolversInOuterScopes, resolversInDistributedScopes);
+
+    // According to the CSS Scoping spec, cascading of rules from inner vs outer scopes happens
+    // such that outer scope rules wins regardless of specificity. For rules from tree-scopes
+    // that do not have an ascendant/descendant relationship in the tree-of-trees (typical for
+    // ::content rules from different scopes during re-distribution), tree-of-trees order of
+    // appearance applies, hence specificity wins although last rule in order of appearance wins
+    // if the specificity is the same.
+    //
+    // The code below uses CascadeOrder which is an order-of-appearance value, and should give
+    // the correct cascading order when order-of-appearance applies.
+    // The "outer scope wins" rule is ensured by calls to sortAndTransferMatchedRules().
+    //
+    // TODO(rune@opera.com): The current implementation does not handle cascading order as
+    // spec'ed for !important rules or multiple shadow trees per host.
 
     // Apply :host and :host-context rules from inner scopes.
-    for (int j = resolversInShadowTree.size() - 1; j >= 0; --j)
-        resolversInShadowTree.at(j)->collectMatchingShadowHostRules(collector, includeEmptyRules, ++cascadeOrder);
+    if (resolversInShadowTree.size()) {
+        collector.clearMatchedRules();
+        CascadeOrder cascadeOrder = 0;
+        for (int i = resolversInShadowTree.size() - 1; i >= 0; --i)
+            resolversInShadowTree.at(i)->collectMatchingShadowHostRules(collector, includeEmptyRules, ++cascadeOrder);
+        collector.sortAndTransferMatchedRules();
+    }
 
-    // Apply normal rules from element scope.
-    if (ScopedStyleResolver* resolver = scopedResolverFor(element))
-        resolver->collectMatchingAuthorRules(collector, includeEmptyRules, ++cascadeOrder);
+    // Apply ::content rules from distributed scopes
+    if (resolversInDistributedScopes.size()) {
+        collector.clearMatchedRules();
+        CascadeOrder cascadeOrder = 0;
+        for (int j = resolversInDistributedScopes.size() - 1; j >= 0; --j)
+            resolversInDistributedScopes.at(j)->collectMatchingTreeBoundaryCrossingRules(collector, includeEmptyRules, ++cascadeOrder);
+        collector.sortAndTransferMatchedRules();
+    }
 
-    // Apply /deep/ and ::shadow rules from outer scopes, and ::content from inner.
-    m_treeBoundaryCrossingRules.collectTreeBoundaryCrossingRules(element, collector, includeEmptyRules);
-    collector.sortAndTransferMatchedRules();
+    // Apply rules from the element's scope.
+    if (ScopedStyleResolver* resolver = scopedResolverFor(element)) {
+        collector.clearMatchedRules();
+        resolver->collectMatchingAuthorRules(collector, includeEmptyRules, ignoreCascadeOrder);
+
+        // TODO(rune@opera.com): Only piercing rules, of the boundary crossing rules,
+        // can match elements in the same scope as the rules, thus we can drop the code
+        // below if piercing combinators are removed.
+        if (resolver->hasTreeBoundaryCrossingRules())
+            resolver->collectMatchingTreeBoundaryCrossingRules(collector, includeEmptyRules, ignoreCascadeOrder);
+
+        collector.sortAndTransferMatchedRules();
+    }
+
+    // Apply /deep/ and ::shadow rules from outer scopes.
+    // TODO(rune@opera.com): The code below can be removed if we remove support for shadow piercing selectors.
+    for (unsigned k = 0; k < resolversInOuterScopes.size(); k++) {
+        collector.clearMatchedRules();
+        resolversInOuterScopes.at(k)->collectMatchingTreeBoundaryCrossingRules(collector, includeEmptyRules, ignoreCascadeOrder);
+        collector.sortAndTransferMatchedRules();
+    }
 }
 
 void StyleResolver::matchUARules(ElementRuleCollector& collector)
 {
     collector.setMatchingUARules(true);
 
     CSSDefaultStyleSheets& defaultStyleSheets = CSSDefaultStyleSheets::instance();
     RuleSet* userAgentStyleSheet = m_printMediaType ? defaultStyleSheets.defaultPrintStyle() : defaultStyleSheets.defaultStyle();
     matchRuleSet(collector, userAgentStyleSheet);
 
@@ skipping 571 matching lines @@
     loadPendingResources(state);
 
     ASSERT(!state.fontBuilder().fontDirty());
 
     return true;
 }
 
 StyleRuleKeyframes* StyleResolver::findKeyframesRule(const Element* element, const AtomicString& animationName)
 {
     WillBeHeapVector<RawPtrWillBeMember<ScopedStyleResolver>, 8> resolvers;
-    collectScopedResolversForHostedShadowTrees(element, resolvers);
+    collectScopedResolversForHostedShadowTrees(*element, resolvers);
     if (ScopedStyleResolver* scopedResolver = element->treeScope().scopedStyleResolver())
         resolvers.append(scopedResolver);
 
     for (size_t i = 0; i < resolvers.size(); ++i) {
         if (StyleRuleKeyframes* keyframesRule = resolvers[i]->keyframeStylesForAnimation(animationName.impl()))
             return keyframesRule;
     }
     return nullptr;
 }
 
@@ skipping 488 matching lines @@
 {
 #if ENABLE(OILPAN)
     visitor->trace(m_matchedPropertiesCache);
     visitor->trace(m_viewportDependentMediaQueryResults);
     visitor->trace(m_selectorFilter);
     visitor->trace(m_viewportStyleResolver);
     visitor->trace(m_features);
     visitor->trace(m_siblingRuleSet);
     visitor->trace(m_uncommonAttributeRuleSet);
     visitor->trace(m_watchedSelectorsRules);
-    visitor->trace(m_treeBoundaryCrossingRules);
     visitor->trace(m_styleResourceLoader);
     visitor->trace(m_styleSharingLists);
     visitor->trace(m_pendingStyleSheets);
     visitor->trace(m_document);
 #endif
 }
 
 } // namespace blink