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

third_party/WebKit/Source/core/dom/Node.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2001 Dirk Mueller (mueller@kde.org)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All rights reserved.
  * Copyright (C) 2008 Nokia Corporation and/or its subsidiary(-ies)
  * Copyright (C) 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
@@ skipping 439 matching lines @@
             last = currentElement->pseudoElement(PseudoIdBefore);
         return last;
     }
 
     return lastChild();
 }
 
 Node& Node::treeRoot() const
 {
     if (isInTreeScope())
-        return treeScope().rootNode();
+        return treeScopeOrDocument().rootNode();
     const Node* node = this;
     while (node->parentNode())
         node = node->parentNode();
     return const_cast<Node&>(*node);
 }
 
 Node* Node::insertBefore(Node* newChild, Node* refChild, ExceptionState& exceptionState)
 {
     if (isContainerNode())
         return toContainerNode(this)->insertBefore(newChild, refChild, exceptionState);
@@ skipping 320 matching lines @@
 void Node::clearNodeLists()
 {
     rareData()->clearNodeLists();
 }
 
 bool Node::isDescendantOf(const Node *other) const
 {
     // Return true if other is an ancestor of this, otherwise false
     if (!other || !other->hasChildren() || inShadowIncludingDocument() != other->inShadowIncludingDocument())
         return false;
-    if (other->treeScope() != treeScope())
+    if (other->treeScopeOrDocument() != treeScopeOrDocument())
         return false;
     if (other->isTreeScope())
         return !isTreeScope();
     for (const ContainerNode* n = parentNode(); n; n = n->parentNode()) {
         if (n == other)
             return true;
     }
     return false;
 }
 
@@ skipping 17 matching lines @@
 
     if (inShadowIncludingDocument() != node->inShadowIncludingDocument())
         return false;
 
     bool hasChildren = isContainerNode() && toContainerNode(this)->hasChildren();
     bool hasShadow = isElementNode() && toElement(this)->shadow();
     if (!hasChildren && !hasShadow)
         return false;
 
     for (; node; node = node->shadowHost()) {
-        if (treeScope() == node->treeScope())
+        if (treeScopeOrDocument() == node->treeScopeOrDocument())
             return contains(node);
     }
 
     return false;
 }
 
 Node* Node::retarget(const Node& target) const
 {
     for (const Node* ancestor = &target; ancestor; ancestor = ancestor->shadowHost()) {
-        if (treeScope() == ancestor->treeScope())
+        if (treeScopeOrDocument() == ancestor->treeScopeOrDocument())
             return const_cast<Node*>(ancestor);
     }
     return nullptr;
 }
 
 bool Node::containsIncludingHostElements(const Node& node) const
 {
     const Node* current = &node;
     do {
         if (current == this)
@@ skipping 182 matching lines @@
 
 Element* Node::shadowHost() const
 {
     if (ShadowRoot* root = containingShadowRoot())
         return root->host();
     return nullptr;
 }
 
 ShadowRoot* Node::containingShadowRoot() const
 {
-    Node& root = treeScope().rootNode();
+    Node& root = treeScopeOrDocument().rootNode();
     return root.isShadowRoot() ? toShadowRoot(&root) : nullptr;
 }
 
 Node* Node::nonBoundaryShadowTreeRootNode()
 {
     DCHECK(!isShadowRoot());
     Node* root = this;
     while (root) {
         if (root->isShadowRoot())
             return root;
@@ skipping 371 matching lines @@
                 return DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC | DOCUMENT_POSITION_PRECEDING;
         }
 
         ASSERT_NOT_REACHED();
         return DOCUMENT_POSITION_DISCONNECTED;
     }
 
     // If one node is in the document and the other is not, we must be disconnected.
     // If the nodes have different owning documents, they must be disconnected.  Note that we avoid
     // comparing Attr nodes here, since they return false from inShadowIncludingDocument() all the time (which seems like a bug).
-    if (start1->inShadowIncludingDocument() != start2->inShadowIncludingDocument() || (treatment == TreatShadowTreesAsDisconnected && start1->treeScope() != start2->treeScope())) {
+    if (start1->inShadowIncludingDocument() != start2->inShadowIncludingDocument() || (treatment == TreatShadowTreesAsDisconnected && start1->treeScopeOrDocument() != start2->treeScopeOrDocument())) {
         unsigned short direction = (this > otherNode) ? DOCUMENT_POSITION_PRECEDING : DOCUMENT_POSITION_FOLLOWING;
         return DOCUMENT_POSITION_DISCONNECTED | DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC | direction;
     }
 
     // We need to find a common ancestor container, and then compare the indices of the two immediate children.
     const Node* current;
     for (current = start1; current; current = current->parentOrShadowHostNode())
         chain1.append(current);
     for (current = start2; current; current = current->parentOrShadowHostNode())
         chain2.append(current);
 
     unsigned index1 = chain1.size();
     unsigned index2 = chain2.size();
 
     // If the two elements don't have a common root, they're not in the same tree.
     if (chain1[index1 - 1] != chain2[index2 - 1]) {
         unsigned short direction = (this > otherNode) ? DOCUMENT_POSITION_PRECEDING : DOCUMENT_POSITION_FOLLOWING;
         return DOCUMENT_POSITION_DISCONNECTED | DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC | direction;
     }
 
-    unsigned connection = start1->treeScope() != start2->treeScope() ? DOCUMENT_POSITION_DISCONNECTED | DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC : 0;
+    unsigned connection = start1->treeScopeOrDocument() != start2->treeScopeOrDocument() ? DOCUMENT_POSITION_DISCONNECTED | DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC : 0;
 
     // Walk the two chains backwards and look for the first difference.
     for (unsigned i = std::min(index1, index2); i; --i) {
         const Node* child1 = chain1[--index1];
         const Node* child2 = chain2[--index2];
         if (child1 != child2) {
             // If one of the children is an attribute, it wins.
             if (child1->getNodeType() == ATTRIBUTE_NODE)
                 return DOCUMENT_POSITION_FOLLOWING | connection;
             if (child2->getNodeType() == ATTRIBUTE_NODE)
@@ skipping 779 matching lines @@
 }
 
 // It's important not to inline removedLastRef, because we don't want to inline the code to
 // delete a Node at each deref call site.
 void Node::removedLastRef()
 {
     // An explicit check for Document here is better than a virtual function since it is
     // faster for non-Document nodes, and because the call to removedLastRef that is inlined
     // at all deref call sites is smaller if it's a non-virtual function.
     if (isTreeScope()) {
-        treeScope().removedLastRefToScope();
+        treeScopeOrDocument().removedLastRefToScope();
         return;
     }
 
 #if ENABLE(SECURITY_ASSERT)
     m_deletionHasBegun = true;
 #endif
     delete this;
 }
 #endif
 
@@ skipping 192 matching lines @@
 
 void showNodePath(const blink::Node* node)
 {
     if (node)
         node->showNodePathForThis();
     else
         fprintf(stderr, "Cannot showNodePath for (nil)\n");
 }
 
 #endif