Move Node/ContainerNode's traverseToChildAt() to NodeTraversal

Source/core/editing/TextIterator.cpp

 /*
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2012 Apple Inc. All rights reserved.
  * Copyright (C) 2005 Alexey Proskuryakov.
  *
  * 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
@@ skipping 158 matching lines @@
 }
 
 #endif
 
 // This function is like Range::pastLastNode, except for the fact that it can climb up out of shadow trees.
 static Node* nextInPreOrderCrossingShadowBoundaries(Node* rangeEndContainer, int rangeEndOffset)
 {
     if (!rangeEndContainer)
         return 0;
     if (rangeEndOffset >= 0 && !rangeEndContainer->offsetInCharacters()) {
-        if (Node* next = rangeEndContainer->traverseToChildAt(rangeEndOffset))
+        if (Node* next = NodeTraversal::childAt(*rangeEndContainer, rangeEndOffset))
             return next;
     }
     for (Node* node = rangeEndContainer; node; node = node->parentOrShadowHostNode()) {
         if (Node* next = node->nextSibling())
             return next;
     }
     return 0;
 }
 
 // --------
@@ skipping 135 matching lines @@
     // the common ancestor tree scope.
     const TreeScope* commonAncestorTreeScope = startContainer->treeScope().commonAncestorTreeScope(endContainer->treeScope());
     ASSERT(commonAncestorTreeScope);
     m_shadowDepth = 0;
     for (const TreeScope* treeScope = &startContainer->treeScope(); treeScope != commonAncestorTreeScope; treeScope = treeScope->parentTreeScope())
         ++m_shadowDepth;
 
     // Set up the current node for processing.
     if (startContainer->offsetInCharacters())
         m_node = startContainer;
-    else if (Node* child = startContainer->traverseToChildAt(startOffset))
+    else if (Node* child = NodeTraversal::childAt(*startContainer, startOffset))
         m_node = child;
     else if (!startOffset)
         m_node = startContainer;
     else
         m_node = NodeTraversal::nextSkippingChildren(*startContainer);
 
     if (!m_node)
         return;
 
     m_node->document().updateLayoutIgnorePendingStylesheets();
@@ skipping 861 matching lines @@
     RefPtrWillBeRawPtr<Range> textRange = range();
     if (!textRange)
         return 0;
 
     Node* node = textRange->startContainer();
     if (!node)
         return 0;
     if (node->offsetInCharacters())
         return node;
 
-    return node->traverseToChildAt(textRange->startOffset());
+    return NodeTraversal::childAt(*node, textRange->startOffset());
 }
 
 // --------
 
 SimplifiedBackwardsTextIterator::SimplifiedBackwardsTextIterator(const Range* r, TextIteratorBehaviorFlags behavior)
     : m_node(nullptr)
     , m_offset(0)
     , m_handledNode(false)
     , m_handledChildren(false)
     , m_startNode(nullptr)
@@ skipping 20 matching lines @@
         return;
 
     Node* startNode = r->startContainer();
     if (!startNode)
         return;
     Node* endNode = r->endContainer();
     int startOffset = r->startOffset();
     int endOffset = r->endOffset();
 
     if (!startNode->offsetInCharacters() && startOffset >= 0) {
-        // traverseToChildAt() will return 0 if the offset is out of range. We rely on this behavior
+        // NodeTraversal::childAt() will return 0 if the offset is out of range. We rely on this behavior
         // instead of calling countChildren() to avoid traversing the children twice.
-        if (Node* childAtOffset = startNode->traverseToChildAt(startOffset)) {
+        if (Node* childAtOffset = NodeTraversal::childAt(*startNode, startOffset)) {
             startNode = childAtOffset;
             startOffset = 0;
         }
     }
     if (!endNode->offsetInCharacters() && endOffset > 0) {
-        // traverseToChildAt() will return 0 if the offset is out of range. We rely on this behavior
+        // NodeTraversal::childAt() will return 0 if the offset is out of range. We rely on this behavior
         // instead of calling countChildren() to avoid traversing the children twice.
-        if (Node* childAtOffset = endNode->traverseToChildAt(endOffset - 1)) {
+        if (Node* childAtOffset = NodeTraversal::childAt(*endNode, endOffset - 1)) {
             endNode = childAtOffset;
             endOffset = lastOffsetInNode(endNode);
         }
     }
 
     m_node = endNode;
     setUpFullyClippedStack(m_fullyClippedStack, m_node);
     m_offset = endOffset;
     m_handledNode = false;
     m_handledChildren = !endOffset;
@@ skipping 941 matching lines @@
             resultEnd = collapseTo;
             return;
         }
     }
 
     CharacterIterator computeRangeIterator(inputStart, inputEnd, iteratorFlagsForFindPlainText);
     calculateCharacterSubrange(computeRangeIterator, matchStart, matchLength, resultStart, resultEnd);
 }
 
 }