Mark calls of {previous,next}PositionOf with invalid VisiblePosition deprecated

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

Index: third_party/WebKit/Source/core/editing/VisibleUnits.cpp
diff --git a/third_party/WebKit/Source/core/editing/VisibleUnits.cpp b/third_party/WebKit/Source/core/editing/VisibleUnits.cpp
index 6ab9347e7956955e656efcf9ca7369271f385b7e..53af524c7724ce42830ed87902445c1c412f2b48 100644
--- a/third_party/WebKit/Source/core/editing/VisibleUnits.cpp
+++ b/third_party/WebKit/Source/core/editing/VisibleUnits.cpp
@@ -3389,32 +3389,48 @@ VisiblePositionInFlatTree rightPositionOf(const VisiblePositionInFlatTree& visib
 }
 
 template <typename Strategy>
-static VisiblePositionTemplate<Strategy> nextPositionOfAlgorithm(const VisiblePositionTemplate<Strategy>& visiblePosition, EditingBoundaryCrossingRule rule)
+static VisiblePositionTemplate<Strategy> nextPositionOfAlgorithm(const PositionWithAffinityTemplate<Strategy>& position, EditingBoundaryCrossingRule rule)
 {
-    // TODO(xiaochengh): Ensure that this function is called with a valid
-    // |visiblePosition|, and add |DCHECK(visiblePosition.isValid())|;
-    const VisiblePositionTemplate<Strategy> next = createVisiblePositionDeprecated(nextVisuallyDistinctCandidate(visiblePosition.deepEquivalent()), visiblePosition.affinity());
+    const VisiblePositionTemplate<Strategy> next = createVisiblePosition(nextVisuallyDistinctCandidate(position.position()), position.affinity());
 
     switch (rule) {
     case CanCrossEditingBoundary:
         return next;
     case CannotCrossEditingBoundary:
-        return honorEditingBoundaryAtOrAfter(next, visiblePosition.deepEquivalent());
+        return honorEditingBoundaryAtOrAfter(next, position.position());
     case CanSkipOverEditingBoundary:
-        return skipToEndOfEditingBoundary(next, visiblePosition.deepEquivalent());
+        return skipToEndOfEditingBoundary(next, position.position());
     }
     NOTREACHED();
-    return honorEditingBoundaryAtOrAfter(next, visiblePosition.deepEquivalent());
+    return honorEditingBoundaryAtOrAfter(next, position.position());
 }
 
 VisiblePosition nextPositionOf(const VisiblePosition& visiblePosition, EditingBoundaryCrossingRule rule)
 {
-    return nextPositionOfAlgorithm<EditingStrategy>(visiblePosition, rule);
+    DCHECK(visiblePosition.isValid()) << visiblePosition;
+    return nextPositionOfAlgorithm<EditingStrategy>(visiblePosition.toPositionWithAffinity(), rule);
 }
 
 VisiblePositionInFlatTree nextPositionOf(const VisiblePositionInFlatTree& visiblePosition, EditingBoundaryCrossingRule rule)
 {
-    return nextPositionOfAlgorithm<EditingInFlatTreeStrategy>(visiblePosition, rule);
+    DCHECK(visiblePosition.isValid()) << visiblePosition;
+    return nextPositionOfAlgorithm<EditingInFlatTreeStrategy>(visiblePosition.toPositionWithAffinity(), rule);
+}
+
+VisiblePosition nextPositionOfDeprecated(const VisiblePosition& visiblePosition, EditingBoundaryCrossingRule rule)
+{
+    if (visiblePosition.isNull())
+        return VisiblePosition();
+    visiblePosition.deepEquivalent().document()->updateStyleAndLayoutIgnorePendingStylesheets();
+    return nextPositionOfAlgorithm<EditingStrategy>(visiblePosition.toPositionWithAffinity(), rule);
+}
+
+VisiblePositionInFlatTree nextPositionOfDeprecated(const VisiblePositionInFlatTree& visiblePosition, EditingBoundaryCrossingRule rule)
+{
+    if (visiblePosition.isNull())
+        return VisiblePositionInFlatTree();
+    visiblePosition.deepEquivalent().document()->updateStyleAndLayoutIgnorePendingStylesheets();
+    return nextPositionOfAlgorithm<EditingInFlatTreeStrategy>(visiblePosition.toPositionWithAffinity(), rule);
 }
 
 template <typename Strategy>
@@ -3443,45 +3459,61 @@ static VisiblePositionTemplate<Strategy> skipToStartOfEditingBoundary(const Visi
 }
 
 template <typename Strategy>
-static VisiblePositionTemplate<Strategy> previousPositionOfAlgorithm(const VisiblePositionTemplate<Strategy>& visiblePosition, EditingBoundaryCrossingRule rule)
+static VisiblePositionTemplate<Strategy> previousPositionOfAlgorithm(const PositionTemplate<Strategy>& position, EditingBoundaryCrossingRule rule)
 {
-    // TODO(xiaochengh): Ensure that this function is called with a valid
-    // |visiblePosition|, and add |DCHECK(visiblePosition.isValid())|;
-    const PositionTemplate<Strategy> pos = previousVisuallyDistinctCandidate(visiblePosition.deepEquivalent());
+    const PositionTemplate<Strategy> prevPosition = previousVisuallyDistinctCandidate(position);
 
     // return null visible position if there is no previous visible position
-    if (pos.atStartOfTree())
+    if (prevPosition.atStartOfTree())
         return VisiblePositionTemplate<Strategy>();
 
     // we should always be able to make the affinity |TextAffinity::Downstream|,
     // because going previous from an |TextAffinity::Upstream| position can
     // never yield another |TextAffinity::Upstream position| (unless line wrap
     // length is 0!).
-    const VisiblePositionTemplate<Strategy> prev = createVisiblePositionDeprecated(pos);
-    if (prev.deepEquivalent() == visiblePosition.deepEquivalent())
+    const VisiblePositionTemplate<Strategy> prev = createVisiblePosition(prevPosition);
+    if (prev.deepEquivalent() == position)
         return VisiblePositionTemplate<Strategy>();
 
     switch (rule) {
     case CanCrossEditingBoundary:
         return prev;
     case CannotCrossEditingBoundary:
-        return honorEditingBoundaryAtOrBefore(prev, visiblePosition.deepEquivalent());
+        return honorEditingBoundaryAtOrBefore(prev, position);
     case CanSkipOverEditingBoundary:
-        return skipToStartOfEditingBoundary(prev, visiblePosition.deepEquivalent());
+        return skipToStartOfEditingBoundary(prev, position);
     }
 
     NOTREACHED();
-    return honorEditingBoundaryAtOrBefore(prev, visiblePosition.deepEquivalent());
+    return honorEditingBoundaryAtOrBefore(prev, position);
 }
 
 VisiblePosition previousPositionOf(const VisiblePosition& visiblePosition, EditingBoundaryCrossingRule rule)
 {
-    return previousPositionOfAlgorithm<EditingStrategy>(visiblePosition, rule);
+    DCHECK(visiblePosition.isValid()) << visiblePosition;
+    return previousPositionOfAlgorithm<EditingStrategy>(visiblePosition.deepEquivalent(), rule);
 }
 
 VisiblePositionInFlatTree previousPositionOf(const VisiblePositionInFlatTree& visiblePosition, EditingBoundaryCrossingRule rule)
 {
-    return previousPositionOfAlgorithm<EditingInFlatTreeStrategy>(visiblePosition, rule);
+    DCHECK(visiblePosition.isValid()) << visiblePosition;
+    return previousPositionOfAlgorithm<EditingInFlatTreeStrategy>(visiblePosition.deepEquivalent(), rule);
+}
+
+VisiblePosition previousPositionOfDeprecated(const VisiblePosition& visiblePosition, EditingBoundaryCrossingRule rule)
+{
+    if (visiblePosition.isNull())
+        return VisiblePosition();
+    visiblePosition.deepEquivalent().document()->updateStyleAndLayoutIgnorePendingStylesheets();
+    return previousPositionOfAlgorithm<EditingStrategy>(visiblePosition.deepEquivalent(), rule);
+}
+
+VisiblePositionInFlatTree previousPositionOfDeprecated(const VisiblePositionInFlatTree& visiblePosition, EditingBoundaryCrossingRule rule)
+{
+    if (visiblePosition.isNull())
+        return VisiblePositionInFlatTree();
+    visiblePosition.deepEquivalent().document()->updateStyleAndLayoutIgnorePendingStylesheets();
+    return previousPositionOfAlgorithm<EditingInFlatTreeStrategy>(visiblePosition.deepEquivalent(), rule);
 }
 
 } // namespace blink