Introduce Node::containingTreeScope(), which asserts that the node's root is a tree scope

third_party/WebKit/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 494 matching lines @@
 
     if (!document().mayContainV0Shadow()) {
         matchSlottedRules(element, collector);
         matchElementScopeRules(element, elementScopeResolver, collector);
         return;
     }
 
     bool matchElementScopeDone = !elementScopeResolver && !element.inlineStyle();
 
     for (auto it = m_treeBoundaryCrossingScopes.rbegin(); it != m_treeBoundaryCrossingScopes.rend(); ++it) {
-        const TreeScope& scope = (*it)->treeScope();
+        const TreeScope& scope = (*it)->containingTreeScope();
         ScopedStyleResolver* resolver = scope.scopedStyleResolver();
         ASSERT(resolver);
 
-        bool isInnerTreeScope = element.treeScope().isInclusiveAncestorOf(scope);
+        bool isInnerTreeScope = element.containingTreeScope().isInclusiveAncestorOf(scope);
         if (!shouldCheckScope(element, **it, isInnerTreeScope))
             continue;
 
-        if (!matchElementScopeDone && scope.isInclusiveAncestorOf(element.treeScope())) {
+        if (!matchElementScopeDone && scope.isInclusiveAncestorOf(element.containingTreeScope())) {
 
             matchElementScopeDone = true;
 
             // At this point, the iterator has either encountered the scope for the element
             // itself (if that scope has boundary-crossing rules), or the iterator has moved
             // to a scope which appears before the element's scope in the tree-of-trees order.
             // Try to match all rules from the element's scope.
 
             matchElementScopeRules(element, elementScopeResolver, collector);
             if (resolver == elementScopeResolver) {
@@ skipping 119 matching lines @@
         return;
 
     // When comparing rules declared in outer treescopes, outer's rules win.
     CascadeOrder outerCascadeOrder = m_treeBoundaryCrossingScopes.size() * 2;
     // When comparing rules declared in inner treescopes, inner's rules win.
     CascadeOrder innerCascadeOrder = m_treeBoundaryCrossingScopes.size();
 
     for (const auto& scopingNode : m_treeBoundaryCrossingScopes) {
         // Skip rule collection for element when tree boundary crossing rules of scopingNode's
         // scope can never apply to it.
-        bool isInnerTreeScope = element.treeScope().isInclusiveAncestorOf(scopingNode->treeScope());
+        bool isInnerTreeScope = element.containingTreeScope().isInclusiveAncestorOf(scopingNode->containingTreeScope());
         if (!shouldCheckScope(element, *scopingNode, isInnerTreeScope))
             continue;
 
         CascadeOrder cascadeOrder = isInnerTreeScope ? innerCascadeOrder : outerCascadeOrder;
         scopingNode->treeScope().scopedStyleResolver()->collectMatchingTreeBoundaryCrossingRules(collector, cascadeOrder);
 
         ++innerCascadeOrder;
         --outerCascadeOrder;
     }
 }
@@ skipping 1061 matching lines @@
     visitor->trace(m_siblingRuleSet);
     visitor->trace(m_uncommonAttributeRuleSet);
     visitor->trace(m_watchedSelectorsRules);
     visitor->trace(m_treeBoundaryCrossingScopes);
     visitor->trace(m_styleSharingLists);
     visitor->trace(m_pendingStyleSheets);
     visitor->trace(m_document);
 }
 
 } // namespace blink