Prune some CreateVisiblePositionDeprecated calls from EditingUtilities

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 73 matching lines @@
 bool needsLayoutTreeUpdate(const Node& node)
 {
     const Document& document = node.document();
     if (document.needsLayoutTreeUpdate())
         return true;
     // TODO(yosin): We should make |document::needsLayoutTreeUpdate()| to
     // check |LayoutView::needsLayout()|.
     return document.view() && document.view()->needsLayout();
 }
 
-bool needsLayoutTreeUpdate(const Position& position)
+template <typename PositionType>
+static bool needsLayoutTreeUpdateAlgorithm(const PositionType& position)
 {
     const Node* node = position.anchorNode();
     if (!node)
         return false;
     return needsLayoutTreeUpdate(*node);
 }
 
+bool needsLayoutTreeUpdate(const Position& position)
+{
+    return needsLayoutTreeUpdateAlgorithm<Position>(position);
+}
+
+bool needsLayoutTreeUpdate(const PositionInFlatTree& position)
+{
+    return needsLayoutTreeUpdateAlgorithm<PositionInFlatTree>(position);
+}
+
 // Atomic means that the node has no children, or has children which are ignored for the
 // purposes of editing.
 bool isAtomicNode(const Node *node)
 {
     return node && (!node->hasChildren() || editingIgnoresContent(node));
 }
 
 template <typename Traversal>
 static int comparePositions(Node* containerA, int offsetA, Node* containerB, int offsetB, bool* disconnected)
 {
@@ skipping 414 matching lines @@
     return previousVisuallyDistinctCandidateAlgorithm<EditingStrategy>(position);
 }
 
 PositionInFlatTree previousVisuallyDistinctCandidate(const PositionInFlatTree& position)
 {
     return previousVisuallyDistinctCandidateAlgorithm<EditingInFlatTreeStrategy>(position);
 }
 
 VisiblePosition firstEditableVisiblePositionAfterPositionInRoot(const Position& position, ContainerNode& highestRoot)
 {
-    return createVisiblePositionDeprecated(firstEditablePositionAfterPositionInRoot(position, highestRoot));
+    DCHECK(!needsLayoutTreeUpdate(position));
+    return createVisiblePosition(firstEditablePositionAfterPositionInRoot(position, highestRoot));
 }
 
 VisiblePositionInFlatTree firstEditableVisiblePositionAfterPositionInRoot(const PositionInFlatTree& position, ContainerNode& highestRoot)
 {
-    return createVisiblePositionDeprecated(firstEditablePositionAfterPositionInRoot(position, highestRoot));
+    DCHECK(!needsLayoutTreeUpdate(position));
+    return createVisiblePosition(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 createVisiblePositionDeprecated(lastEditablePositionBeforePositionInRoot(position, highestRoot));
+    DCHECK(!needsLayoutTreeUpdate(position));
+    return createVisiblePosition(lastEditablePositionBeforePositionInRoot(position, highestRoot));
 }
 
 VisiblePositionInFlatTree lastEditableVisiblePositionBeforePositionInRoot(const PositionInFlatTree& position, ContainerNode& highestRoot)
 {
-    return createVisiblePositionDeprecated(lastEditablePositionBeforePositionInRoot(position, highestRoot));
+    DCHECK(!needsLayoutTreeUpdate(position));
+    return createVisiblePosition(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 701 matching lines @@
         if (n == root || isTableCell(n))
             return 0;
     }
 
     return 0;
 }
 
 // FIXME: This method should not need to call isStartOfParagraph/isEndOfParagraph
 Node* enclosingEmptyListItem(const VisiblePosition& visiblePos)
 {
+    DCHECK(visiblePos.isValid());
+
     // 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 = createVisiblePositionDeprecated(firstPositionInOrBeforeNode(listChildNode));
-    VisiblePosition lastInListChild = createVisiblePositionDeprecated(lastPositionInOrAfterNode(listChildNode));
+    VisiblePosition firstInListChild = createVisiblePosition(firstPositionInOrBeforeNode(listChildNode));
+    VisiblePosition lastInListChild = createVisiblePosition(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);
@@ skipping 411 matching lines @@
 
 EphemeralRangeInFlatTree normalizeRange(const EphemeralRangeInFlatTree& range)
 {
     return normalizeRangeAlgorithm<EditingInFlatTreeStrategy>(range);
 }
 
 VisiblePosition visiblePositionForIndex(int index, ContainerNode* scope)
 {
     if (!scope)
         return VisiblePosition();
+    DCHECK(!scope->document().needsLayoutTreeUpdate());
+    DocumentLifecycle::DisallowTransitionScope disallowTransition(scope->document().lifecycle());
+
     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 createVisiblePositionDeprecated(range.startPosition());
+    return createVisiblePosition(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() == createVisiblePositionDeprecated(selectedRange.startPosition()).deepEquivalent();
@@ skipping 145 matching lines @@
             return InputType::DeleteWordBackward;
         if (granularity == LineBoundary)
             return InputType::DeleteLineBackward;
         return InputType::DeleteContentBackward;
     default:
         return InputType::None;
     }
 }
 
 } // namespace blink