Mark the createVisiblePosition overloads as deprecated

third_party/WebKit/Source/core/editing/spellcheck/SpellChecker.cpp

 /*
  * Copyright (C) 2006, 2007, 2008, 2011 Apple Inc. All rights reserved.
  * Copyright (C) 2008 Nokia Corporation and/or its subsidiary(-ies)
  *
  * 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
@@ skipping 78 matching lines @@
     if (HTMLElement* element = Traversal<HTMLElement>::firstAncestorOrSelf(*selection.start().anchorNode())) {
         if (element->isSpellCheckingEnabled())
             return true;
     }
     return false;
 }
 
 static EphemeralRange expandEndToSentenceBoundary(const EphemeralRange& range)
 {
     DCHECK(range.isNotNull());
-    const VisiblePosition& visibleEnd = createVisiblePosition(range.endPosition());
+    const VisiblePosition& visibleEnd = createVisiblePositionDeprecated(range.endPosition());
     DCHECK(visibleEnd.isNotNull());
     const Position& sentenceEnd = endOfSentence(visibleEnd).deepEquivalent();
     // TODO(xiaochengh): |sentenceEnd < range.endPosition()| is possible,
     // which would trigger a DCHECK in EphemeralRange's constructor if we return
     // it directly. However, this shouldn't happen and needs to be fixed.
     return EphemeralRange(range.startPosition(), sentenceEnd.isNotNull() && sentenceEnd > range.endPosition() ? sentenceEnd : range.endPosition());
 }
 
 static EphemeralRange expandRangeToSentenceBoundary(const EphemeralRange& range)
 {
     DCHECK(range.isNotNull());
-    const VisiblePosition& visibleStart = createVisiblePosition(range.startPosition());
+    const VisiblePosition& visibleStart = createVisiblePositionDeprecated(range.startPosition());
     DCHECK(visibleStart.isNotNull());
     const Position& sentenceStart = startOfSentence(visibleStart).deepEquivalent();
     // TODO(xiaochengh): |sentenceStart > range.startPosition()| is possible,
     // which would trigger a DCHECK in EphemeralRange's constructor if we return
     // it directly. However, this shouldn't happen and needs to be fixed.
     return expandEndToSentenceBoundary(EphemeralRange(sentenceStart.isNotNull() && sentenceStart < range.startPosition() ? sentenceStart : range.startPosition(), range.endPosition()));
 }
 
 } // namespace
 
@@ skipping 135 matching lines @@
     // topNode defines the whole range we want to operate on
     ContainerNode* topNode = highestEditableRoot(position);
     // TODO(yosin): |lastOffsetForEditing()| is wrong here if
     // |editingIgnoresContent(highestEditableRoot())| returns true, e.g. <table>
     spellingSearchEnd = Position::editingPositionOf(topNode, EditingStrategy::lastOffsetForEditing(topNode));
 
     // If spellingSearchRange starts in the middle of a word, advance to the
     // next word so we start checking at a word boundary. Going back by one char
     // and then forward by a word does the trick.
     if (startedWithSelection) {
-        VisiblePosition oneBeforeStart = previousPositionOf(createVisiblePosition(spellingSearchStart));
+        VisiblePosition oneBeforeStart = previousPositionOf(createVisiblePositionDeprecated(spellingSearchStart));
         if (oneBeforeStart.isNotNull() && rootEditableElementOf(oneBeforeStart) == rootEditableElementOf(spellingSearchStart))
             spellingSearchStart = endOfWord(oneBeforeStart).toParentAnchoredPosition();
         // else we were already at the start of the editable node
     }
 
     if (spellingSearchStart == spellingSearchEnd)
         return; // nothing to search in
 
     // We go to the end of our first range instead of the start of it, just to be sure
     // we don't get foiled by any word boundary problems at the start. It means we might
@@ skipping 102 matching lines @@
 }
 
 void SpellChecker::markMisspellingsAfterTypingCommand(const TypingCommand& cmd)
 {
     m_spellCheckRequester->cancelCheck();
 
     // Take a look at the selection that results after typing and determine whether we need to spellcheck.
     // Since the word containing the current selection is never marked, this does a check to
     // see if typing made a new word that is not in the current selection. Basically, you
     // get this by being at the end of a word and typing a space.
-    VisiblePosition start = createVisiblePosition(cmd.endingSelection().start(), cmd.endingSelection().affinity());
+    VisiblePosition start = createVisiblePositionDeprecated(cmd.endingSelection().start(), cmd.endingSelection().affinity());
     VisiblePosition previous = previousPositionOf(start);
 
     VisiblePosition wordStartOfPrevious = startOfWord(previous, LeftWordIfOnBoundary);
 
     if (cmd.commandTypeOfOpenCommand() == TypingCommand::InsertParagraphSeparator) {
         VisiblePosition nextWord = nextWordPosition(start);
         VisibleSelection words(wordStartOfPrevious, endOfWord(nextWord));
         markMisspellingsAfterLineBreak(words);
         return;
     }
@@ skipping 537 matching lines @@
 {
     String misspelledWord;
 
     // Initialize out parameters; they will be updated if we find something to return.
     String firstFoundItem;
     int firstFoundOffset = 0;
 
     // Expand the search range to encompass entire paragraphs, since text checking needs that much context.
     // Determine the character offset from the start of the paragraph to the start of the original search range,
     // since we will want to ignore results in this area.
-    Position paragraphStart = startOfParagraph(createVisiblePosition(start)).toParentAnchoredPosition();
+    Position paragraphStart = startOfParagraph(createVisiblePositionDeprecated(start)).toParentAnchoredPosition();
     Position paragraphEnd = end;
     int totalRangeLength = TextIterator::rangeLength(paragraphStart, paragraphEnd);
-    paragraphEnd = endOfParagraph(createVisiblePosition(start)).toParentAnchoredPosition();
+    paragraphEnd = endOfParagraph(createVisiblePositionDeprecated(start)).toParentAnchoredPosition();
 
     int rangeStartOffset = TextIterator::rangeLength(paragraphStart, start);
     int totalLengthProcessed = 0;
 
     bool firstIteration = true;
     bool lastIteration = false;
     while (totalLengthProcessed < totalRangeLength) {
         // Iterate through the search range by paragraphs, checking each one for spelling.
         int currentLength = TextIterator::rangeLength(paragraphStart, paragraphEnd);
         int currentStartOffset = firstIteration ? rangeStartOffset : 0;
         int currentEndOffset = currentLength;
-        if (inSameParagraph(createVisiblePosition(paragraphStart), createVisiblePosition(end))) {
+        if (inSameParagraph(createVisiblePositionDeprecated(paragraphStart), createVisiblePositionDeprecated(end))) {
             // Determine the character offset from the end of the original search range to the end of the paragraph,
             // since we will want to ignore results in this area.
             currentEndOffset = TextIterator::rangeLength(paragraphStart, end);
             lastIteration = true;
         }
         if (currentStartOffset < currentEndOffset) {
             String paragraphString = plainText(EphemeralRange(paragraphStart, paragraphEnd));
             if (paragraphString.length() > 0) {
                 int spellingLocation = 0;
 
@@ skipping 16 matching lines @@
                     if (!firstIteration)
                         spellingOffset += TextIterator::rangeLength(start, paragraphStart);
                     firstFoundOffset = spellingOffset;
                     firstFoundItem = misspelledWord;
                     break;
                 }
             }
         }
         if (lastIteration || totalLengthProcessed + currentLength >= totalRangeLength)
             break;
-        VisiblePosition newParagraphStart = startOfNextParagraph(createVisiblePosition(paragraphEnd));
+        VisiblePosition newParagraphStart = startOfNextParagraph(createVisiblePositionDeprecated(paragraphEnd));
         paragraphStart = newParagraphStart.toParentAnchoredPosition();
         paragraphEnd = endOfParagraph(newParagraphStart).toParentAnchoredPosition();
         firstIteration = false;
         totalLengthProcessed += currentLength;
     }
     return std::make_pair(firstFoundItem, firstFoundOffset);
 }
 
 } // namespace blink