Mark paragraph-related functions deprecated in VisibleUnits

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

 /*
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009 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 1592 matching lines @@
 
     if (candidateType == PositionAnchorType::OffsetInAnchor)
         return PositionTemplate<Strategy>(candidateNode, candidateOffset);
 
     return PositionTemplate<Strategy>(candidateNode, candidateType);
 }
 
 template <typename Strategy>
 VisiblePositionTemplate<Strategy> startOfParagraphAlgorithm(const VisiblePositionTemplate<Strategy>& visiblePosition, EditingBoundaryCrossingRule boundaryCrossingRule)
 {
-    // TODO(xiaochengh): Ensure that this function is called with a valid
-    // |visiblePosition|, and add |DCHECK(visiblePosition.isValid())|;
-    return createVisiblePositionDeprecated(startOfParagraphAlgorithm(visiblePosition.deepEquivalent(), boundaryCrossingRule));
+    DCHECK(visiblePosition.isValid());
+    return createVisiblePosition(startOfParagraphAlgorithm(visiblePosition.deepEquivalent(), boundaryCrossingRule));
 }
 
 VisiblePosition startOfParagraph(const VisiblePosition& c, EditingBoundaryCrossingRule boundaryCrossingRule)
 {
     return startOfParagraphAlgorithm<EditingStrategy>(c, boundaryCrossingRule);
 }
 
 VisiblePositionInFlatTree startOfParagraph(const VisiblePositionInFlatTree& c, EditingBoundaryCrossingRule boundaryCrossingRule)
 {
     return startOfParagraphAlgorithm<EditingInFlatTreeStrategy>(c, boundaryCrossingRule);
 }
 
 template <typename Strategy>
+VisiblePositionTemplate<Strategy> startOfParagraphAlgorithmDeprecated(const VisiblePositionTemplate<Strategy>& visiblePosition, EditingBoundaryCrossingRule boundaryCrossingRule)
+{
+    return createVisiblePositionDeprecated(startOfParagraphAlgorithm(visiblePosition.deepEquivalent(), boundaryCrossingRule));
+}
+
+VisiblePosition startOfParagraphDeprecated(const VisiblePosition& c, EditingBoundaryCrossingRule boundaryCrossingRule)
+{
+    return startOfParagraphAlgorithmDeprecated<EditingStrategy>(c, boundaryCrossingRule);
+}
+
+VisiblePositionInFlatTree startOfParagraphDeprecated(const VisiblePositionInFlatTree& c, EditingBoundaryCrossingRule boundaryCrossingRule)
+{
+    return startOfParagraphAlgorithmDeprecated<EditingInFlatTreeStrategy>(c, boundaryCrossingRule);
+}
+
+template <typename Strategy>
 static PositionTemplate<Strategy> endOfParagraphAlgorithm(const PositionTemplate<Strategy>& position, EditingBoundaryCrossingRule boundaryCrossingRule)
 {
     Node* const startNode = position.anchorNode();
 
     if (!startNode)
         return PositionTemplate<Strategy>();
 
     if (isRenderedAsNonInlineTableImageOrHR(startNode))
         return PositionTemplate<Strategy>::afterNode(startNode);
 
@@ skipping 57 matching lines @@
 
     if (candidateType == PositionAnchorType::OffsetInAnchor)
         return PositionTemplate<Strategy>(candidateNode, candidateOffset);
 
     return PositionTemplate<Strategy>(candidateNode, candidateType);
 }
 
 template <typename Strategy>
 static VisiblePositionTemplate<Strategy> endOfParagraphAlgorithm(const VisiblePositionTemplate<Strategy>& visiblePosition, EditingBoundaryCrossingRule boundaryCrossingRule)
 {
-    // TODO(xiaochengh): Ensure that this function is called with a valid
-    // |visiblePosition|, and add |DCHECK(visiblePosition.isValid())|;
+    DCHECK(visiblePosition.isValid());
     return createVisiblePositionDeprecated(endOfParagraphAlgorithm(visiblePosition.deepEquivalent(), boundaryCrossingRule));
 }
 
 VisiblePosition endOfParagraph(const VisiblePosition& c, EditingBoundaryCrossingRule boundaryCrossingRule)
 {
     return endOfParagraphAlgorithm<EditingStrategy>(c, boundaryCrossingRule);
 }
 
 VisiblePositionInFlatTree endOfParagraph(const VisiblePositionInFlatTree& c, EditingBoundaryCrossingRule boundaryCrossingRule)
 {
     return endOfParagraphAlgorithm<EditingInFlatTreeStrategy>(c, boundaryCrossingRule);
 }
 
+template <typename Strategy>
+static VisiblePositionTemplate<Strategy> endOfParagraphAlgorithmDeprecated(const VisiblePositionTemplate<Strategy>& visiblePosition, EditingBoundaryCrossingRule boundaryCrossingRule)
+{
+    return createVisiblePositionDeprecated(endOfParagraphAlgorithm(visiblePosition.deepEquivalent(), boundaryCrossingRule));
+}
+
+VisiblePosition endOfParagraphDeprecated(const VisiblePosition& c, EditingBoundaryCrossingRule boundaryCrossingRule)
+{
+    return endOfParagraphAlgorithmDeprecated<EditingStrategy>(c, boundaryCrossingRule);
+}
+
+VisiblePositionInFlatTree endOfParagraphDeprecated(const VisiblePositionInFlatTree& c, EditingBoundaryCrossingRule boundaryCrossingRule)
+{
+    return endOfParagraphAlgorithmDeprecated<EditingInFlatTreeStrategy>(c, boundaryCrossingRule);
+}
+
 // FIXME: isStartOfParagraph(startOfNextParagraph(pos)) is not always true
 VisiblePosition startOfNextParagraph(const VisiblePosition& visiblePosition)
 {
+    DCHECK(visiblePosition.isValid());
     VisiblePosition paragraphEnd(endOfParagraph(visiblePosition, CanSkipOverEditingBoundary));
     VisiblePosition afterParagraphEnd(nextPositionOf(paragraphEnd, CannotCrossEditingBoundary));
     // The position after the last position in the last cell of a table
     // is not the start of the next paragraph.
     if (tableElementJustBefore(afterParagraphEnd))
         return nextPositionOf(afterParagraphEnd, CannotCrossEditingBoundary);
     return afterParagraphEnd;
 }
 
+// FIXME: isStartOfParagraph(startOfNextParagraph(pos)) is not always true
+VisiblePosition startOfNextParagraphDeprecated(const VisiblePosition& visiblePosition)
+{
+    VisiblePosition paragraphEnd(endOfParagraphDeprecated(visiblePosition, CanSkipOverEditingBoundary));
+    VisiblePosition afterParagraphEnd(nextPositionOf(paragraphEnd, CannotCrossEditingBoundary));
+    // The position after the last position in the last cell of a table
+    // is not the start of the next paragraph.
+    if (tableElementJustBefore(afterParagraphEnd))
+        return nextPositionOf(afterParagraphEnd, CannotCrossEditingBoundary);
+    return afterParagraphEnd;
+}
+
 bool inSameParagraph(const VisiblePosition& a, const VisiblePosition& b, EditingBoundaryCrossingRule boundaryCrossingRule)
 {
+    DCHECK(a.isValid());

[yosin_UTC9, 2016/09/26 01:29:09]

nit: Could you add "<< a" for ease of debug?

[Xiaocheng, 2016/09/26 01:36:14]

I'm thinking about having a scope that asserts VP::isValid at the beginning and
disallows document lifecycle's transition within the scope. Then we can replace
basically all existing checks of VP::isValid with this scope.

WDYT?

+    DCHECK(b.isValid());

[yosin_UTC9, 2016/09/26 01:29:09]

nit: Could you add "<< b" for ease of debug?

     return a.isNotNull() && startOfParagraph(a, boundaryCrossingRule).deepEquivalent() == startOfParagraph(b, boundaryCrossingRule).deepEquivalent();
 }
 
+bool inSameParagraphDeprecated(const VisiblePosition& a, const VisiblePosition& b, EditingBoundaryCrossingRule boundaryCrossingRule)
+{
+    return a.isNotNull() && startOfParagraphDeprecated(a, boundaryCrossingRule).deepEquivalent() == startOfParagraphDeprecated(b, boundaryCrossingRule).deepEquivalent();
+}
+
 template <typename Strategy>
 static bool isStartOfParagraphAlgorithm(const VisiblePositionTemplate<Strategy>& pos, EditingBoundaryCrossingRule boundaryCrossingRule)
 {
+    DCHECK(pos.isValid());

[yosin_UTC9, 2016/09/26 01:29:09]

nit: Could you add "<< pos" for ease of debugging?

     return pos.isNotNull() && pos.deepEquivalent() == startOfParagraph(pos, boundaryCrossingRule).deepEquivalent();
 }
 
 bool isStartOfParagraph(const VisiblePosition& pos, EditingBoundaryCrossingRule boundaryCrossingRule)
 {
     return isStartOfParagraphAlgorithm<EditingStrategy>(pos, boundaryCrossingRule);
 }
 
 bool isStartOfParagraph(const VisiblePositionInFlatTree& pos, EditingBoundaryCrossingRule boundaryCrossingRule)
 {
     return isStartOfParagraphAlgorithm<EditingInFlatTreeStrategy>(pos, boundaryCrossingRule);
 }
 
 template <typename Strategy>
+static bool isStartOfParagraphAlgorithmDeprecated(const VisiblePositionTemplate<Strategy>& pos, EditingBoundaryCrossingRule boundaryCrossingRule)
+{
+    return pos.isNotNull() && pos.deepEquivalent() == startOfParagraphDeprecated(pos, boundaryCrossingRule).deepEquivalent();
+}
+
+bool isStartOfParagraphDeprecated(const VisiblePosition& pos, EditingBoundaryCrossingRule boundaryCrossingRule)
+{
+    return isStartOfParagraphAlgorithmDeprecated<EditingStrategy>(pos, boundaryCrossingRule);
+}
+
+bool isStartOfParagraphDeprecated(const VisiblePositionInFlatTree& pos, EditingBoundaryCrossingRule boundaryCrossingRule)
+{
+    return isStartOfParagraphAlgorithmDeprecated<EditingInFlatTreeStrategy>(pos, boundaryCrossingRule);
+}
+
+template <typename Strategy>
 static bool isEndOfParagraphAlgorithm(const VisiblePositionTemplate<Strategy>& pos, EditingBoundaryCrossingRule boundaryCrossingRule)
 {
+    DCHECK(pos.isValid());
     return pos.isNotNull() && pos.deepEquivalent() == endOfParagraph(pos, boundaryCrossingRule).deepEquivalent();
 }
 
 bool isEndOfParagraph(const VisiblePosition& pos, EditingBoundaryCrossingRule boundaryCrossingRule)
 {
     return isEndOfParagraphAlgorithm<EditingStrategy>(pos, boundaryCrossingRule);
 }
 
 bool isEndOfParagraph(const VisiblePositionInFlatTree& pos, EditingBoundaryCrossingRule boundaryCrossingRule)
 {
     return isEndOfParagraphAlgorithm<EditingInFlatTreeStrategy>(pos, boundaryCrossingRule);
 }
 
+template <typename Strategy>
+static bool isEndOfParagraphAlgorithmDeprecated(const VisiblePositionTemplate<Strategy>& pos, EditingBoundaryCrossingRule boundaryCrossingRule)
+{
+    return pos.isNotNull() && pos.deepEquivalent() == endOfParagraphDeprecated(pos, boundaryCrossingRule).deepEquivalent();
+}
+
+bool isEndOfParagraphDeprecated(const VisiblePosition& pos, EditingBoundaryCrossingRule boundaryCrossingRule)
+{
+    return isEndOfParagraphAlgorithmDeprecated<EditingStrategy>(pos, boundaryCrossingRule);
+}
+
+bool isEndOfParagraphDeprecated(const VisiblePositionInFlatTree& pos, EditingBoundaryCrossingRule boundaryCrossingRule)
+{
+    return isEndOfParagraphAlgorithmDeprecated<EditingInFlatTreeStrategy>(pos, boundaryCrossingRule);
+}
+
 VisiblePosition previousParagraphPosition(const VisiblePosition& p, LayoutUnit x)
 {
     VisiblePosition pos = p;
     do {
         VisiblePosition n = previousLinePosition(pos, x);
         if (n.isNull() || n.deepEquivalent() == pos.deepEquivalent())
             break;
         pos = n;
     } while (inSameParagraph(p, pos));
     return pos;
@@ skipping 1564 matching lines @@
 {
     return previousPositionOfAlgorithm<EditingStrategy>(visiblePosition, rule);
 }
 
 VisiblePositionInFlatTree previousPositionOf(const VisiblePositionInFlatTree& visiblePosition, EditingBoundaryCrossingRule rule)
 {
     return previousPositionOfAlgorithm<EditingInFlatTreeStrategy>(visiblePosition, rule);
 }
 
 } // namespace blink