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

third_party/WebKit/Source/core/editing/SelectionAdjuster.cpp

 /*
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 81 matching lines @@
     // We use |firstChild|'s after instead of beforeAllChildren for backward
     // compatibility. The positions are same but the anchors would be different,
     // and selection painting uses anchor nodes.
     if (Node* firstChild = FlatTreeTraversal::firstChild(*shadowHost))
         return PositionInFlatTree::beforeNode(firstChild);
     return PositionInFlatTree();
 }
 
 Position adjustPositionForEnd(const Position& currentPosition, Node* startContainerNode)
 {
-    TreeScope& treeScope = startContainerNode->treeScope();
+    TreeScope& treeScope = startContainerNode->treeScopeOrDocument();
 
-    ASSERT(currentPosition.computeContainerNode()->treeScope() != treeScope);
+    ASSERT(currentPosition.computeContainerNode()->treeScopeOrDocument() != treeScope);
 
     if (Node* ancestor = treeScope.ancestorInThisScope(currentPosition.computeContainerNode())) {
         if (ancestor->contains(startContainerNode))
             return positionAfterNode(ancestor);
         return positionBeforeNode(ancestor);
     }
 
     if (Node* lastChild = treeScope.rootNode().lastChild())
         return positionAfterNode(lastChild);
 
@@ skipping 11 matching lines @@
     // We use |lastChild|'s after instead of afterAllChildren for backward
     // compatibility. The positions are same but the anchors would be different,
     // and selection painting uses anchor nodes.
     if (Node* lastChild = FlatTreeTraversal::lastChild(*shadowHost))
         return PositionInFlatTree::afterNode(lastChild);
     return PositionInFlatTree();
 }
 
 Position adjustPositionForStart(const Position& currentPosition, Node* endContainerNode)
 {
-    TreeScope& treeScope = endContainerNode->treeScope();
+    TreeScope& treeScope = endContainerNode->treeScopeOrDocument();
 
-    ASSERT(currentPosition.computeContainerNode()->treeScope() != treeScope);
+    ASSERT(currentPosition.computeContainerNode()->treeScopeOrDocument() != treeScope);
 
     if (Node* ancestor = treeScope.ancestorInThisScope(currentPosition.computeContainerNode())) {
         if (ancestor->contains(endContainerNode))
             return positionBeforeNode(ancestor);
         return positionAfterNode(ancestor);
     }
 
     if (Node* firstChild = treeScope.rootNode().firstChild())
         return positionBeforeNode(firstChild);
 
@@ skipping 31 matching lines @@
         selectionInFlatTree->m_end = position1;
     }
     selectionInFlatTree->updateSelectionType();
     selectionInFlatTree->didChange();
 }
 
 static bool isCrossingShadowBoundaries(const VisibleSelectionInFlatTree& selection)
 {
     if (!selection.isRange())
         return false;
-    TreeScope& treeScope = selection.base().anchorNode()->treeScope();
-    return selection.extent().anchorNode()->treeScope() != treeScope
-        || selection.start().anchorNode()->treeScope() != treeScope
-        || selection.end().anchorNode()->treeScope() != treeScope;
+    TreeScope& treeScope = selection.base().anchorNode()->treeScopeOrDocument();
+    return selection.extent().anchorNode()->treeScopeOrDocument() != treeScope
+        || selection.start().anchorNode()->treeScopeOrDocument() != treeScope
+        || selection.end().anchorNode()->treeScopeOrDocument() != treeScope;
 }
 
 void SelectionAdjuster::adjustSelectionInDOMTree(VisibleSelection* selection, const VisibleSelectionInFlatTree& selectionInFlatTree)
 {
     if (selectionInFlatTree.isNone()) {
         *selection = VisibleSelection();
         return;
     }
 
     const Position& base = toPositionInDOMTree(selectionInFlatTree.base());
@@ skipping 27 matching lines @@
 void SelectionAdjuster::adjustSelectionToAvoidCrossingShadowBoundaries(VisibleSelection* selection)
 {
     // Note: |m_selectionType| isn't computed yet.
     ASSERT(selection->base().isNotNull());
     ASSERT(selection->extent().isNotNull());
     ASSERT(selection->start().isNotNull());
     ASSERT(selection->end().isNotNull());
 
     // TODO(hajimehoshi): Checking treeScope is wrong when a node is
     // distributed, but we leave it as it is for backward compatibility.
-    if (selection->start().anchorNode()->treeScope() == selection->end().anchorNode()->treeScope())
+    if (selection->start().anchorNode()->treeScopeOrDocument() == selection->end().anchorNode()->treeScopeOrDocument())
         return;
 
     if (selection->isBaseFirst()) {
         const Position& newEnd = adjustPositionForEnd(selection->end(), selection->start().computeContainerNode());
         selection->m_extent = newEnd;
         selection->m_end = newEnd;
         return;
     }
 
     const Position& newStart = adjustPositionForStart(selection->start(), selection->end().computeContainerNode());
@@ skipping 18 matching lines @@
         selection->m_end = newEnd;
         return;
     }
     Node* const shadowHost = shadowHostEnd ? shadowHostEnd : shadowHostStart;
     const PositionInFlatTree& newStart = adjustPositionInFlatTreeForStart(selection->start(), shadowHost);
     selection->m_extent = newStart;
     selection->m_start = newStart;
 }
 
 } // namespace blink