Mark the createVisiblePosition overloads as deprecated

third_party/WebKit/Source/core/editing/commands/ReplaceSelectionCommand.cpp

 /*
  * Copyright (C) 2005, 2006, 2008 Apple Inc. All rights reserved.
  * Copyright (C) 2009, 2010, 2011 Google 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
@@ skipping 122 matching lines @@
     Element* enclosingBlockElement = enclosingBlock(pos.computeContainerNode());
     for (Position nextPosition = pos; nextPosition.computeContainerNode() != enclosingBlockElement; pos = nextPosition) {
         if (lineBreakExistsAtPosition(pos))
             break;
 
         if (pos.computeContainerNode()->nonShadowBoundaryParentNode())
             nextPosition = Position::inParentAfterNode(*pos.computeContainerNode());
 
         if (nextPosition == pos
             || enclosingBlock(nextPosition.computeContainerNode()) != enclosingBlockElement
-            || createVisiblePosition(pos).deepEquivalent() != createVisiblePosition(nextPosition).deepEquivalent())
+            || createVisiblePositionDeprecated(pos).deepEquivalent() != createVisiblePositionDeprecated(nextPosition).deepEquivalent())
             break;
     }
     return pos;
 }
 
 ReplacementFragment::ReplacementFragment(Document* document, DocumentFragment* fragment, const VisibleSelection& selection)
     : m_document(document)
     , m_fragment(fragment)
     , m_hasInterchangeNewlineAtStart(false)
     , m_hasInterchangeNewlineAtEnd(false)
@@ skipping 543 matching lines @@
             }
         }
     }
 }
 
 void ReplaceSelectionCommand::moveElementOutOfAncestor(Element* element, Element* ancestor, EditingState* editingState)
 {
     if (!hasEditableStyle(*ancestor->parentNode()))
         return;
 
-    VisiblePosition positionAtEndOfNode = createVisiblePosition(lastPositionInOrAfterNode(element));
+    VisiblePosition positionAtEndOfNode = createVisiblePositionDeprecated(lastPositionInOrAfterNode(element));
     VisiblePosition lastPositionInParagraph = VisiblePosition::lastPositionInNode(ancestor);
     if (positionAtEndOfNode.deepEquivalent() == lastPositionInParagraph.deepEquivalent()) {
         removeNode(element, editingState);
         if (editingState->isAborted())
             return;
         if (ancestor->nextSibling())
             insertNodeBefore(element, ancestor->nextSibling(), editingState);
         else
             appendNode(element, ancestor->parentNode(), editingState);
         if (editingState->isAborted())
@@ skipping 39 matching lines @@
     }
 }
 
 VisiblePosition ReplaceSelectionCommand::positionAtEndOfInsertedContent() const
 {
     // TODO(yosin): We should set |m_endOfInsertedContent| not in SELECT
     // element, since contents of SELECT elements, e.g. OPTION, OPTGROUP, are
     // not editable, or SELECT element is an atomic on editing.
     HTMLSelectElement* enclosingSelect = toHTMLSelectElement(enclosingElementWithTag(m_endOfInsertedContent, selectTag));
     if (enclosingSelect)
-        return createVisiblePosition(lastPositionInOrAfterNode(enclosingSelect));
+        return createVisiblePositionDeprecated(lastPositionInOrAfterNode(enclosingSelect));
     if (m_endOfInsertedContent.isOrphan())
         return VisiblePosition();
-    return createVisiblePosition(m_endOfInsertedContent);
+    return createVisiblePositionDeprecated(m_endOfInsertedContent);
 }
 
 VisiblePosition ReplaceSelectionCommand::positionAtStartOfInsertedContent() const
 {
     if (m_startOfInsertedContent.isOrphan())
         return VisiblePosition();
-    return createVisiblePosition(m_startOfInsertedContent);
+    return createVisiblePositionDeprecated(m_startOfInsertedContent);
 }
 
 static void removeHeadContents(ReplacementFragment& fragment)
 {
     Node* next = nullptr;
     for (Node* node = fragment.firstChild(); node; node = next) {
         if (isHTMLBaseElement(*node)
             || isHTMLLinkElement(*node)
             || isHTMLMetaElement(*node)
             || isHTMLTitleElement(*node)) {
@@ skipping 354 matching lines @@
     VisiblePosition originalVisPosBeforeEndBR;
     if (endBR)
         originalVisPosBeforeEndBR = previousPositionOf(VisiblePosition::beforeNode(endBR));
 
     Element* enclosingBlockOfInsertionPos = enclosingBlock(insertionPos.anchorNode());
 
     // Adjust |enclosingBlockOfInsertionPos| to prevent nesting.
     // If the start was in a Mail blockquote, we will have already handled
     // adjusting |enclosingBlockOfInsertionPos| above.
     if (m_preventNesting && enclosingBlockOfInsertionPos && enclosingBlockOfInsertionPos != currentRoot && !isTableCell(enclosingBlockOfInsertionPos) && !startIsInsideMailBlockquote) {
-        VisiblePosition visibleInsertionPos = createVisiblePosition(insertionPos);
+        VisiblePosition visibleInsertionPos = createVisiblePositionDeprecated(insertionPos);
         if (isEndOfBlock(visibleInsertionPos) && !(isStartOfBlock(visibleInsertionPos) && fragment.hasInterchangeNewlineAtEnd()))
             insertionPos = Position::inParentAfterNode(*enclosingBlockOfInsertionPos);
         else if (isStartOfBlock(visibleInsertionPos))
             insertionPos = Position::inParentBeforeNode(*enclosingBlockOfInsertionPos);
     }
 
     // Paste at start or end of link goes outside of link.
     insertionPos = positionAvoidingSpecialElementBoundary(insertionPos, editingState);
     if (editingState->isAborted())
         return;
@@ skipping 110 matching lines @@
 
     // Mutation events (bug 20161) may have already removed the inserted content
     if (!insertedNodes.firstNodeInserted() || !insertedNodes.firstNodeInserted()->isConnected())
         return;
 
     // Scripts specified in javascript protocol may remove |enclosingBlockOfInsertionPos|
     // during insertion, e.g. <iframe src="javascript:...">
     if (enclosingBlockOfInsertionPos && !enclosingBlockOfInsertionPos->isConnected())
         enclosingBlockOfInsertionPos = nullptr;
 
-    VisiblePosition startOfInsertedContent = createVisiblePosition(firstPositionInOrBeforeNode(insertedNodes.firstNodeInserted()));
+    VisiblePosition startOfInsertedContent = createVisiblePositionDeprecated(firstPositionInOrBeforeNode(insertedNodes.firstNodeInserted()));
 
     // We inserted before the enclosingBlockOfInsertionPos to prevent nesting, and the content before the enclosingBlockOfInsertionPos wasn't in its own block and
     // didn't have a br after it, so the inserted content ended up in the same paragraph.
     if (!startOfInsertedContent.isNull() && enclosingBlockOfInsertionPos && insertionPos.anchorNode() == enclosingBlockOfInsertionPos->parentNode() && (unsigned)insertionPos.computeEditingOffset() < enclosingBlockOfInsertionPos->nodeIndex() && !isStartOfParagraph(startOfInsertedContent)) {
         insertNodeAt(HTMLBRElement::create(document()), startOfInsertedContent.deepEquivalent(), editingState);
         if (editingState->isAborted())
             return;
     }
 
     if (endBR && (plainTextFragment || (shouldRemoveEndBR(endBR, originalVisPosBeforeEndBR) && !(fragment.hasInterchangeNewlineAtEnd() && selectionIsPlainText)))) {
@@ skipping 350 matching lines @@
     return m_inputType;
 }
 
 // If the user is inserting a list into an existing list, instead of nesting the list,
 // we put the list items into the existing list.
 Node* ReplaceSelectionCommand::insertAsListItems(HTMLElement* listElement, Element* insertionBlock, const Position& insertPos, InsertedNodes& insertedNodes, EditingState* editingState)
 {
     while (listElement->hasOneChild() && isHTMLListElement(listElement->firstChild()))
         listElement = toHTMLElement(listElement->firstChild());
 
-    bool isStart = isStartOfParagraph(createVisiblePosition(insertPos));
-    bool isEnd = isEndOfParagraph(createVisiblePosition(insertPos));
+    bool isStart = isStartOfParagraph(createVisiblePositionDeprecated(insertPos));
+    bool isEnd = isEndOfParagraph(createVisiblePositionDeprecated(insertPos));
     bool isMiddle = !isStart && !isEnd;
     Node* lastNode = insertionBlock;
 
     // If we're in the middle of a list item, we should split it into two separate
     // list items and insert these nodes between them.
     if (isMiddle) {
         int textNodeOffset = insertPos.offsetInContainerNode();
         if (insertPos.anchorNode()->isTextNode() && textNodeOffset > 0)
             splitTextNode(toText(insertPos.anchorNode()), textNodeOffset);
         splitTreeToNode(insertPos.anchorNode(), lastNode, true);
@@ skipping 92 matching lines @@
     visitor->trace(m_startOfInsertedContent);
     visitor->trace(m_endOfInsertedContent);
     visitor->trace(m_insertionStyle);
     visitor->trace(m_documentFragment);
     visitor->trace(m_startOfInsertedRange);
     visitor->trace(m_endOfInsertedRange);
     CompositeEditCommand::trace(visitor);
 }
 
 } // namespace blink