Mark the createVisiblePosition overloads as deprecated

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

 /*
  * Copyright (C) 2004, 2005, 2006 Apple Computer, 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 266 matching lines @@
         return;
     m_hasTrailingWhitespace = true;
 }
 
 template <typename Strategy>
 void VisibleSelectionTemplate<Strategy>::setBaseAndExtentToDeepEquivalents()
 {
     // Move the selection to rendered positions, if possible.
     bool baseAndExtentEqual = m_base == m_extent;
     if (m_base.isNotNull()) {
-        m_base = createVisiblePosition(m_base, m_affinity).deepEquivalent();
+        m_base = createVisiblePositionDeprecated(m_base, m_affinity).deepEquivalent();
         if (baseAndExtentEqual)
             m_extent = m_base;
     }
     if (m_extent.isNotNull() && !baseAndExtentEqual)
-        m_extent = createVisiblePosition(m_extent, m_affinity).deepEquivalent();
+        m_extent = createVisiblePositionDeprecated(m_extent, m_affinity).deepEquivalent();
 
     // Make sure we do not have a dangling base or extent.
     if (m_base.isNull() && m_extent.isNull()) {
         m_baseIsFirst = true;
     } else if (m_base.isNull()) {
         m_base = m_extent;
         m_baseIsFirst = true;
     } else if (m_extent.isNull()) {
         m_extent = m_base;
         m_baseIsFirst = true;
@@ skipping 14 matching lines @@
     case CharacterGranularity:
         // Don't do any expansion.
         break;
     case WordGranularity: {
         // General case: Select the word the caret is positioned inside of.
         // If the caret is on the word boundary, select the word according to |wordSide|.
         // Edge case: If the caret is after the last word in a soft-wrapped line or the last word in
         // the document, select that last word (LeftWordIfOnBoundary).
         // Edge case: If the caret is after the last word in a paragraph, select from the the end of the
         // last word to the line break (also RightWordIfOnBoundary);
-        const VisiblePositionTemplate<Strategy> visibleStart = createVisiblePosition(m_start, m_affinity);
+        const VisiblePositionTemplate<Strategy> visibleStart = createVisiblePositionDeprecated(m_start, m_affinity);
         EWordSide side = RightWordIfOnBoundary;
         if (isEndOfEditableOrNonEditableContent(visibleStart) || (isEndOfLine(visibleStart) && !isStartOfLine(visibleStart) && !isEndOfParagraph(visibleStart)))
             side = LeftWordIfOnBoundary;
         m_start = startOfWord(visibleStart, side).deepEquivalent();
         break;
     }
     case SentenceGranularity: {
-        m_start = startOfSentence(createVisiblePosition(m_start, m_affinity)).deepEquivalent();
+        m_start = startOfSentence(createVisiblePositionDeprecated(m_start, m_affinity)).deepEquivalent();
         break;
     }
     case LineGranularity: {
-        m_start = startOfLine(createVisiblePosition(m_start, m_affinity)).deepEquivalent();
+        m_start = startOfLine(createVisiblePositionDeprecated(m_start, m_affinity)).deepEquivalent();
         break;
     }
     case LineBoundary:
-        m_start = startOfLine(createVisiblePosition(m_start, m_affinity)).deepEquivalent();
+        m_start = startOfLine(createVisiblePositionDeprecated(m_start, m_affinity)).deepEquivalent();
         break;
     case ParagraphGranularity: {
-        VisiblePositionTemplate<Strategy> pos = createVisiblePosition(m_start, m_affinity);
+        VisiblePositionTemplate<Strategy> pos = createVisiblePositionDeprecated(m_start, m_affinity);
         if (isStartOfLine(pos) && isEndOfEditableOrNonEditableContent(pos))
             pos = previousPositionOf(pos);
         m_start = startOfParagraph(pos).deepEquivalent();
         break;
     }
     case DocumentBoundary:
-        m_start = startOfDocument(createVisiblePosition(m_start, m_affinity)).deepEquivalent();
+        m_start = startOfDocument(createVisiblePositionDeprecated(m_start, m_affinity)).deepEquivalent();
         break;
     case ParagraphBoundary:
-        m_start = startOfParagraph(createVisiblePosition(m_start, m_affinity)).deepEquivalent();
+        m_start = startOfParagraph(createVisiblePositionDeprecated(m_start, m_affinity)).deepEquivalent();
         break;
     case SentenceBoundary:
-        m_start = startOfSentence(createVisiblePosition(m_start, m_affinity)).deepEquivalent();
+        m_start = startOfSentence(createVisiblePositionDeprecated(m_start, m_affinity)).deepEquivalent();
         break;
     }
 
     // Make sure we do not have a Null position.
     if (m_start.isNull())
         m_start = m_baseIsFirst ? m_base : m_extent;
 }
 
 template <typename Strategy>
 void VisibleSelectionTemplate<Strategy>::setEndRespectingGranularity(TextGranularity granularity)
@@ skipping 10 matching lines @@
     case WordGranularity: {
         // General case: Select the word the caret is positioned inside of.
         // If the caret is on the word boundary, select the word according to
         // |wordSide|.
         // Edge case: If the caret is after the last word in a soft-wrapped line
         // or the last word in the document, select that last word
         // (|LeftWordIfOnBoundary|).
         // Edge case: If the caret is after the last word in a paragraph, select
         // from the the end of the last word to the line break (also
         // |RightWordIfOnBoundary|);
-        const VisiblePositionTemplate<Strategy> originalEnd = createVisiblePosition(m_end, m_affinity);
+        const VisiblePositionTemplate<Strategy> originalEnd = createVisiblePositionDeprecated(m_end, m_affinity);
         EWordSide side = RightWordIfOnBoundary;
         if (isEndOfEditableOrNonEditableContent(originalEnd) || (isEndOfLine(originalEnd) && !isStartOfLine(originalEnd) && !isEndOfParagraph(originalEnd)))
             side = LeftWordIfOnBoundary;
 
         const VisiblePositionTemplate<Strategy> wordEnd = endOfWord(originalEnd, side);
         VisiblePositionTemplate<Strategy> end = wordEnd;
 
         if (isEndOfParagraph(originalEnd) && !isEmptyTableCell(m_start.anchorNode())) {
             // Select the paragraph break (the space from the end of a paragraph
             // to the start of the next one) to match TextEdit.
@@ skipping 11 matching lines @@
 
             if (end.isNull())
                 end = wordEnd;
 
         }
 
         m_end = end.deepEquivalent();
         break;
     }
     case SentenceGranularity: {
-        m_end = endOfSentence(createVisiblePosition(m_end, m_affinity)).deepEquivalent();
+        m_end = endOfSentence(createVisiblePositionDeprecated(m_end, m_affinity)).deepEquivalent();
         break;
     }
     case LineGranularity: {
-        VisiblePositionTemplate<Strategy> end = endOfLine(createVisiblePosition(m_end, m_affinity));
+        VisiblePositionTemplate<Strategy> end = endOfLine(createVisiblePositionDeprecated(m_end, m_affinity));
         // If the end of this line is at the end of a paragraph, include the
         // space after the end of the line in the selection.
         if (isEndOfParagraph(end)) {
             VisiblePositionTemplate<Strategy> next = nextPositionOf(end);
             if (next.isNotNull())
                 end = next;
         }
         m_end = end.deepEquivalent();
         break;
     }
     case LineBoundary:
-        m_end = endOfLine(createVisiblePosition(m_end, m_affinity)).deepEquivalent();
+        m_end = endOfLine(createVisiblePositionDeprecated(m_end, m_affinity)).deepEquivalent();
         break;
     case ParagraphGranularity: {
-        const VisiblePositionTemplate<Strategy> visibleParagraphEnd = endOfParagraph(createVisiblePosition(m_end, m_affinity));
+        const VisiblePositionTemplate<Strategy> visibleParagraphEnd = endOfParagraph(createVisiblePositionDeprecated(m_end, m_affinity));
 
         // Include the "paragraph break" (the space from the end of this
         // paragraph to the start of the next one) in the selection.
         VisiblePositionTemplate<Strategy> end = nextPositionOf(visibleParagraphEnd);
 
         if (Element* table = tableElementJustBefore(end)) {
             // The paragraph break after the last paragraph in the last cell of
             // a block table ends at the start of the paragraph after the table,
             // not at the position just after the table.
             if (isEnclosingBlock(table)) {
                 end = nextPositionOf(end, CannotCrossEditingBoundary);
             } else {
                 // There is no parargraph break after the last paragraph in the
                 // last cell of an inline table.
                 end = visibleParagraphEnd;
             }
         }
 
         if (end.isNull())
             end = visibleParagraphEnd;
 
         m_end = end.deepEquivalent();
         break;
     }
     case DocumentBoundary:
-        m_end = endOfDocument(createVisiblePosition(m_end, m_affinity)).deepEquivalent();
+        m_end = endOfDocument(createVisiblePositionDeprecated(m_end, m_affinity)).deepEquivalent();
         break;
     case ParagraphBoundary:
-        m_end = endOfParagraph(createVisiblePosition(m_end, m_affinity)).deepEquivalent();
+        m_end = endOfParagraph(createVisiblePositionDeprecated(m_end, m_affinity)).deepEquivalent();
         break;
     case SentenceBoundary:
-        m_end = endOfSentence(createVisiblePosition(m_end, m_affinity)).deepEquivalent();
+        m_end = endOfSentence(createVisiblePositionDeprecated(m_end, m_affinity)).deepEquivalent();
         break;
     }
 
     // Make sure we do not have a Null position.
     if (m_end.isNull())
         m_end = m_baseIsFirst ? m_extent : m_base;
 }
 
 template <typename Strategy>
 void VisibleSelectionTemplate<Strategy>::updateSelectionType()
@@ skipping 161 matching lines @@
             Element* shadowAncestor = endRoot ? endRoot->ownerShadowHost() : nullptr;
             if (p.isNull() && shadowAncestor)
                 p = PositionTemplate<Strategy>::afterNode(shadowAncestor);
             while (p.isNotNull() && !(lowestEditableAncestor(p.computeContainerNode()) == baseEditableAncestor && !isEditablePosition(p))) {
                 Element* root = rootEditableElementOf(p);
                 shadowAncestor = root ? root->ownerShadowHost() : nullptr;
                 p = isAtomicNode(p.computeContainerNode()) ? PositionTemplate<Strategy>::inParentBeforeNode(*p.computeContainerNode()) : previousVisuallyDistinctCandidate(p);
                 if (p.isNull() && shadowAncestor)
                     p = PositionTemplate<Strategy>::afterNode(shadowAncestor);
             }
-            const VisiblePositionTemplate<Strategy> previous = createVisiblePosition(p);
+            const VisiblePositionTemplate<Strategy> previous = createVisiblePositionDeprecated(p);
 
             if (previous.isNull()) {
                 // The selection crosses an Editing boundary.  This is a
                 // programmer error in the editing code.  Happy debugging!
                 NOTREACHED();
                 m_base = PositionTemplate<Strategy>();
                 m_extent = PositionTemplate<Strategy>();
                 validate();
                 return;
             }
             m_end = previous.deepEquivalent();
         }
 
         // The selection starts in editable content or non-editable content inside a different editable ancestor,
         // move forward until non-editable content inside the same lowest editable ancestor is reached.
         Element* startEditableAncestor = lowestEditableAncestor(m_start.computeContainerNode());
         if (startRoot || startEditableAncestor != baseEditableAncestor) {
             PositionTemplate<Strategy> p = nextVisuallyDistinctCandidate(m_start);
             Element* shadowAncestor = startRoot ? startRoot->ownerShadowHost() : nullptr;
             if (p.isNull() && shadowAncestor)
                 p = PositionTemplate<Strategy>::beforeNode(shadowAncestor);
             while (p.isNotNull() && !(lowestEditableAncestor(p.computeContainerNode()) == baseEditableAncestor && !isEditablePosition(p))) {
                 Element* root = rootEditableElementOf(p);
                 shadowAncestor = root ? root->ownerShadowHost() : nullptr;
                 p = isAtomicNode(p.computeContainerNode()) ? PositionTemplate<Strategy>::inParentAfterNode(*p.computeContainerNode()) : nextVisuallyDistinctCandidate(p);
                 if (p.isNull() && shadowAncestor)
                     p = PositionTemplate<Strategy>::beforeNode(shadowAncestor);
             }
-            const VisiblePositionTemplate<Strategy> next = createVisiblePosition(p);
+            const VisiblePositionTemplate<Strategy> next = createVisiblePositionDeprecated(p);
 
             if (next.isNull()) {
                 // The selection crosses an Editing boundary.  This is a
                 // programmer error in the editing code.  Happy debugging!
                 NOTREACHED();
                 m_base = PositionTemplate<Strategy>();
                 m_extent = PositionTemplate<Strategy>();
                 validate();
                 return;
             }
@@ skipping 147 matching lines @@
 {
     sel.showTreeForThis();
 }
 
 void showTree(const blink::VisibleSelectionInFlatTree* sel)
 {
     if (sel)
         sel->showTreeForThis();
 }
 #endif