Mark the createVisiblePosition overloads as deprecated

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

 /*
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 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 183 matching lines @@
         return PositionWithAffinityTemplate<Strategy>();
 
     // Return the last position before |pos| that is in the same editable region
     // as this position
     return lastEditablePositionBeforePositionInRoot(pos.position(), *highestRoot);
 }
 
 template <typename Strategy>
 static VisiblePositionTemplate<Strategy> honorEditingBoundaryAtOrBefore(const VisiblePositionTemplate<Strategy>& pos, const PositionTemplate<Strategy>& anchor)
 {
-    return createVisiblePosition(honorEditingBoundaryAtOrBefore(pos.toPositionWithAffinity(), anchor));
+    return createVisiblePositionDeprecated(honorEditingBoundaryAtOrBefore(pos.toPositionWithAffinity(), anchor));
 }
 
 template <typename Strategy>
 static VisiblePositionTemplate<Strategy> honorEditingBoundaryAtOrAfter(const VisiblePositionTemplate<Strategy>& pos, const PositionTemplate<Strategy>& anchor)
 {
     if (pos.isNull())
         return pos;
 
     ContainerNode* highestRoot = highestEditableRoot(anchor);
 
@@ skipping 94 matching lines @@
     }
     return 0;
 }
 
 // FIXME: consolidate with code in previousLinePosition.
 static Position previousRootInlineBoxCandidatePosition(Node* node, const VisiblePosition& visiblePosition, EditableType editableType)
 {
     ContainerNode* highestRoot = highestEditableRoot(visiblePosition.deepEquivalent(), editableType);
     Node* previousNode = previousLeafWithSameEditability(node, editableType);
 
-    while (previousNode && (!previousNode->layoutObject() || inSameLine(createVisiblePosition(firstPositionInOrBeforeNode(previousNode)), visiblePosition)))
+    while (previousNode && (!previousNode->layoutObject() || inSameLine(createVisiblePositionDeprecated(firstPositionInOrBeforeNode(previousNode)), visiblePosition)))
         previousNode = previousLeafWithSameEditability(previousNode, editableType);
 
     while (previousNode && !previousNode->isShadowRoot()) {
         if (highestEditableRoot(firstPositionInOrBeforeNode(previousNode), editableType) != highestRoot)
             break;
 
         Position pos = isHTMLBRElement(*previousNode) ? Position::beforeNode(previousNode) :
             Position::editingPositionOf(previousNode, caretMaxOffset(previousNode));
 
         if (isVisuallyEquivalentCandidate(pos))
             return pos;
 
         previousNode = previousLeafWithSameEditability(previousNode, editableType);
     }
     return Position();
 }
 
 static Position nextRootInlineBoxCandidatePosition(Node* node, const VisiblePosition& visiblePosition, EditableType editableType)
 {
     ContainerNode* highestRoot = highestEditableRoot(visiblePosition.deepEquivalent(), editableType);
     Node* nextNode = nextLeafWithSameEditability(node, editableType);
-    while (nextNode && (!nextNode->layoutObject() || inSameLine(createVisiblePosition(firstPositionInOrBeforeNode(nextNode)), visiblePosition)))
+    while (nextNode && (!nextNode->layoutObject() || inSameLine(createVisiblePositionDeprecated(firstPositionInOrBeforeNode(nextNode)), visiblePosition)))
         nextNode = nextLeafWithSameEditability(nextNode, ContentIsEditable);
 
     while (nextNode && !nextNode->isShadowRoot()) {
         if (highestEditableRoot(firstPositionInOrBeforeNode(nextNode), editableType) != highestRoot)
             break;
 
         Position pos;
         pos = Position::editingPositionOf(nextNode, caretMinOffset(nextNode));
 
         if (isVisuallyEquivalentCandidate(pos))
@@ skipping 412 matching lines @@
     if (needMoreContext) {
         // The last search returned the beginning of the buffer and asked for
         // more context, but there is no earlier text. Force a search with
         // what's available.
         // TODO(xiaochengh): Do we have to search the whole string?
         next = searchFunction(string.data(), string.size(), string.size() - suffixLength, DontHaveMoreContext, needMoreContext);
         DCHECK(!needMoreContext);
     }
 
     if (!next)
-        return createVisiblePosition(it.atEnd() ? it.startPosition() : pos);
+        return createVisiblePositionDeprecated(it.atEnd() ? it.startPosition() : pos);
 
     Node* node = it.startContainer();
     int boundaryOffset = remainingLength + next;
     if (node->isTextNode() && boundaryOffset <= node->maxCharacterOffset()) {
         // The next variable contains a usable index into a text node
-        return createVisiblePosition(PositionTemplate<Strategy>(node, boundaryOffset));
+        return createVisiblePositionDeprecated(PositionTemplate<Strategy>(node, boundaryOffset));
     }
 
     // Use the character iterator to translate the next value into a DOM
     // position.
     BackwardsCharacterIteratorAlgorithm<Strategy> charIt(start, end);
     charIt.advance(string.size() - suffixLength - next);
     // TODO(yosin) charIt can get out of shadow host.
-    return createVisiblePosition(charIt.endPosition());
+    return createVisiblePositionDeprecated(charIt.endPosition());
 }
 
 template <typename Strategy>
 static VisiblePositionTemplate<Strategy> nextBoundary(const VisiblePositionTemplate<Strategy>& c, BoundarySearchFunction searchFunction)
 {
     PositionTemplate<Strategy> pos = c.deepEquivalent();
     Node* boundary = parentEditingBoundary(pos);
     if (!boundary)
         return VisiblePositionTemplate<Strategy>();
 
@@ skipping 67 matching lines @@
         // Use the character iterator to translate the next value into a DOM
         // position.
         CharacterIteratorAlgorithm<Strategy> charIt(searchStart, searchEnd, TextIteratorEmitsCharactersBetweenAllVisiblePositions);
         charIt.advance(next - prefixLength - 1);
         pos = charIt.endPosition();
 
         if (charIt.characterAt(0) == '\n') {
             // TODO(yosin) workaround for collapsed range (where only start
             // position is correct) emitted for some emitted newlines
             // (see rdar://5192593)
-            const VisiblePositionTemplate<Strategy> visPos = createVisiblePosition(pos);
-            if (visPos.deepEquivalent() == createVisiblePosition(charIt.startPosition()).deepEquivalent()) {
+            const VisiblePositionTemplate<Strategy> visPos = createVisiblePositionDeprecated(pos);
+            if (visPos.deepEquivalent() == createVisiblePositionDeprecated(charIt.startPosition()).deepEquivalent()) {
                 charIt.advance(1);
                 pos = charIt.startPosition();
             }
         }
     }
 
     // generate VisiblePosition, use TextAffinity::Upstream affinity if possible
-    return createVisiblePosition(pos, VP_UPSTREAM_IF_POSSIBLE);
+    return createVisiblePositionDeprecated(pos, VP_UPSTREAM_IF_POSSIBLE);
 }
 
 // ---------
 
 static unsigned startWordBoundary(const UChar* characters, unsigned length, unsigned offset, BoundarySearchContextAvailability mayHaveMoreContext, bool& needMoreContext)
 {
     TRACE_EVENT0("blink", "startWordBoundary");
     DCHECK(offset);
     if (mayHaveMoreContext && !startOfLastWordBoundaryContext(characters, offset)) {
         needMoreContext = true;
@@ skipping 165 matching lines @@
 }
 
 static PositionInFlatTreeWithAffinity startOfLine(const PositionInFlatTreeWithAffinity& currentPosition)
 {
     return startOfLineAlgorithm<EditingInFlatTreeStrategy>(currentPosition);
 }
 
 // FIXME: Rename this function to reflect the fact it ignores bidi levels.
 VisiblePosition startOfLine(const VisiblePosition& currentPosition)
 {
-    return createVisiblePosition(startOfLine(currentPosition.toPositionWithAffinity()));
+    return createVisiblePositionDeprecated(startOfLine(currentPosition.toPositionWithAffinity()));
 }
 
 VisiblePositionInFlatTree startOfLine(const VisiblePositionInFlatTree& currentPosition)
 {
-    return createVisiblePosition(startOfLine(currentPosition.toPositionWithAffinity()));
+    return createVisiblePositionDeprecated(startOfLine(currentPosition.toPositionWithAffinity()));
 }
 
 template <typename Strategy>
 static PositionWithAffinityTemplate<Strategy> logicalStartOfLineAlgorithm(const PositionWithAffinityTemplate<Strategy>& c)
 {
     // TODO: this is the current behavior that might need to be fixed.
     // Please refer to https://bugs.webkit.org/show_bug.cgi?id=49107 for detail.
     PositionWithAffinityTemplate<Strategy> visPos = startPositionForLine(c, UseLogicalOrdering);
 
     if (ContainerNode* editableRoot = highestEditableRoot(c.position())) {
         if (!editableRoot->contains(visPos.position().computeContainerNode()))
             return PositionWithAffinityTemplate<Strategy>(PositionTemplate<Strategy>::firstPositionInNode(editableRoot));
     }
 
     return honorEditingBoundaryAtOrBefore(visPos, c.position());
 }
 
 VisiblePosition logicalStartOfLine(const VisiblePosition& currentPosition)
 {
-    return createVisiblePosition(logicalStartOfLineAlgorithm<EditingStrategy>(currentPosition.toPositionWithAffinity()));
+    return createVisiblePositionDeprecated(logicalStartOfLineAlgorithm<EditingStrategy>(currentPosition.toPositionWithAffinity()));
 }
 
 VisiblePositionInFlatTree logicalStartOfLine(const VisiblePositionInFlatTree& currentPosition)
 {
-    return createVisiblePosition(logicalStartOfLineAlgorithm<EditingInFlatTreeStrategy>(currentPosition.toPositionWithAffinity()));
+    return createVisiblePositionDeprecated(logicalStartOfLineAlgorithm<EditingInFlatTreeStrategy>(currentPosition.toPositionWithAffinity()));
 }
 
 template <typename Strategy>
 static VisiblePositionTemplate<Strategy> endPositionForLine(const VisiblePositionTemplate<Strategy>& c, LineEndpointComputationMode mode)
 {
     if (c.isNull())
         return VisiblePositionTemplate<Strategy>();
 
     RootInlineBox* rootBox = RenderedPosition(c).rootBox();
     if (!rootBox) {
@@ skipping 34 matching lines @@
     } else if (endBox->isInlineTextBox() && endNode->isTextNode()) {
         InlineTextBox* endTextBox = toInlineTextBox(endBox);
         int endOffset = endTextBox->start();
         if (!endTextBox->isLineBreak())
             endOffset += endTextBox->len();
         pos = PositionTemplate<Strategy>(toText(endNode), endOffset);
     } else {
         pos = PositionTemplate<Strategy>::afterNode(endNode);
     }
 
-    return createVisiblePosition(pos, VP_UPSTREAM_IF_POSSIBLE);
+    return createVisiblePositionDeprecated(pos, VP_UPSTREAM_IF_POSSIBLE);
 }
 
 // TODO(yosin) Rename this function to reflect the fact it ignores bidi levels.
 template <typename Strategy>
 static VisiblePositionTemplate<Strategy> endOfLineAlgorithm(const VisiblePositionTemplate<Strategy>& currentPosition)
 {
     // TODO(yosin) this is the current behavior that might need to be fixed.
     // Please refer to https://bugs.webkit.org/show_bug.cgi?id=49107 for detail.
     VisiblePositionTemplate<Strategy> visPos = endPositionForLine(currentPosition, UseInlineBoxOrdering);
 
@@ skipping 45 matching lines @@
     // next line. For example,
     // <div contenteditable dir="rtl" style="line-break:before-white-space">xyz
     // a xyz xyz xyz xyz xyz xyz xyz xyz xyz xyz </div>
     // In this case, use the previous position of the computed logical end
     // position.
     if (!inSameLogicalLine(currentPosition, visPos))
         visPos = previousPositionOf(visPos);
 
     if (ContainerNode* editableRoot = highestEditableRoot(currentPosition.deepEquivalent())) {
         if (!editableRoot->contains(visPos.deepEquivalent().computeContainerNode()))
-            return createVisiblePosition(PositionTemplate<Strategy>::lastPositionInNode(editableRoot));
+            return createVisiblePositionDeprecated(PositionTemplate<Strategy>::lastPositionInNode(editableRoot));
     }
 
     return honorEditingBoundaryAtOrAfter(visPos, currentPosition.deepEquivalent());
 }
 
 VisiblePosition logicalEndOfLine(const VisiblePosition& currentPosition)
 {
     return logicalEndOfLineAlgorithm<EditingStrategy>(currentPosition);
 }
 
@@ skipping 122 matching lines @@
         root = box->root().prevRootBox();
         // We want to skip zero height boxes.
         // This could happen in case it is a TrailingFloatsRootInlineBox.
         if (!root || !root->logicalHeight() || !root->firstLeafChild())
             root = 0;
     }
 
     if (!root) {
         Position position = previousRootInlineBoxCandidatePosition(node, visiblePosition, editableType);
         if (position.isNotNull()) {
-            RenderedPosition renderedPosition((createVisiblePosition(position)));
+            RenderedPosition renderedPosition((createVisiblePositionDeprecated(position)));
             root = renderedPosition.rootBox();
             if (!root)
-                return createVisiblePosition(position);
+                return createVisiblePositionDeprecated(position);
         }
     }
 
     if (root) {
         // FIXME: Can be wrong for multi-column layout and with transforms.
         LayoutPoint pointInLine = absoluteLineDirectionPointToLocalPointInBlock(root, lineDirectionPoint);
         LineLayoutItem lineLayoutItem = root->closestLeafChildForPoint(pointInLine, isEditablePosition(p))->getLineLayoutItem();
         Node* node = lineLayoutItem.node();
         if (node && editingIgnoresContent(node))
             return VisiblePosition::inParentBeforeNode(*node);
-        return createVisiblePosition(lineLayoutItem.positionForPoint(pointInLine));
+        return createVisiblePositionDeprecated(lineLayoutItem.positionForPoint(pointInLine));
     }
 
     // Could not find a previous line. This means we must already be on the first line.
     // Move to the start of the content in this block, which effectively moves us
     // to the start of the line we're on.
     Element* rootElement = hasEditableStyle(*node, editableType) ? rootEditableElement(*node, editableType) : node->document().documentElement();
     if (!rootElement)
         return VisiblePosition();
     return VisiblePosition::firstPositionInNode(rootElement);
 }
@@ skipping 21 matching lines @@
         if (!root || !root->logicalHeight() || !root->firstLeafChild())
             root = 0;
     }
 
     if (!root) {
         // FIXME: We need do the same in previousLinePosition.
         Node* child = NodeTraversal::childAt(*node, p.computeEditingOffset());
         node = child ? child : &NodeTraversal::lastWithinOrSelf(*node);
         Position position = nextRootInlineBoxCandidatePosition(node, visiblePosition, editableType);
         if (position.isNotNull()) {
-            RenderedPosition renderedPosition((createVisiblePosition(position)));
+            RenderedPosition renderedPosition((createVisiblePositionDeprecated(position)));
             root = renderedPosition.rootBox();
             if (!root)
-                return createVisiblePosition(position);
+                return createVisiblePositionDeprecated(position);
         }
     }
 
     if (root) {
         // FIXME: Can be wrong for multi-column layout and with transforms.
         LayoutPoint pointInLine = absoluteLineDirectionPointToLocalPointInBlock(root, lineDirectionPoint);
         LineLayoutItem lineLayoutItem = root->closestLeafChildForPoint(pointInLine, isEditablePosition(p))->getLineLayoutItem();
         Node* node = lineLayoutItem.node();
         if (node && editingIgnoresContent(node))
             return VisiblePosition::inParentBeforeNode(*node);
-        return createVisiblePosition(lineLayoutItem.positionForPoint(pointInLine));
+        return createVisiblePositionDeprecated(lineLayoutItem.positionForPoint(pointInLine));
     }
 
     // Could not find a next line. This means we must already be on the last line.
     // Move to the end of the content in this block, which effectively moves us
     // to the end of the line we're on.
     Element* rootElement = hasEditableStyle(*node, editableType) ? rootEditableElement(*node, editableType) : node->document().documentElement();
     if (!rootElement)
         return VisiblePosition();
     return VisiblePosition::lastPositionInNode(rootElement);
 }
@@ skipping 146 matching lines @@
 
     if (candidateType == PositionAnchorType::OffsetInAnchor)
         return PositionTemplate<Strategy>(candidateNode, candidateOffset);
 
     return PositionTemplate<Strategy>(candidateNode, candidateType);
 }
 
 template <typename Strategy>
 VisiblePositionTemplate<Strategy> startOfParagraphAlgorithm(const VisiblePositionTemplate<Strategy>& visiblePosition, EditingBoundaryCrossingRule boundaryCrossingRule)
 {
-    return createVisiblePosition(startOfParagraphAlgorithm(visiblePosition.deepEquivalent(), boundaryCrossingRule));
+    return createVisiblePositionDeprecated(startOfParagraphAlgorithm(visiblePosition.deepEquivalent(), boundaryCrossingRule));
 }
 
 VisiblePosition startOfParagraph(const VisiblePosition& c, EditingBoundaryCrossingRule boundaryCrossingRule)
 {
     return startOfParagraphAlgorithm<EditingStrategy>(c, boundaryCrossingRule);
 }
 
 VisiblePositionInFlatTree startOfParagraph(const VisiblePositionInFlatTree& c, EditingBoundaryCrossingRule boundaryCrossingRule)
 {
     return startOfParagraphAlgorithm<EditingInFlatTreeStrategy>(c, boundaryCrossingRule);
@@ skipping 70 matching lines @@
 
     if (candidateType == PositionAnchorType::OffsetInAnchor)
         return PositionTemplate<Strategy>(candidateNode, candidateOffset);
 
     return PositionTemplate<Strategy>(candidateNode, candidateType);
 }
 
 template <typename Strategy>
 static VisiblePositionTemplate<Strategy> endOfParagraphAlgorithm(const VisiblePositionTemplate<Strategy>& visiblePosition, EditingBoundaryCrossingRule boundaryCrossingRule)
 {
-    return createVisiblePosition(endOfParagraphAlgorithm(visiblePosition.deepEquivalent(), boundaryCrossingRule));
+    return createVisiblePositionDeprecated(endOfParagraphAlgorithm(visiblePosition.deepEquivalent(), boundaryCrossingRule));
 }
 
 VisiblePosition endOfParagraph(const VisiblePosition& c, EditingBoundaryCrossingRule boundaryCrossingRule)
 {
     return endOfParagraphAlgorithm<EditingStrategy>(c, boundaryCrossingRule);
 }
 
 VisiblePositionInFlatTree endOfParagraph(const VisiblePositionInFlatTree& c, EditingBoundaryCrossingRule boundaryCrossingRule)
 {
     return endOfParagraphAlgorithm<EditingInFlatTreeStrategy>(c, boundaryCrossingRule);
@@ skipping 105 matching lines @@
 
 // ---------
 
 template <typename Strategy>
 static VisiblePositionTemplate<Strategy> startOfDocumentAlgorithm(const VisiblePositionTemplate<Strategy>& visiblePosition)
 {
     Node* node = visiblePosition.deepEquivalent().anchorNode();
     if (!node || !node->document().documentElement())
         return VisiblePositionTemplate<Strategy>();
 
-    return createVisiblePosition(PositionTemplate<Strategy>::firstPositionInNode(node->document().documentElement()));
+    return createVisiblePositionDeprecated(PositionTemplate<Strategy>::firstPositionInNode(node->document().documentElement()));
 }
 
 VisiblePosition startOfDocument(const VisiblePosition& c)
 {
     return startOfDocumentAlgorithm<EditingStrategy>(c);
 }
 
 VisiblePositionInFlatTree startOfDocument(const VisiblePositionInFlatTree& c)
 {
     return startOfDocumentAlgorithm<EditingInFlatTreeStrategy>(c);
 }
 
 template <typename Strategy>
 static VisiblePositionTemplate<Strategy> endOfDocumentAlgorithm(const VisiblePositionTemplate<Strategy>& visiblePosition)
 {
     Node* node = visiblePosition.deepEquivalent().anchorNode();
     if (!node || !node->document().documentElement())
         return VisiblePositionTemplate<Strategy>();
 
     Element* doc = node->document().documentElement();
-    return createVisiblePosition(PositionTemplate<Strategy>::lastPositionInNode(doc));
+    return createVisiblePositionDeprecated(PositionTemplate<Strategy>::lastPositionInNode(doc));
 }
 
 VisiblePosition endOfDocument(const VisiblePosition& c)
 {
     return endOfDocumentAlgorithm<EditingStrategy>(c);
 }
 
 VisiblePositionInFlatTree endOfDocument(const VisiblePositionInFlatTree& c)
 {
     return endOfDocumentAlgorithm<EditingInFlatTreeStrategy>(c);
@@ skipping 387 matching lines @@
     return false;
 }
 
 VisiblePosition visiblePositionForContentsPoint(const IntPoint& contentsPoint, LocalFrame* frame)
 {
     HitTestRequest request = HitTestRequest::Move | HitTestRequest::ReadOnly | HitTestRequest::Active | HitTestRequest::IgnoreClipping;
     HitTestResult result(request, contentsPoint);
     frame->document()->layoutViewItem().hitTest(result);
 
     if (Node* node = result.innerNode())
-        return createVisiblePosition(positionRespectingEditingBoundary(frame->selection().selection().start(), result.localPoint(), node));
+        return createVisiblePositionDeprecated(positionRespectingEditingBoundary(frame->selection().selection().start(), result.localPoint(), node));
     return VisiblePosition();
 }
 
 // TODO(yosin): We should use |associatedLayoutObjectOf()| in "VisibleUnits.cpp"
 // where it takes |LayoutObject| from |Position|.
 // Note about ::first-letter pseudo-element:
 //   When an element has ::first-letter pseudo-element, first letter characters
 //   are taken from |Text| node and first letter characters are considered
 //   as content of <pseudo:first-letter>.
 //   For following HTML,
@@ skipping 559 matching lines @@
     ContainerNode* highestRoot = highestEditableRoot(anchor);
     ContainerNode* highestRootOfPos = highestEditableRoot(pos.deepEquivalent());
 
     // Return |pos| itself if the two are from the very same editable region,
     // or both are non-editable.
     if (highestRootOfPos == highestRoot)
         return pos;
 
     // If this is not editable but |pos| has an editable root, skip to the end
     if (!highestRoot && highestRootOfPos)
-        return createVisiblePosition(PositionTemplate<Strategy>(highestRootOfPos, PositionAnchorType::AfterAnchor).parentAnchoredEquivalent());
+        return createVisiblePositionDeprecated(PositionTemplate<Strategy>(highestRootOfPos, PositionAnchorType::AfterAnchor).parentAnchoredEquivalent());
 
     // That must mean that |pos| is not editable. Return the next position after
     // |pos| that is in the same editable region as this position
     DCHECK(highestRoot);
     return firstEditableVisiblePositionAfterPositionInRoot(pos.deepEquivalent(), *highestRoot);
 }
 
 template <typename Strategy>
 static UChar32 characterAfterAlgorithm(const VisiblePositionTemplate<Strategy>& visiblePosition)
 {
@@ skipping 194 matching lines @@
 }
 
 template <typename Strategy>
 VisiblePositionTemplate<Strategy> leftPositionOfAlgorithm(const VisiblePositionTemplate<Strategy>& visiblePosition)
 {
     const PositionTemplate<Strategy> pos = leftVisuallyDistinctCandidate(visiblePosition);
     // TODO(yosin) Why can't we move left from the last position in a tree?
     if (pos.atStartOfTree() || pos.atEndOfTree())
         return VisiblePositionTemplate<Strategy>();
 
-    const VisiblePositionTemplate<Strategy> left = createVisiblePosition(pos);
+    const VisiblePositionTemplate<Strategy> left = createVisiblePositionDeprecated(pos);
     DCHECK_NE(left.deepEquivalent(), visiblePosition.deepEquivalent());
 
     return directionOfEnclosingBlock(left.deepEquivalent()) == LTR ? honorEditingBoundaryAtOrBefore(left, visiblePosition.deepEquivalent()) : honorEditingBoundaryAtOrAfter(left, visiblePosition.deepEquivalent());
 }
 
 VisiblePosition leftPositionOf(const VisiblePosition& visiblePosition)
 {
     return leftPositionOfAlgorithm<EditingStrategy>(visiblePosition);
 }
 
@@ skipping 157 matching lines @@
 }
 
 template <typename Strategy>
 static VisiblePositionTemplate<Strategy> rightPositionOfAlgorithm(const VisiblePositionTemplate<Strategy>& visiblePosition)
 {
     const PositionTemplate<Strategy> pos = rightVisuallyDistinctCandidate(visiblePosition);
     // FIXME: Why can't we move left from the last position in a tree?
     if (pos.atStartOfTree() || pos.atEndOfTree())
         return VisiblePositionTemplate<Strategy>();
 
-    const VisiblePositionTemplate<Strategy> right = createVisiblePosition(pos);
+    const VisiblePositionTemplate<Strategy> right = createVisiblePositionDeprecated(pos);
     DCHECK_NE(right.deepEquivalent(), visiblePosition.deepEquivalent());
 
     return directionOfEnclosingBlock(right.deepEquivalent()) == LTR ? honorEditingBoundaryAtOrAfter(right, visiblePosition.deepEquivalent()) : honorEditingBoundaryAtOrBefore(right, visiblePosition.deepEquivalent());
 }
 
 VisiblePosition rightPositionOf(const VisiblePosition& visiblePosition)
 {
     return rightPositionOfAlgorithm<EditingStrategy>(visiblePosition);
 }
 
 VisiblePositionInFlatTree rightPositionOf(const VisiblePositionInFlatTree& visiblePosition)
 {
     return rightPositionOfAlgorithm<EditingInFlatTreeStrategy>(visiblePosition);
 }
 
 template <typename Strategy>
 static VisiblePositionTemplate<Strategy> nextPositionOfAlgorithm(const VisiblePositionTemplate<Strategy>& visiblePosition, EditingBoundaryCrossingRule rule)
 {
-    const VisiblePositionTemplate<Strategy> next = createVisiblePosition(nextVisuallyDistinctCandidate(visiblePosition.deepEquivalent()), visiblePosition.affinity());
+    const VisiblePositionTemplate<Strategy> next = createVisiblePositionDeprecated(nextVisuallyDistinctCandidate(visiblePosition.deepEquivalent()), visiblePosition.affinity());
 
     switch (rule) {
     case CanCrossEditingBoundary:
         return next;
     case CannotCrossEditingBoundary:
         return honorEditingBoundaryAtOrAfter(next, visiblePosition.deepEquivalent());
     case CanSkipOverEditingBoundary:
         return skipToEndOfEditingBoundary(next, visiblePosition.deepEquivalent());
     }
     NOTREACHED();
@@ skipping 19 matching lines @@
     ContainerNode* highestRoot = highestEditableRoot(anchor);
     ContainerNode* highestRootOfPos = highestEditableRoot(pos.deepEquivalent());
 
     // Return |pos| itself if the two are from the very same editable region, or
     // both are non-editable.
     if (highestRootOfPos == highestRoot)
         return pos;
 
     // If this is not editable but |pos| has an editable root, skip to the start
     if (!highestRoot && highestRootOfPos)
-        return createVisiblePosition(previousVisuallyDistinctCandidate(PositionTemplate<Strategy>(highestRootOfPos, PositionAnchorType::BeforeAnchor).parentAnchoredEquivalent()));
+        return createVisiblePositionDeprecated(previousVisuallyDistinctCandidate(PositionTemplate<Strategy>(highestRootOfPos, PositionAnchorType::BeforeAnchor).parentAnchoredEquivalent()));
 
     // That must mean that |pos| is not editable. Return the last position
     // before |pos| that is in the same editable region as this position
     DCHECK(highestRoot);
     return lastEditableVisiblePositionBeforePositionInRoot(pos.deepEquivalent(), *highestRoot);
 }
 
 template <typename Strategy>
 static VisiblePositionTemplate<Strategy> previousPositionOfAlgorithm(const VisiblePositionTemplate<Strategy>& visiblePosition, EditingBoundaryCrossingRule rule)
 {
     const PositionTemplate<Strategy> pos = previousVisuallyDistinctCandidate(visiblePosition.deepEquivalent());
 
     // return null visible position if there is no previous visible position
     if (pos.atStartOfTree())
         return VisiblePositionTemplate<Strategy>();
 
     // we should always be able to make the affinity |TextAffinity::Downstream|,
     // because going previous from an |TextAffinity::Upstream| position can
     // never yield another |TextAffinity::Upstream position| (unless line wrap
     // length is 0!).
-    const VisiblePositionTemplate<Strategy> prev = createVisiblePosition(pos);
+    const VisiblePositionTemplate<Strategy> prev = createVisiblePositionDeprecated(pos);
     if (prev.deepEquivalent() == visiblePosition.deepEquivalent())
         return VisiblePositionTemplate<Strategy>();
 
     switch (rule) {
     case CanCrossEditingBoundary:
         return prev;
     case CannotCrossEditingBoundary:
         return honorEditingBoundaryAtOrBefore(prev, visiblePosition.deepEquivalent());
     case CanSkipOverEditingBoundary:
         return skipToStartOfEditingBoundary(prev, visiblePosition.deepEquivalent());
     }
 
     NOTREACHED();
     return honorEditingBoundaryAtOrBefore(prev, visiblePosition.deepEquivalent());
 }
 
 VisiblePosition previousPositionOf(const VisiblePosition& visiblePosition, EditingBoundaryCrossingRule rule)
 {
     return previousPositionOfAlgorithm<EditingStrategy>(visiblePosition, rule);
 }
 
 VisiblePositionInFlatTree previousPositionOf(const VisiblePositionInFlatTree& visiblePosition, EditingBoundaryCrossingRule rule)
 {
     return previousPositionOfAlgorithm<EditingInFlatTreeStrategy>(visiblePosition, rule);
 }
 
 } // namespace blink