Get rid of a redundant function Position::deprecatedEditingOffset()

Source/core/editing/Position.cpp

 /*
  * Copyright (C) 2004, 2005, 2006, 2009 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 186 matching lines @@
 }
 
 template <typename Strategy>
 int PositionAlgorithm<Strategy>::computeEditingOffset() const
 {
     if (isAfterAnchorOrAfterChildren())
         return Strategy::lastOffsetForEditing(m_anchorNode.get());
     return m_offset;
 }
 
-// TODO(yosin) We should replace all usage of |deprecatedEditingOffset()| by
-// |computeEditingOffset()|.
-template <typename Strategy>
-int PositionAlgorithm<Strategy>::deprecatedEditingOffset() const
-{
-    return computeEditingOffset();
-}
-
 template <typename Strategy>
 Node* PositionAlgorithm<Strategy>::computeNodeBeforePosition() const
 {
     if (!m_anchorNode)
         return 0;
     switch (anchorType()) {
     case PositionAnchorType::BeforeChildren:
         return 0;
     case PositionAnchorType::AfterChildren:
         return Strategy::lastChild(*m_anchorNode);
@@ skipping 96 matching lines @@
     return comparePositions(*this, other);
 }
 
 template <typename Strategy>
 PositionAlgorithm<Strategy> PositionAlgorithm<Strategy>::previous(PositionMoveType moveType) const
 {
     Node* node = anchorNode();
     if (!node)
         return PositionAlgorithm<Strategy>(*this);
 
-    int offset = deprecatedEditingOffset();
+    int offset = computeEditingOffset();
 
     if (offset > 0) {
         if (editingIgnoresContent(node))
             return beforeNode(node);
         if (Node* child = Strategy::childAt(*node, offset - 1))
             return lastPositionInOrAfterNode(child);
 
         // There are two reasons child might be 0:
         //   1) The node is node like a text node that is not an element, and therefore has no children.
         //      Going backward one character at a time is correct.
@@ skipping 21 matching lines @@
 
 template <typename Strategy>
 PositionAlgorithm<Strategy> PositionAlgorithm<Strategy>::next(PositionMoveType moveType) const
 {
     ASSERT(moveType != BackwardDeletion);
 
     Node* node = anchorNode();
     if (!node)
         return PositionAlgorithm<Strategy>(*this);
 
-    int offset = deprecatedEditingOffset();
+    int offset = computeEditingOffset();
 
     if (Node* child = Strategy::childAt(*node, offset))
         return firstPositionInOrBeforeNode(child);
 
     // TODO(yosin) We should use |Strategy::lastOffsetForEditing()| instead of
     // DOM tree version.
     if (!Strategy::hasChildren(*node) && offset < EditingStrategy::lastOffsetForEditing(node)) {
         // There are two reasons child might be 0:
         //   1) The node is node like a text node that is not an element, and therefore has no children.
         //      Going forward one character at a time is correct.
@@ skipping 632 matching lines @@
         lastPosition = position;
         position = position.upstream(CanCrossEditingBoundary);
     }
     return position;
 }
 
 template <typename Strategy>
 InlineBoxPosition PositionAlgorithm<Strategy>::computeInlineBoxPosition(EAffinity affinity, TextDirection primaryDirection) const
 {
     InlineBox* inlineBox = nullptr;
-    int caretOffset = deprecatedEditingOffset();
+    int caretOffset = computeEditingOffset();
     LayoutObject* layoutObject = m_anchorNode->isShadowRoot() ? toShadowRoot(m_anchorNode)->host()->layoutObject() : m_anchorNode->layoutObject();
 
     if (!layoutObject->isText()) {
         inlineBox = 0;
         if (canHaveChildrenForEditing(anchorNode()) && layoutObject->isLayoutBlockFlow() && hasRenderedNonAnonymousDescendantsWithHeight(layoutObject)) {
             // Try a visually equivalent position with possibly opposite
             // editability. This helps in case |this| is in an editable block
             // but surrounded by non-editable positions. It acts to negate the
             // logic at the beginning of LayoutObject::createVisiblePosition().
             PositionAlgorithm<Strategy> thisPosition = PositionAlgorithm<Strategy>(*this);
@@ skipping 324 matching lines @@
 
 void showTree(const blink::Position* pos)
 {
     if (pos)
         pos->showTreeForThis();
     else
         fprintf(stderr, "Cannot showTree for (nil)\n");
 }
 
 #endif