Mark the createVisiblePosition overloads as deprecated

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

Index: third_party/WebKit/Source/core/editing/VisibleUnits.cpp
diff --git a/third_party/WebKit/Source/core/editing/VisibleUnits.cpp b/third_party/WebKit/Source/core/editing/VisibleUnits.cpp
index d1a09bf8e121ff27ee436be9dfe43d09826ae7d9..82793d96e4a0882f90b110ddf06670b2988b1193 100644
--- a/third_party/WebKit/Source/core/editing/VisibleUnits.cpp
+++ b/third_party/WebKit/Source/core/editing/VisibleUnits.cpp
@@ -201,7 +201,7 @@ static PositionWithAffinityTemplate<Strategy> honorEditingBoundaryAtOrBefore(con
 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>
@@ -316,7 +316,7 @@ static Position previousRootInlineBoxCandidatePosition(Node* node, const Visible
     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()) {
@@ -338,7 +338,7 @@ static Position nextRootInlineBoxCandidatePosition(Node* node, const VisiblePosi
 {
     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()) {
@@ -771,13 +771,13 @@ static VisiblePositionTemplate<Strategy> previousBoundary(const VisiblePositionT
     }
 
     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
@@ -785,7 +785,7 @@ static VisiblePositionTemplate<Strategy> previousBoundary(const VisiblePositionT
     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>
@@ -873,8 +873,8 @@ static VisiblePositionTemplate<Strategy> nextBoundary(const VisiblePositionTempl
             // 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();
             }
@@ -882,7 +882,7 @@ static VisiblePositionTemplate<Strategy> nextBoundary(const VisiblePositionTempl
     }
 
     // generate VisiblePosition, use TextAffinity::Upstream affinity if possible
-    return createVisiblePosition(pos, VP_UPSTREAM_IF_POSSIBLE);
+    return createVisiblePositionDeprecated(pos, VP_UPSTREAM_IF_POSSIBLE);
 }
 
 // ---------
@@ -1068,12 +1068,12 @@ static PositionInFlatTreeWithAffinity startOfLine(const PositionInFlatTreeWithAf
 // 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>
@@ -1093,12 +1093,12 @@ static PositionWithAffinityTemplate<Strategy> logicalStartOfLineAlgorithm(const
 
 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>
@@ -1153,7 +1153,7 @@ static VisiblePositionTemplate<Strategy> endPositionForLine(const VisiblePositio
         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.
@@ -1219,7 +1219,7 @@ VisiblePositionTemplate<Strategy> logicalEndOfLineAlgorithm(const VisiblePositio
 
     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());
@@ -1362,10 +1362,10 @@ VisiblePosition previousLinePosition(const VisiblePosition& visiblePosition, Lay
     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);
         }
     }
 
@@ -1376,7 +1376,7 @@ VisiblePosition previousLinePosition(const VisiblePosition& visiblePosition, Lay
         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.
@@ -1418,10 +1418,10 @@ VisiblePosition nextLinePosition(const VisiblePosition& visiblePosition, LayoutU
         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);
         }
     }
 
@@ -1432,7 +1432,7 @@ VisiblePosition nextLinePosition(const VisiblePosition& visiblePosition, LayoutU
         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.
@@ -1599,7 +1599,7 @@ PositionTemplate<Strategy> startOfParagraphAlgorithm(const PositionTemplate<Stra
 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)
@@ -1690,7 +1690,7 @@ static PositionTemplate<Strategy> endOfParagraphAlgorithm(const PositionTemplate
 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)
@@ -1816,7 +1816,7 @@ static VisiblePositionTemplate<Strategy> startOfDocumentAlgorithm(const VisibleP
     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)
@@ -1837,7 +1837,7 @@ static VisiblePositionTemplate<Strategy> endOfDocumentAlgorithm(const VisiblePos
         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)
@@ -2245,7 +2245,7 @@ VisiblePosition visiblePositionForContentsPoint(const IntPoint& contentsPoint, L
     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();
 }
 
@@ -2825,7 +2825,7 @@ static VisiblePositionTemplate<Strategy> skipToEndOfEditingBoundary(const Visibl
 
     // 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
@@ -3040,7 +3040,7 @@ VisiblePositionTemplate<Strategy> leftPositionOfAlgorithm(const VisiblePositionT
     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());
@@ -3218,7 +3218,7 @@ static VisiblePositionTemplate<Strategy> rightPositionOfAlgorithm(const VisibleP
     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());
@@ -3237,7 +3237,7 @@ VisiblePositionInFlatTree rightPositionOf(const VisiblePositionInFlatTree& visib
 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:
@@ -3277,7 +3277,7 @@ static VisiblePositionTemplate<Strategy> skipToStartOfEditingBoundary(const Visi
 
     // 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
@@ -3298,7 +3298,7 @@ static VisiblePositionTemplate<Strategy> previousPositionOfAlgorithm(const Visib
     // 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>();