Move Node::lengthOfContents into Range, its only user.

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

 /*
  * (C) 1999 Lars Knoll (knoll@kde.org)
  * (C) 2000 Gunnstein Lye (gunnstein@netcom.no)
  * (C) 2000 Frederik Holljen (frederik.holljen@hig.no)
  * (C) 2001 Peter Kelly (pmk@post.com)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All
  * rights reserved.
  * Copyright (C) 2011 Motorola Mobility. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #include "core/dom/Range.h"
 
 #include "bindings/core/v8/ExceptionState.h"
+#include "core/dom/CharacterData.h"
 #include "core/dom/ClientRect.h"
 #include "core/dom/ClientRectList.h"
+#include "core/dom/ContainerNode.h"
 #include "core/dom/DocumentFragment.h"
 #include "core/dom/ExceptionCode.h"
 #include "core/dom/Node.h"
 #include "core/dom/NodeTraversal.h"
 #include "core/dom/NodeWithIndex.h"
 #include "core/dom/ProcessingInstruction.h"
 #include "core/dom/Text.h"
 #include "core/editing/EditingUtilities.h"
 #include "core/editing/EphemeralRange.h"
 #include "core/editing/FrameSelection.h"
@@ skipping 480 matching lines @@
     for (unsigned i = 0; container && i < offset; i++)
       container = container->nextSibling();
   } else {
     while (container->parentNode() != commonRoot)
       container = container->parentNode();
   }
 
   return container;
 }
 
+static unsigned lengthOfContents(const Node* node) {
+  // This switch statement must be consistent with that of
+  // Range::processContentsBetweenOffsets.
+  switch (node->getNodeType()) {
+    case Node::kTextNode:
+    case Node::kCdataSectionNode:
+    case Node::kCommentNode:
+    case Node::kProcessingInstructionNode:
+      return toCharacterData(node)->length();
+    case Node::kElementNode:
+    case Node::kDocumentNode:
+    case Node::kDocumentFragmentNode:
+      return toContainerNode(node)->countChildren();
+    case Node::kAttributeNode:
+    case Node::kDocumentTypeNode:
+      return 0;
+  }
+  NOTREACHED();
+  return 0;
+}
+
 DocumentFragment* Range::processContents(ActionType action,
                                          ExceptionState& exceptionState) {
   typedef HeapVector<Member<Node>> NodeVector;
 
   DocumentFragment* fragment = nullptr;
   if (action == EXTRACT_CONTENTS || action == CLONE_CONTENTS)
     fragment = DocumentFragment::create(*m_ownerDocument.get());
 
   if (collapsed())
     return fragment;
@@ skipping 39 matching lines @@
 
   // Note that we are verifying that our common root hierarchy is still intact
   // after any DOM mutation event, at various stages below. See webkit bug
   // 60350.
 
   Node* leftContents = nullptr;
   if (originalStart.container() != commonRoot &&
       commonRoot->contains(originalStart.container())) {
     leftContents = processContentsBetweenOffsets(
         action, nullptr, originalStart.container(), originalStart.offset(),
-        originalStart.container()->lengthOfContents(), exceptionState);
+        lengthOfContents(originalStart.container()), exceptionState);
     leftContents = processAncestorsAndTheirSiblings(
         action, originalStart.container(), ProcessContentsForward, leftContents,
         commonRoot, exceptionState);
   }
 
   Node* rightContents = nullptr;
   if (m_end.container() != commonRoot &&
       commonRoot->contains(originalEnd.container())) {
     rightContents =
         processContentsBetweenOffsets(action, nullptr, originalEnd.container(),
@@ skipping 67 matching lines @@
 Node* Range::processContentsBetweenOffsets(ActionType action,
                                            DocumentFragment* fragment,
                                            Node* container,
                                            unsigned startOffset,
                                            unsigned endOffset,
                                            ExceptionState& exceptionState) {
   DCHECK(container);
   DCHECK_LE(startOffset, endOffset);
 
   // This switch statement must be consistent with that of
-  // Node::lengthOfContents.
+  // lengthOfContents.
   Node* result = nullptr;
   switch (container->getNodeType()) {
     case Node::kTextNode:
     case Node::kCdataSectionNode:
     case Node::kCommentNode:
     case Node::kProcessingInstructionNode:
       endOffset = std::min(endOffset, toCharacterData(container)->length());
       if (action == EXTRACT_CONTENTS || action == CLONE_CONTENTS) {
         CharacterData* c =
             static_cast<CharacterData*>(container->cloneNode(true));
@@ skipping 1113 matching lines @@
                      .data()
               << "start offset: " << range->startOffset()
               << ", end offset: " << range->endOffset();
   } else {
     LOG(INFO) << "Cannot show tree if range is null, or if boundary points are "
                  "invalid.";
   }
 }
 
 #endif