Mark the createVisiblePosition overloads as deprecated

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

 /*
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010 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 158 matching lines @@
         bool movingBackwardsMovedPositionToStartOfCurrentWord = positionAfterCurrentWord.deepEquivalent() == previousWordPosition(nextWordPosition(originalPosition)).deepEquivalent();
         if (movingBackwardsMovedPositionToStartOfCurrentWord)
             positionAfterCurrentWord = positionAfterSpacingAndFollowingWord;
     }
     return positionAfterCurrentWord;
 }
 
 static void adjustPositionForUserSelectAll(VisiblePosition& pos, bool isForward)
 {
     if (Node* rootUserSelectAll = EditingStrategy::rootUserSelectAllForNode(pos.deepEquivalent().anchorNode()))
-        pos = createVisiblePosition(isForward ? mostForwardCaretPosition(Position::afterNode(rootUserSelectAll), CanCrossEditingBoundary) : mostBackwardCaretPosition(Position::beforeNode(rootUserSelectAll), CanCrossEditingBoundary));
+        pos = createVisiblePositionDeprecated(isForward ? mostForwardCaretPosition(Position::afterNode(rootUserSelectAll), CanCrossEditingBoundary) : mostBackwardCaretPosition(Position::beforeNode(rootUserSelectAll), CanCrossEditingBoundary));
 }
 
 VisiblePosition SelectionModifier::modifyExtendingRight(TextGranularity granularity)
 {
-    VisiblePosition pos = createVisiblePosition(m_selection.extent(), m_selection.affinity());
+    VisiblePosition pos = createVisiblePositionDeprecated(m_selection.extent(), m_selection.affinity());
 
     // The difference between modifyExtendingRight and modifyExtendingForward is:
     // modifyExtendingForward always extends forward logically.
     // modifyExtendingRight behaves the same as modifyExtendingForward except for extending character or word,
     // it extends forward logically if the enclosing block is LTR direction,
     // but it extends backward logically if the enclosing block is RTL direction.
     switch (granularity) {
     case CharacterGranularity:
         if (directionOfEnclosingBlock() == LTR)
             pos = nextPositionOf(pos, CanSkipOverEditingBoundary);
@@ skipping 21 matching lines @@
         // FIXME: implement all of the above?
         pos = modifyExtendingForward(granularity);
         break;
     }
     adjustPositionForUserSelectAll(pos, directionOfEnclosingBlock() == LTR);
     return pos;
 }
 
 VisiblePosition SelectionModifier::modifyExtendingForward(TextGranularity granularity)
 {
-    VisiblePosition pos = createVisiblePosition(m_selection.extent(), m_selection.affinity());
+    VisiblePosition pos = createVisiblePositionDeprecated(m_selection.extent(), m_selection.affinity());
     switch (granularity) {
     case CharacterGranularity:
         pos = nextPositionOf(pos, CanSkipOverEditingBoundary);
         break;
     case WordGranularity:
         pos = nextWordPositionForPlatform(pos);
         break;
     case SentenceGranularity:
         pos = nextSentencePosition(pos);
         break;
@@ skipping 24 matching lines @@
     return pos;
 }
 
 VisiblePosition SelectionModifier::modifyMovingRight(TextGranularity granularity)
 {
     VisiblePosition pos;
     switch (granularity) {
     case CharacterGranularity:
         if (m_selection.isRange()) {
             if (directionOfSelection() == LTR)
-                pos = createVisiblePosition(m_selection.end(), m_selection.affinity());
+                pos = createVisiblePositionDeprecated(m_selection.end(), m_selection.affinity());
             else
-                pos = createVisiblePosition(m_selection.start(), m_selection.affinity());
+                pos = createVisiblePositionDeprecated(m_selection.start(), m_selection.affinity());
         } else {
-            pos = rightPositionOf(createVisiblePosition(m_selection.extent(), m_selection.affinity()));
+            pos = rightPositionOf(createVisiblePositionDeprecated(m_selection.extent(), m_selection.affinity()));
         }
         break;
     case WordGranularity: {
         bool skipsSpaceWhenMovingRight = frame() && frame()->editor().behavior().shouldSkipSpaceWhenMovingRight();
-        pos = rightWordPosition(createVisiblePosition(m_selection.extent(), m_selection.affinity()), skipsSpaceWhenMovingRight);
+        pos = rightWordPosition(createVisiblePositionDeprecated(m_selection.extent(), m_selection.affinity()), skipsSpaceWhenMovingRight);
         break;
     }
     case SentenceGranularity:
     case LineGranularity:
     case ParagraphGranularity:
     case SentenceBoundary:
     case ParagraphBoundary:
     case DocumentBoundary:
         // FIXME: Implement all of the above.
         pos = modifyMovingForward(granularity);
         break;
     case LineBoundary:
         pos = rightBoundaryOfLine(startForPlatform(), directionOfEnclosingBlock());
         break;
     }
     return pos;
 }
 
 VisiblePosition SelectionModifier::modifyMovingForward(TextGranularity granularity)
 {
     VisiblePosition pos;
     // FIXME: Stay in editable content for the less common granularities.
     switch (granularity) {
     case CharacterGranularity:
         if (m_selection.isRange())
-            pos = createVisiblePosition(m_selection.end(), m_selection.affinity());
+            pos = createVisiblePositionDeprecated(m_selection.end(), m_selection.affinity());
         else
-            pos = nextPositionOf(createVisiblePosition(m_selection.extent(), m_selection.affinity()), CanSkipOverEditingBoundary);
+            pos = nextPositionOf(createVisiblePositionDeprecated(m_selection.extent(), m_selection.affinity()), CanSkipOverEditingBoundary);
         break;
     case WordGranularity:
-        pos = nextWordPositionForPlatform(createVisiblePosition(m_selection.extent(), m_selection.affinity()));
+        pos = nextWordPositionForPlatform(createVisiblePositionDeprecated(m_selection.extent(), m_selection.affinity()));
         break;
     case SentenceGranularity:
-        pos = nextSentencePosition(createVisiblePosition(m_selection.extent(), m_selection.affinity()));
+        pos = nextSentencePosition(createVisiblePositionDeprecated(m_selection.extent(), m_selection.affinity()));
         break;
     case LineGranularity: {
         // down-arrowing from a range selection that ends at the start of a line needs
         // to leave the selection at that line start (no need to call nextLinePosition!)
         pos = endForPlatform();
         if (!m_selection.isRange() || !isStartOfLine(pos))
             pos = nextLinePosition(pos, lineDirectionPointForBlockDirectionNavigation(START));
         break;
     }
     case ParagraphGranularity:
@@ skipping 14 matching lines @@
             pos = endOfEditableContent(pos);
         else
             pos = endOfDocument(pos);
         break;
     }
     return pos;
 }
 
 VisiblePosition SelectionModifier::modifyExtendingLeft(TextGranularity granularity)
 {
-    VisiblePosition pos = createVisiblePosition(m_selection.extent(), m_selection.affinity());
+    VisiblePosition pos = createVisiblePositionDeprecated(m_selection.extent(), m_selection.affinity());
 
     // The difference between modifyExtendingLeft and modifyExtendingBackward is:
     // modifyExtendingBackward always extends backward logically.
     // modifyExtendingLeft behaves the same as modifyExtendingBackward except for extending character or word,
     // it extends backward logically if the enclosing block is LTR direction,
     // but it extends forward logically if the enclosing block is RTL direction.
     switch (granularity) {
     case CharacterGranularity:
         if (directionOfEnclosingBlock() == LTR)
             pos = previousPositionOf(pos, CanSkipOverEditingBoundary);
@@ skipping 20 matching lines @@
     case DocumentBoundary:
         pos = modifyExtendingBackward(granularity);
         break;
     }
     adjustPositionForUserSelectAll(pos, !(directionOfEnclosingBlock() == LTR));
     return pos;
 }
 
 VisiblePosition SelectionModifier::modifyExtendingBackward(TextGranularity granularity)
 {
-    VisiblePosition pos = createVisiblePosition(m_selection.extent(), m_selection.affinity());
+    VisiblePosition pos = createVisiblePositionDeprecated(m_selection.extent(), m_selection.affinity());
 
     // Extending a selection backward by word or character from just after a table selects
     // the table.  This "makes sense" from the user perspective, esp. when deleting.
     // It was done here instead of in VisiblePosition because we want VPs to iterate
     // over everything.
     switch (granularity) {
     case CharacterGranularity:
         pos = previousPositionOf(pos, CanSkipOverEditingBoundary);
         break;
     case WordGranularity:
@@ skipping 29 matching lines @@
     return pos;
 }
 
 VisiblePosition SelectionModifier::modifyMovingLeft(TextGranularity granularity)
 {
     VisiblePosition pos;
     switch (granularity) {
     case CharacterGranularity:
         if (m_selection.isRange()) {
             if (directionOfSelection() == LTR)
-                pos = createVisiblePosition(m_selection.start(), m_selection.affinity());
+                pos = createVisiblePositionDeprecated(m_selection.start(), m_selection.affinity());
             else
-                pos = createVisiblePosition(m_selection.end(), m_selection.affinity());
+                pos = createVisiblePositionDeprecated(m_selection.end(), m_selection.affinity());
         } else {
-            pos = leftPositionOf(createVisiblePosition(m_selection.extent(), m_selection.affinity()));
+            pos = leftPositionOf(createVisiblePositionDeprecated(m_selection.extent(), m_selection.affinity()));
         }
         break;
     case WordGranularity: {
         bool skipsSpaceWhenMovingRight = frame() && frame()->editor().behavior().shouldSkipSpaceWhenMovingRight();
-        pos = leftWordPosition(createVisiblePosition(m_selection.extent(), m_selection.affinity()), skipsSpaceWhenMovingRight);
+        pos = leftWordPosition(createVisiblePositionDeprecated(m_selection.extent(), m_selection.affinity()), skipsSpaceWhenMovingRight);
         break;
     }
     case SentenceGranularity:
     case LineGranularity:
     case ParagraphGranularity:
     case SentenceBoundary:
     case ParagraphBoundary:
     case DocumentBoundary:
         // FIXME: Implement all of the above.
         pos = modifyMovingBackward(granularity);
         break;
     case LineBoundary:
         pos = leftBoundaryOfLine(startForPlatform(), directionOfEnclosingBlock());
         break;
     }
     return pos;
 }
 
 VisiblePosition SelectionModifier::modifyMovingBackward(TextGranularity granularity)
 {
     VisiblePosition pos;
     switch (granularity) {
     case CharacterGranularity:
         if (m_selection.isRange())
-            pos = createVisiblePosition(m_selection.start(), m_selection.affinity());
+            pos = createVisiblePositionDeprecated(m_selection.start(), m_selection.affinity());
         else
-            pos = previousPositionOf(createVisiblePosition(m_selection.extent(), m_selection.affinity()), CanSkipOverEditingBoundary);
+            pos = previousPositionOf(createVisiblePositionDeprecated(m_selection.extent(), m_selection.affinity()), CanSkipOverEditingBoundary);
         break;
     case WordGranularity:
-        pos = previousWordPosition(createVisiblePosition(m_selection.extent(), m_selection.affinity()));
+        pos = previousWordPosition(createVisiblePositionDeprecated(m_selection.extent(), m_selection.affinity()));
         break;
     case SentenceGranularity:
-        pos = previousSentencePosition(createVisiblePosition(m_selection.extent(), m_selection.affinity()));
+        pos = previousSentencePosition(createVisiblePositionDeprecated(m_selection.extent(), m_selection.affinity()));
         break;
     case LineGranularity:
         pos = previousLinePosition(startForPlatform(), lineDirectionPointForBlockDirectionNavigation(START));
         break;
     case ParagraphGranularity:
         pos = previousParagraphPosition(startForPlatform(), lineDirectionPointForBlockDirectionNavigation(START));
         break;
     case SentenceBoundary:
         pos = startOfSentence(startForPlatform());
         break;
@@ skipping 142 matching lines @@
 {
     if (!verticalDistance)
         return false;
 
     willBeModified(alter, direction == FrameSelection::DirectionUp ? DirectionBackward : DirectionForward);
 
     VisiblePosition pos;
     LayoutUnit xPos;
     switch (alter) {
     case FrameSelection::AlterationMove:
-        pos = createVisiblePosition(direction == FrameSelection::DirectionUp ? m_selection.start() : m_selection.end(), m_selection.affinity());
+        pos = createVisiblePositionDeprecated(direction == FrameSelection::DirectionUp ? m_selection.start() : m_selection.end(), m_selection.affinity());
         xPos = lineDirectionPointForBlockDirectionNavigation(direction == FrameSelection::DirectionUp ? START : END);
         m_selection.setAffinity(direction == FrameSelection::DirectionUp ? TextAffinity::Upstream : TextAffinity::Downstream);
         break;
     case FrameSelection::AlterationExtend:
-        pos = createVisiblePosition(m_selection.extent(), m_selection.affinity());
+        pos = createVisiblePositionDeprecated(m_selection.extent(), m_selection.affinity());
         xPos = lineDirectionPointForBlockDirectionNavigation(EXTENT);
         m_selection.setAffinity(TextAffinity::Downstream);
         break;
     }
 
     int startY;
     if (!absoluteCaretY(pos, startY))
         return false;
     if (direction == FrameSelection::DirectionUp)
         startY = -startY;
@@ skipping 82 matching lines @@
     case EXTENT:
         pos = m_selection.extent();
         break;
     }
 
     LocalFrame* frame = pos.document()->frame();
     if (!frame)
         return x;
 
     if (m_xPosForVerticalArrowNavigation == NoXPosForVerticalArrowNavigation()) {
-        VisiblePosition visiblePosition = createVisiblePosition(pos, m_selection.affinity());
+        VisiblePosition visiblePosition = createVisiblePositionDeprecated(pos, m_selection.affinity());
         // VisiblePosition creation can fail here if a node containing the selection becomes visibility:hidden
         // after the selection is created and before this function is called.
         x = lineDirectionPointForBlockDirectionNavigationOf(visiblePosition);
         m_xPosForVerticalArrowNavigation = x;
     } else {
         x = m_xPosForVerticalArrowNavigation;
     }
 
     return x;
 }
 
 DEFINE_TRACE(SelectionModifier)
 {
     visitor->trace(m_frame);
     visitor->trace(m_selection);
 }
 
 } // namespace blink