Rename Node::treeScope() to Node::treeScopeOrDocument()

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 211 matching lines @@
 {
     for (unsigned i = 0; i < styleSheets.size(); ++i)
         m_pendingStyleSheets.remove(styleSheets[i].get());
 }
 
 void StyleResolver::appendCSSStyleSheet(CSSStyleSheet& cssSheet)
 {
     ASSERT(!cssSheet.disabled());
     ASSERT(cssSheet.ownerDocument());
     ASSERT(cssSheet.ownerNode());
-    ASSERT(isHTMLStyleElement(cssSheet.ownerNode()) || isSVGStyleElement(cssSheet.ownerNode()) || cssSheet.ownerNode()->treeScope() == cssSheet.ownerDocument());
+    ASSERT(isHTMLStyleElement(cssSheet.ownerNode()) || isSVGStyleElement(cssSheet.ownerNode()) || cssSheet.ownerNode()->treeScopeOrDocument() == cssSheet.ownerDocument());
 
     if (cssSheet.mediaQueries() && !m_medium->eval(cssSheet.mediaQueries(), &m_viewportDependentMediaQueryResults, &m_deviceDependentMediaQueryResults))
         return;
 
-    TreeScope* treeScope = &cssSheet.ownerNode()->treeScope();
+    TreeScope* treeScope = &cssSheet.ownerNode()->treeScopeOrDocument();
     // TODO(rune@opera.com): This is a workaround for crbug.com/559292
     // when we're in the middle of removing a subtree with a style element
     // and the treescope has been changed but inDocument and isInShadowTree
     // are not.
     //
     // This check can be removed when crbug.com/567021 is fixed.
     if (cssSheet.ownerNode()->isInShadowTree() && treeScope->rootNode().isDocumentNode())
         return;
 
     // Sheets in the document scope of HTML imports apply to the main document
@@ skipping 133 matching lines @@
     return *m_styleSharingLists[depth];
 }
 
 void StyleResolver::clearStyleSharingList()
 {
     m_styleSharingLists.resize(0);
 }
 
 static inline ScopedStyleResolver* scopedResolverFor(const Element& element)
 {
-    // Ideally, returning element->treeScope().scopedStyleResolver() should be
+    // Ideally, returning element->treeScopeOrDocument().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_treeBoundaryCrossingScopes.
     // 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();
+    TreeScope* treeScope = &element.treeScopeOrDocument();
     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())
@@ skipping 20 matching lines @@
 }
 
 static void matchSlottedRules(const Element& element, ElementRuleCollector& collector)
 {
     HTMLSlotElement* slot = element.assignedSlot();
     if (!slot)
         return;
 
     HeapVector<Member<ScopedStyleResolver>> resolvers;
     for (; slot; slot = slot->assignedSlot()) {
-        if (ScopedStyleResolver* resolver = slot->treeScope().scopedStyleResolver())
+        if (ScopedStyleResolver* resolver = slot->treeScopeOrDocument().scopedStyleResolver())
             resolvers.append(resolver);
     }
     for (auto it = resolvers.rbegin(); it != resolvers.rend(); ++it) {
         collector.clearMatchedRules();
         (*it)->collectMatchingTreeBoundaryCrossingRules(collector);
         collector.sortAndTransferMatchedRules();
         collector.finishAddingAuthorRulesForTreeScope();
     }
 }
 
@@ skipping 10 matching lines @@
         // Inline style is immutable as long as there is no CSSOM wrapper.
         bool isInlineStyleCacheable = !element.inlineStyle()->isMutable();
         collector.addElementStyleProperties(element.inlineStyle(), isInlineStyleCacheable);
     }
 
     collector.finishAddingAuthorRulesForTreeScope();
 }
 
 static bool shouldCheckScope(const Element& element, const Node& scopingNode, bool isInnerTreeScope)
 {
-    if (isInnerTreeScope && element.treeScope() != scopingNode.treeScope()) {
+    if (isInnerTreeScope && element.treeScopeOrDocument() != scopingNode.treeScopeOrDocument()) {
         // Check if |element| may be affected by a ::content rule in |scopingNode|'s style.
         // If |element| is a descendant of a shadow host which is ancestral to |scopingNode|,
         // the |element| should be included for rule collection.
         // Skip otherwise.
-        const TreeScope* scope = &scopingNode.treeScope();
-        while (scope && scope->parentTreeScope() != &element.treeScope())
+        const TreeScope* scope = &scopingNode.treeScopeOrDocument();
+        while (scope && scope->parentTreeScope() != &element.treeScopeOrDocument())
             scope = scope->parentTreeScope();
         Element* shadowHost = scope ? scope->rootNode().shadowHost() : nullptr;
         return shadowHost && element.isDescendantOf(shadowHost);
     }
 
     // When |element| can be distributed to |scopingNode| via <shadow>, ::content rule can match,
     // thus the case should be included.
-    if (!isInnerTreeScope && scopingNode.parentOrShadowHostNode() == element.treeScope().rootNode().parentOrShadowHostNode())
+    if (!isInnerTreeScope && scopingNode.parentOrShadowHostNode() == element.treeScopeOrDocument().rootNode().parentOrShadowHostNode())
         return true;
 
     // Obviously cases when ancestor scope has /deep/ or ::shadow rule should be included.
     // Skip otherwise.
-    return scopingNode.treeScope().scopedStyleResolver()->hasDeepOrShadowSelector();
+    return scopingNode.treeScopeOrDocument().scopedStyleResolver()->hasDeepOrShadowSelector();
 }
 
 void StyleResolver::matchScopedRules(const Element& element, ElementRuleCollector& collector)
 {
     // Match rules from treeScopes in the reverse tree-of-trees order, since the
     // cascading order for normal rules is such that when comparing rules from
     // different shadow trees, the rule from the tree which comes first in the
     // tree-of-trees order wins. From other treeScopes than the element's own
     // scope, only tree-boundary-crossing rules may match.
 
     ScopedStyleResolver* elementScopeResolver = scopedResolverFor(element);
 
     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)->treeScopeOrDocument();
         ScopedStyleResolver* resolver = scope.scopedStyleResolver();
         ASSERT(resolver);
 
-        bool isInnerTreeScope = element.treeScope().isInclusiveAncestorOf(scope);
+        bool isInnerTreeScope = element.treeScopeOrDocument().isInclusiveAncestorOf(scope);
         if (!shouldCheckScope(element, **it, isInnerTreeScope))
             continue;
 
-        if (!matchElementScopeDone && scope.isInclusiveAncestorOf(element.treeScope())) {
+        if (!matchElementScopeDone && scope.isInclusiveAncestorOf(element.treeScopeOrDocument())) {
 
             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.treeScopeOrDocument().isInclusiveAncestorOf(scopingNode->treeScopeOrDocument());
         if (!shouldCheckScope(element, *scopingNode, isInnerTreeScope))
             continue;
 
         CascadeOrder cascadeOrder = isInnerTreeScope ? innerCascadeOrder : outerCascadeOrder;
-        scopingNode->treeScope().scopedStyleResolver()->collectMatchingTreeBoundaryCrossingRules(collector, cascadeOrder);
+        scopingNode->treeScopeOrDocument().scopedStyleResolver()->collectMatchingTreeBoundaryCrossingRules(collector, cascadeOrder);
 
         ++innerCascadeOrder;
         --outerCascadeOrder;
     }
 }
 
 PassRefPtr<ComputedStyle> StyleResolver::styleForDocument(Document& document)
 {
     const LocalFrame* frame = document.frame();
 
@@ skipping 464 matching lines @@
 
     state.setApplyPropertyToVisitedLinkStyle(false);
 
     return true;
 }
 
 StyleRuleKeyframes* StyleResolver::findKeyframesRule(const Element* element, const AtomicString& animationName)
 {
     HeapVector<Member<ScopedStyleResolver>, 8> resolvers;
     collectScopedResolversForHostedShadowTrees(*element, resolvers);
-    if (ScopedStyleResolver* scopedResolver = element->treeScope().scopedStyleResolver())
+    if (ScopedStyleResolver* scopedResolver = element->treeScopeOrDocument().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;
 }
 
 template <CSSPropertyPriority priority>
@@ skipping 570 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