Mark the createVisiblePosition overloads as deprecated

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

 /*
  * Copyright (C) 2004, 2005, 2006, 2007 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 515 matching lines @@
     return previousVisuallyDistinctCandidateAlgorithm<EditingStrategy>(position);
 }
 
 PositionInFlatTree previousVisuallyDistinctCandidate(const PositionInFlatTree& position)
 {
     return previousVisuallyDistinctCandidateAlgorithm<EditingInFlatTreeStrategy>(position);
 }
 
 VisiblePosition firstEditableVisiblePositionAfterPositionInRoot(const Position& position, ContainerNode& highestRoot)
 {
-    return createVisiblePosition(firstEditablePositionAfterPositionInRoot(position, highestRoot));
+    return createVisiblePositionDeprecated(firstEditablePositionAfterPositionInRoot(position, highestRoot));
 }
 
 VisiblePositionInFlatTree firstEditableVisiblePositionAfterPositionInRoot(const PositionInFlatTree& position, ContainerNode& highestRoot)
 {
-    return createVisiblePosition(firstEditablePositionAfterPositionInRoot(position, highestRoot));
+    return createVisiblePositionDeprecated(firstEditablePositionAfterPositionInRoot(position, highestRoot));
 }
 
 template <typename Strategy>
 PositionTemplate<Strategy> firstEditablePositionAfterPositionInRootAlgorithm(const PositionTemplate<Strategy>& position, Node& highestRoot)
 {
     DCHECK(!needsLayoutTreeUpdate(highestRoot)) << position << ' ' << highestRoot;
     // position falls before highestRoot.
     if (position.compareTo(PositionTemplate<Strategy>::firstPositionInNode(&highestRoot)) == -1 && hasEditableStyle(highestRoot))
         return PositionTemplate<Strategy>::firstPositionInNode(&highestRoot);
 
@@ skipping 29 matching lines @@
     return firstEditablePositionAfterPositionInRootAlgorithm<EditingStrategy>(position, highestRoot);
 }
 
 PositionInFlatTree firstEditablePositionAfterPositionInRoot(const PositionInFlatTree& position, Node& highestRoot)
 {
     return firstEditablePositionAfterPositionInRootAlgorithm<EditingInFlatTreeStrategy>(position, highestRoot);
 }
 
 VisiblePosition lastEditableVisiblePositionBeforePositionInRoot(const Position& position, ContainerNode& highestRoot)
 {
-    return createVisiblePosition(lastEditablePositionBeforePositionInRoot(position, highestRoot));
+    return createVisiblePositionDeprecated(lastEditablePositionBeforePositionInRoot(position, highestRoot));
 }
 
 VisiblePositionInFlatTree lastEditableVisiblePositionBeforePositionInRoot(const PositionInFlatTree& position, ContainerNode& highestRoot)
 {
-    return createVisiblePosition(lastEditablePositionBeforePositionInRoot(position, highestRoot));
+    return createVisiblePositionDeprecated(lastEditablePositionBeforePositionInRoot(position, highestRoot));
 }
 
 template <typename Strategy>
 PositionTemplate<Strategy> lastEditablePositionBeforePositionInRootAlgorithm(const PositionTemplate<Strategy>& position, Node& highestRoot)
 {
     DCHECK(!needsLayoutTreeUpdate(highestRoot)) << position << ' ' << highestRoot;
     // When position falls after highestRoot, the result is easy to compute.
     if (position.compareTo(PositionTemplate<Strategy>::lastPositionInNode(&highestRoot)) == 1)
         return PositionTemplate<Strategy>::lastPositionInNode(&highestRoot);
 
@@ skipping 368 matching lines @@
 }
 
 static HTMLElement* firstInSpecialElement(const Position& pos)
 {
     Element* element = rootEditableElement(*pos.computeContainerNode());
     for (Node& runner : NodeTraversal::inclusiveAncestorsOf(*pos.anchorNode())) {
         if (rootEditableElement(runner) != element)
             break;
         if (isSpecialHTMLElement(runner)) {
             HTMLElement* specialElement = toHTMLElement(&runner);
-            VisiblePosition vPos = createVisiblePosition(pos);
-            VisiblePosition firstInElement = createVisiblePosition(firstPositionInOrBeforeNode(specialElement));
+            VisiblePosition vPos = createVisiblePositionDeprecated(pos);
+            VisiblePosition firstInElement = createVisiblePositionDeprecated(firstPositionInOrBeforeNode(specialElement));
             if (isDisplayInsideTable(specialElement) && vPos.deepEquivalent() == nextPositionOf(firstInElement).deepEquivalent())
                 return specialElement;
             if (vPos.deepEquivalent() == firstInElement.deepEquivalent())
                 return specialElement;
         }
     }
     return 0;
 }
 
 static HTMLElement* lastInSpecialElement(const Position& pos)
 {
     Element* element = rootEditableElement(*pos.computeContainerNode());
     for (Node& runner : NodeTraversal::inclusiveAncestorsOf(*pos.anchorNode())) {
         if (rootEditableElement(runner) != element)
             break;
         if (isSpecialHTMLElement(runner)) {
             HTMLElement* specialElement = toHTMLElement(&runner);
-            VisiblePosition vPos = createVisiblePosition(pos);
-            VisiblePosition lastInElement = createVisiblePosition(lastPositionInOrAfterNode(specialElement));
+            VisiblePosition vPos = createVisiblePositionDeprecated(pos);
+            VisiblePosition lastInElement = createVisiblePositionDeprecated(lastPositionInOrAfterNode(specialElement));
             if (isDisplayInsideTable(specialElement) && vPos.deepEquivalent() == previousPositionOf(lastInElement).deepEquivalent())
                 return specialElement;
             if (vPos.deepEquivalent() == lastInElement.deepEquivalent())
                 return specialElement;
         }
     }
     return 0;
 }
 
 Position positionBeforeContainingSpecialElement(const Position& pos, HTMLElement** containingSpecialElement)
@@ skipping 95 matching lines @@
             return node;
         node = nextNodeConsideringAtomicNodes(*node);
     }
     return nullptr;
 }
 
 // Returns the visible position at the beginning of a node
 VisiblePosition visiblePositionBeforeNode(Node& node)
 {
     if (node.hasChildren())
-        return createVisiblePosition(firstPositionInOrBeforeNode(&node));
+        return createVisiblePositionDeprecated(firstPositionInOrBeforeNode(&node));
     DCHECK(node.parentNode()) << node;
     DCHECK(!node.parentNode()->isShadowRoot()) << node.parentNode();
     return VisiblePosition::inParentBeforeNode(node);
 }
 
 // Returns the visible position at the ending of a node
 VisiblePosition visiblePositionAfterNode(Node& node)
 {
     if (node.hasChildren())
-        return createVisiblePosition(lastPositionInOrAfterNode(&node));
+        return createVisiblePositionDeprecated(lastPositionInOrAfterNode(&node));
     DCHECK(node.parentNode()) << node.parentNode();
     DCHECK(!node.parentNode()->isShadowRoot()) << node.parentNode();
     return VisiblePosition::inParentAfterNode(node);
 }
 
 bool isHTMLListElement(Node* n)
 {
     return (n && (isHTMLUListElement(*n) || isHTMLOListElement(*n) || isHTMLDListElement(*n)));
 }
 
@@ skipping 171 matching lines @@
 }
 
 // FIXME: This method should not need to call isStartOfParagraph/isEndOfParagraph
 Node* enclosingEmptyListItem(const VisiblePosition& visiblePos)
 {
     // Check that position is on a line by itself inside a list item
     Node* listChildNode = enclosingListChild(visiblePos.deepEquivalent().anchorNode());
     if (!listChildNode || !isStartOfParagraph(visiblePos) || !isEndOfParagraph(visiblePos))
         return 0;
 
-    VisiblePosition firstInListChild = createVisiblePosition(firstPositionInOrBeforeNode(listChildNode));
-    VisiblePosition lastInListChild = createVisiblePosition(lastPositionInOrAfterNode(listChildNode));
+    VisiblePosition firstInListChild = createVisiblePositionDeprecated(firstPositionInOrBeforeNode(listChildNode));
+    VisiblePosition lastInListChild = createVisiblePositionDeprecated(lastPositionInOrAfterNode(listChildNode));
 
     if (firstInListChild.deepEquivalent() != visiblePos.deepEquivalent() || lastInListChild.deepEquivalent() != visiblePos.deepEquivalent())
         return 0;
 
     return listChildNode;
 }
 
 HTMLElement* outermostEnclosingList(Node* node, HTMLElement* rootList)
 {
     HTMLElement* list = enclosingList(node);
     if (!list)
         return 0;
 
     while (HTMLElement* nextList = enclosingList(list)) {
         if (nextList == rootList)
             break;
         list = nextList;
     }
 
     return list;
 }
 
 // Determines whether two positions are visibly next to each other (first then second)
 // while ignoring whitespaces and unrendered nodes
 static bool isVisiblyAdjacent(const Position& first, const Position& second)
 {
-    return createVisiblePosition(first).deepEquivalent() == createVisiblePosition(mostBackwardCaretPosition(second)).deepEquivalent();
+    return createVisiblePositionDeprecated(first).deepEquivalent() == createVisiblePositionDeprecated(mostBackwardCaretPosition(second)).deepEquivalent();
 }
 
 bool canMergeLists(Element* firstList, Element* secondList)
 {
     if (!firstList || !secondList || !firstList->isHTMLElement() || !secondList->isHTMLElement())
         return false;
 
     return firstList->hasTagName(secondList->tagQName()) // make sure the list types match (ol vs. ul)
     && hasEditableStyle(*firstList) && hasEditableStyle(*secondList) // both lists are editable
     && rootEditableElement(*firstList) == rootEditableElement(*secondList) // don't cross editing boundaries
@@ skipping 122 matching lines @@
 }
 
 // return first preceding DOM position rendered at a different location, or "this"
 static Position previousCharacterPosition(const Position& position, TextAffinity affinity)
 {
     if (position.isNull())
         return Position();
 
     Element* fromRootEditableElement = rootEditableElement(*position.anchorNode());
 
-    bool atStartOfLine = isStartOfLine(createVisiblePosition(position, affinity));
+    bool atStartOfLine = isStartOfLine(createVisiblePositionDeprecated(position, affinity));
     bool rendered = isVisuallyEquivalentCandidate(position);
 
     Position currentPos = position;
     while (!currentPos.atStartOfTree()) {
         // TODO(yosin) When we use |previousCharacterPosition()| other than
         // finding leading whitespace, we should use |Character| instead of
         // |CodePoint|.
         currentPos = previousPositionOf(currentPos, PositionMoveType::CodeUnit);
 
         if (rootEditableElement(*currentPos.anchorNode()) != fromRootEditableElement)
@@ skipping 38 matching lines @@
     return prev;
 }
 
 // This assumes that it starts in editable content.
 Position trailingWhitespacePosition(const Position& position, TextAffinity, WhitespacePositionOption option)
 {
     DCHECK(isEditablePosition(position)) << position;
     if (position.isNull())
         return Position();
 
-    VisiblePosition visiblePosition = createVisiblePosition(position);
+    VisiblePosition visiblePosition = createVisiblePositionDeprecated(position);
     UChar characterAfterVisiblePosition = characterAfter(visiblePosition);
     bool isSpace = option == ConsiderNonCollapsibleWhitespace ? (isSpaceOrNewline(characterAfterVisiblePosition) || characterAfterVisiblePosition == noBreakSpaceCharacter) : isCollapsibleWhitespace(characterAfterVisiblePosition);
     // The space must not be in another paragraph and it must be editable.
     if (isSpace && !isEndOfParagraph(visiblePosition) && nextPositionOf(visiblePosition, CannotCrossEditingBoundary).isNotNull())
         return position;
     return Position();
 }
 
 unsigned numEnclosingMailBlockquotes(const Position& p)
 {
@@ skipping 188 matching lines @@
 VisiblePosition visiblePositionForIndex(int index, ContainerNode* scope)
 {
     if (!scope)
         return VisiblePosition();
     EphemeralRange range = PlainTextRange(index).createRangeForSelection(*scope);
     // Check for an invalid index. Certain editing operations invalidate indices
     // because of problems with
     // TextIteratorEmitsCharactersBetweenAllVisiblePositions.
     if (range.isNull())
         return VisiblePosition();
-    return createVisiblePosition(range.startPosition());
+    return createVisiblePositionDeprecated(range.startPosition());
 }
 
 // Determines whether a node is inside a range or visibly starts and ends at the boundaries of the range.
 // Call this function to determine whether a node is visibly fit inside selectedRange
 bool isNodeVisiblyContainedWithin(Node& node, const Range& selectedRange)
 {
     if (selectedRange.isNodeFullyContained(node))
         return true;
 
-    bool startIsVisuallySame = visiblePositionBeforeNode(node).deepEquivalent() == createVisiblePosition(selectedRange.startPosition()).deepEquivalent();
+    bool startIsVisuallySame = visiblePositionBeforeNode(node).deepEquivalent() == createVisiblePositionDeprecated(selectedRange.startPosition()).deepEquivalent();
     if (startIsVisuallySame && comparePositions(Position::inParentAfterNode(node), selectedRange.endPosition()) < 0)
         return true;
 
-    bool endIsVisuallySame = visiblePositionAfterNode(node).deepEquivalent() == createVisiblePosition(selectedRange.endPosition()).deepEquivalent();
+    bool endIsVisuallySame = visiblePositionAfterNode(node).deepEquivalent() == createVisiblePositionDeprecated(selectedRange.endPosition()).deepEquivalent();
     if (endIsVisuallySame && comparePositions(selectedRange.startPosition(), Position::inParentBeforeNode(node)) < 0)
         return true;
 
     return startIsVisuallySame && endIsVisuallySame;
 }
 
 bool isRenderedAsNonInlineTableImageOrHR(const Node* node)
 {
     if (!node)
         return false;
@@ skipping 42 matching lines @@
     return node.isElementNode() && layoutObject && layoutObject->isLayoutBlockFlow();
 }
 
 Position adjustedSelectionStartForStyleComputation(const VisibleSelection& selection)
 {
     // This function is used by range style computations to avoid bugs like:
     // <rdar://problem/4017641> REGRESSION (Mail): you can only bold/unbold a selection starting from end of line once
     // It is important to skip certain irrelevant content at the start of the selection, so we do not wind up
     // with a spurious "mixed" style.
 
-    VisiblePosition visiblePosition = createVisiblePosition(selection.start());
+    VisiblePosition visiblePosition = createVisiblePositionDeprecated(selection.start());
     if (visiblePosition.isNull())
         return Position();
 
     // if the selection is a caret, just return the position, since the style
     // behind us is relevant
     if (selection.isCaret())
         return visiblePosition.deepEquivalent();
 
     // if the selection starts just before a paragraph break, skip over it
     if (isEndOfParagraph(visiblePosition))
@@ skipping 68 matching lines @@
             return InputType::DeleteWordBackward;
         if (granularity == LineBoundary)
             return InputType::DeleteLineBackward;
         return InputType::DeleteContentBackward;
     default:
         return InputType::None;
     }
 }
 
 } // namespace blink