Rename childNodeCount() / childNode() methods for clarity

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 157 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->childNode(rangeEndOffset))
+        if (Node* next = rangeEndContainer->traverseToChildAt(rangeEndOffset))
             return next;
     }
     for (Node* node = rangeEndContainer; node; node = node->parentOrShadowHostNode()) {
         if (Node* next = node->nextSibling())
             return next;
     }
     return 0;
 }
 
 // --------
@@ skipping 947 matching lines @@
     RefPtr<Range> textRange = range();
     if (!textRange)
         return 0;
 
     Node* node = textRange->startContainer();
     if (!node)
         return 0;
     if (node->offsetInCharacters())
         return node;
 
-    return node->childNode(textRange->startOffset());
+    return node->traverseToChildAt(textRange->startOffset());
 }
 
 // --------
 
 SimplifiedBackwardsTextIterator::SimplifiedBackwardsTextIterator(const Range* r, TextIteratorBehaviorFlags behavior)
     : m_node(0)
     , m_offset(0)
     , m_handledNode(false)
     , m_handledChildren(false)
     , m_startNode(0)
@@ 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) {
-        // childNode() will return 0 if the offset is out of range. We rely on this behavior
-        // instead of calling childNodeCount() to avoid traversing the children twice.
-        if (Node* childAtOffset = startNode->childNode(startOffset)) {
+        // traverseToChildAt() 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)) {
             startNode = childAtOffset;
             startOffset = 0;
         }
     }
     if (!endNode->offsetInCharacters() && endOffset > 0) {
-        // childNode() will return 0 if the offset is out of range. We rely on this behavior
-        // instead of calling childNodeCount() to avoid traversing the children twice.
-        if (Node* childAtOffset = endNode->childNode(endOffset - 1)) {
+        // traverseToChildAt() 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)) {
             endNode = childAtOffset;
             endOffset = lastOffsetInNode(endNode);
         }
     }
 
     m_node = endNode;
     setUpFullyClippedStack(m_fullyClippedStack, m_node);
     m_offset = endOffset;
     m_handledNode = false;
     m_handledChildren = !endOffset;
@@ skipping 42 matching lines @@
             } else if (renderer && (renderer->isImage() || renderer->isWidget())) {
                 if (renderer->style()->visibility() == VISIBLE && m_offset > 0)
                     m_handledNode = handleReplacedElement();
             } else {
                 m_handledNode = handleNonTextNode();
             }
             if (m_positionNode)
                 return;
         }
 
-        if (!m_handledChildren && m_node->hasChildNodes()) {
+        if (!m_handledChildren && m_node->hasChildren()) {
             m_node = m_node->lastChild();
             pushFullyClippedState(m_fullyClippedStack, m_node);
         } else {
             // Exit empty containers as we pass over them or containers
             // where [container, 0] is where we started iterating.
             if (!m_handledNode
                 && canHaveChildrenForEditing(m_node)
                 && m_node->parentNode()
                 && (!m_node->lastChild() || (m_node == m_endNode && !m_endOffset))) {
                 exitNode();
@@ skipping 810 matching lines @@
         if (!matchLength)
             return collapsedToBoundary(range, !(options & Backwards));
     }
 
     // Then, find the document position of the start and the end of the text.
     CharacterIterator computeRangeIterator(range, TextIteratorEntersTextControls | TextIteratorEntersAuthorShadowRoots);
     return characterSubrange(computeRangeIterator, matchStart, matchLength);
 }
 
 }