Mark the createVisiblePosition overloads as deprecated

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

 /*
  * Copyright (C) 2005, 2006, 2007, 2008 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 714 matching lines @@
         upstream--;
 
     int downstream = endOffset;
     while ((unsigned)downstream < text.length() && isWhitespace(text[downstream]))
         downstream++;
 
     int length = downstream - upstream;
     if (!length)
         return;
 
-    VisiblePosition visibleUpstreamPos = createVisiblePosition(Position(textNode, upstream));
-    VisiblePosition visibleDownstreamPos = createVisiblePosition(Position(textNode, downstream));
+    VisiblePosition visibleUpstreamPos = createVisiblePositionDeprecated(Position(textNode, upstream));
+    VisiblePosition visibleDownstreamPos = createVisiblePositionDeprecated(Position(textNode, downstream));
 
     String string = text.substring(upstream, length);
     // FIXME: Because of the problem mentioned at the top of this function, we
     // must also use nbsps at the start/end of the string because this function
     // doesn't get all surrounding whitespace, just the whitespace in the
     // current text node. However, if the next sibling node is a text node
     // (not empty, see http://crbug.com/632300), we should use a plain space.
     // See http://crbug.com/310149
     const bool nextSiblingIsTextNode = textNode->nextSibling() && textNode->nextSibling()->isTextNode()
         && toText(textNode->nextSibling())->data().length();
@@ skipping 18 matching lines @@
         return;
     LayoutText* layoutText = textNode->layoutObject();
     if (layoutText && !layoutText->style()->collapseWhiteSpace())
         return;
 
     // Delete collapsed whitespace so that inserting nbsps doesn't uncollapse it.
     Position upstreamPos = mostBackwardCaretPosition(position);
     deleteInsignificantText(upstreamPos, mostForwardCaretPosition(position));
     position = mostForwardCaretPosition(upstreamPos);
 
-    VisiblePosition visiblePos = createVisiblePosition(position);
+    VisiblePosition visiblePos = createVisiblePositionDeprecated(position);
     VisiblePosition previousVisiblePos = previousPositionOf(visiblePos);
     replaceCollapsibleWhitespaceWithNonBreakingSpaceIfNeeded(previousVisiblePos);
     replaceCollapsibleWhitespaceWithNonBreakingSpaceIfNeeded(visiblePos);
 }
 
 void CompositeEditCommand::replaceCollapsibleWhitespaceWithNonBreakingSpaceIfNeeded(const VisiblePosition& visiblePosition)
 {
     if (!isCollapsibleWhitespace(characterAfter(visiblePosition)))
         return;
     Position pos = mostForwardCaretPosition(visiblePosition.deepEquivalent());
@@ skipping 114 matching lines @@
     for (const auto& node : nodes) {
         Text* textNode = node;
         int startOffset = textNode == start.anchorNode() ? start.computeOffsetInContainerNode() : 0;
         int endOffset = textNode == end.anchorNode() ? end.computeOffsetInContainerNode() : static_cast<int>(textNode->length());
         deleteInsignificantText(textNode, startOffset, endOffset);
     }
 }
 
 void CompositeEditCommand::deleteInsignificantTextDownstream(const Position& pos)
 {
-    Position end = mostForwardCaretPosition(nextPositionOf(createVisiblePosition(pos, VP_DEFAULT_AFFINITY)).deepEquivalent());
+    Position end = mostForwardCaretPosition(nextPositionOf(createVisiblePositionDeprecated(pos, VP_DEFAULT_AFFINITY)).deepEquivalent());
     deleteInsignificantText(pos, end);
 }
 
 HTMLBRElement* CompositeEditCommand::appendBlockPlaceholder(Element* container, EditingState* editingState)
 {
     if (!container)
         return nullptr;
 
     document().updateStyleAndLayoutIgnorePendingStylesheets();
 
@@ skipping 68 matching lines @@
 }
 
 // If the paragraph is not entirely within it's own block, create one and move the paragraph into
 // it, and return that block.  Otherwise return 0.
 HTMLElement* CompositeEditCommand::moveParagraphContentsToNewBlockIfNecessary(const Position& pos, EditingState* editingState)
 {
     DCHECK(isEditablePosition(pos)) << pos;
 
     // It's strange that this function is responsible for verifying that pos has not been invalidated
     // by an earlier call to this function.  The caller, applyBlockStyle, should do this.
-    VisiblePosition visiblePos = createVisiblePosition(pos, VP_DEFAULT_AFFINITY);
+    VisiblePosition visiblePos = createVisiblePositionDeprecated(pos, VP_DEFAULT_AFFINITY);
     VisiblePosition visibleParagraphStart = startOfParagraph(visiblePos);
     VisiblePosition visibleParagraphEnd = endOfParagraph(visiblePos);
     VisiblePosition next = nextPositionOf(visibleParagraphEnd);
     VisiblePosition visibleEnd = next.isNotNull() ? next : visibleParagraphEnd;
 
     Position upstreamStart = mostBackwardCaretPosition(visibleParagraphStart.deepEquivalent());
     Position upstreamEnd = mostBackwardCaretPosition(visibleEnd.deepEquivalent());
 
     // If there are no VisiblePositions in the same block as pos then
     // upstreamStart will be outside the paragraph
@@ skipping 29 matching lines @@
         return nullptr;
 
     HTMLElement* newBlock = insertNewDefaultParagraphElementAt(upstreamStart, editingState);
     if (editingState->isAborted())
         return nullptr;
 
     bool endWasBr = isHTMLBRElement(*visibleParagraphEnd.deepEquivalent().anchorNode());
 
     // Inserting default paragraph element can change visible position. We
     // should update visible positions before use them.
-    visiblePos = createVisiblePosition(pos, VP_DEFAULT_AFFINITY);
+    visiblePos = createVisiblePositionDeprecated(pos, VP_DEFAULT_AFFINITY);
     visibleParagraphStart = startOfParagraph(visiblePos);
     visibleParagraphEnd = endOfParagraph(visiblePos);
     moveParagraphs(visibleParagraphStart, visibleParagraphEnd, VisiblePosition::firstPositionInNode(newBlock), editingState);
     if (editingState->isAborted())
         return nullptr;
 
     if (newBlock->lastChild() && isHTMLBRElement(*newBlock->lastChild()) && !endWasBr) {
         removeNode(newBlock->lastChild(), editingState);
         if (editingState->isAborted())
             return nullptr;
@@ skipping 191 matching lines @@
 
     // Add a br if pruning an empty block level element caused a collapse.  For example:
     // foo^
     // <div>bar</div>
     // baz
     // Imagine moving 'bar' to ^.  'bar' will be deleted and its div pruned.  That would
     // cause 'baz' to collapse onto the line with 'foobar' unless we insert a br.
     // Must recononicalize these two VisiblePositions after the pruning above.
     // TODO(yosin): We should abort when |beforeParagraph| is a orphan when
     // we have a sample.
-    beforeParagraph = createVisiblePosition(beforeParagraph.deepEquivalent());
+    beforeParagraph = createVisiblePositionDeprecated(beforeParagraph.deepEquivalent());
     if (afterParagraph.isOrphan()) {
         editingState->abort();
         return;
     }
-    afterParagraph = createVisiblePosition(afterParagraph.deepEquivalent());
+    afterParagraph = createVisiblePositionDeprecated(afterParagraph.deepEquivalent());
 
     if (beforeParagraph.isNotNull() && !isDisplayInsideTable(beforeParagraph.deepEquivalent().anchorNode())
         && ((!isEndOfParagraph(beforeParagraph) && !isStartOfParagraph(beforeParagraph)) || beforeParagraph.deepEquivalent() == afterParagraph.deepEquivalent())) {
         // FIXME: Trim text between beforeParagraph and afterParagraph if they aren't equal.
         insertNodeAt(HTMLBRElement::create(document()), beforeParagraph.deepEquivalent(), editingState);
     }
 }
 
 void CompositeEditCommand::moveParagraph(const VisiblePosition& startOfParagraphToMove, const VisiblePosition& endOfParagraphToMove, const VisiblePosition& destination, EditingState* editingState, ShouldPreserveSelection shouldPreserveSelection, ShouldPreserveStyle shouldPreserveStyle, Node* constrainingAncestor)
 {
@@ skipping 73 matching lines @@
         return;
     DCHECK(destination.deepEquivalent().isConnected()) << destination;
 
     // Add a br if pruning an empty block level element caused a collapse. For example:
     // foo^
     // <div>bar</div>
     // baz
     // Imagine moving 'bar' to ^. 'bar' will be deleted and its div pruned. That would
     // cause 'baz' to collapse onto the line with 'foobar' unless we insert a br.
     // Must recononicalize these two VisiblePositions after the pruning above.
-    VisiblePosition beforeParagraph = createVisiblePosition(beforeParagraphPosition.position());
-    VisiblePosition afterParagraph = createVisiblePosition(afterParagraphPosition.position());
+    VisiblePosition beforeParagraph = createVisiblePositionDeprecated(beforeParagraphPosition.position());
+    VisiblePosition afterParagraph = createVisiblePositionDeprecated(afterParagraphPosition.position());
     if (beforeParagraph.isNotNull() && (!isEndOfParagraph(beforeParagraph) || beforeParagraph.deepEquivalent() == afterParagraph.deepEquivalent())) {
         // FIXME: Trim text between beforeParagraph and afterParagraph if they aren't equal.
         insertNodeAt(HTMLBRElement::create(document()), beforeParagraph.deepEquivalent(), editingState);
         if (editingState->isAborted())
             return;
         // Need an updateLayout here in case inserting the br has split a text node.
         document().updateStyleAndLayoutIgnorePendingStylesheets();
     }
 
     destinationIndex = TextIterator::rangeLength(Position::firstPositionInNode(document().documentElement()), destination.toParentAnchoredPosition(), true);
@@ skipping 192 matching lines @@
 
 // Operations use this function to avoid inserting content into an anchor when at the start or the end of
 // that anchor, as in NSTextView.
 // FIXME: This is only an approximation of NSTextViews insertion behavior, which varies depending on how
 // the caret was made.
 Position CompositeEditCommand::positionAvoidingSpecialElementBoundary(const Position& original, EditingState* editingState)
 {
     if (original.isNull())
         return original;
 
-    VisiblePosition visiblePos = createVisiblePosition(original);
+    VisiblePosition visiblePos = createVisiblePositionDeprecated(original);
     Element* enclosingAnchor = enclosingAnchorElement(original);
     Position result = original;
 
     if (!enclosingAnchor)
         return result;
 
     // Don't avoid block level anchors, because that would insert content into the wrong paragraph.
     if (enclosingAnchor && !isEnclosingBlock(enclosingAnchor)) {
         VisiblePosition firstInAnchor = VisiblePosition::firstPositionInNode(enclosingAnchor);
         VisiblePosition lastInAnchor = VisiblePosition::lastPositionInNode(enclosingAnchor);
@@ skipping 56 matching lines @@
         return end;
 
     Node* endNode = end;
     Node* node = nullptr;
     for (node = start; node->parentNode() != endNode; node = node->parentNode()) {
         Element* parentElement = node->parentElement();
         if (!parentElement)
             break;
         // Do not split a node when doing so introduces an empty node.
         VisiblePosition positionInParent = VisiblePosition::firstPositionInNode(parentElement);
-        VisiblePosition positionInNode = createVisiblePosition(firstPositionInOrBeforeNode(node));
+        VisiblePosition positionInNode = createVisiblePositionDeprecated(firstPositionInOrBeforeNode(node));
         if (positionInParent.deepEquivalent() != positionInNode.deepEquivalent())
             splitElement(parentElement, node);
     }
 
     return node;
 }
 
 DEFINE_TRACE(CompositeEditCommand)
 {
     visitor->trace(m_commands);
     visitor->trace(m_composition);
     EditCommand::trace(visitor);
 }
 
 } // namespace blink