Remove First/LastEditableVisiblePositionAfter/BeforePositionInRoot

The two functions are just wrappers of their non-canonical variants.
This patch removes them to decrease the usage of VisiblePosition.

Bug: 657237
Change-Id: If5e98e66724d45b2b02682f5a1a7d54b09ab73dd
Reviewed-on: https://chromium-review.googlesource.com/c/1306838Reviewed-by: Yoshifumi Inoue <yosin@chromium.org>
Commit-Queue: Xiaocheng Hu <xiaochengh@chromium.org>
Cr-Commit-Position: refs/heads/master@{#603787}

third_party/blink/renderer/core/editing/editing_utilities.cc

@@ -637,22 +637,6 @@ PositionInFlatTree PreviousVisuallyDistinctCandidate(
       position);
 }
 
-VisiblePosition FirstEditableVisiblePositionAfterPositionInRoot(
-    const Position& position,
-    ContainerNode& highest_root) {
-  DCHECK(!NeedsLayoutTreeUpdate(position));
-  return CreateVisiblePosition(
-      FirstEditablePositionAfterPositionInRoot(position, highest_root));
-}
-
-VisiblePositionInFlatTree FirstEditableVisiblePositionAfterPositionInRoot(
-    const PositionInFlatTree& position,
-    ContainerNode& highest_root) {
-  DCHECK(!NeedsLayoutTreeUpdate(position));
-  return CreateVisiblePosition(
-      FirstEditablePositionAfterPositionInRoot(position, highest_root));
-}
-
 template <typename Strategy>
 PositionTemplate<Strategy> FirstEditablePositionAfterPositionInRootAlgorithm(
     const PositionTemplate<Strategy>& position,
@@ -714,22 +698,6 @@ PositionInFlatTree FirstEditablePositionAfterPositionInRoot(
       EditingInFlatTreeStrategy>(position, highest_root);
 }
 
-VisiblePosition LastEditableVisiblePositionBeforePositionInRoot(
-    const Position& position,
-    ContainerNode& highest_root) {
-  DCHECK(!NeedsLayoutTreeUpdate(position));
-  return CreateVisiblePosition(
-      LastEditablePositionBeforePositionInRoot(position, highest_root));
-}
-
-VisiblePositionInFlatTree LastEditableVisiblePositionBeforePositionInRoot(
-    const PositionInFlatTree& position,
-    ContainerNode& highest_root) {
-  DCHECK(!NeedsLayoutTreeUpdate(position));
-  return CreateVisiblePosition(
-      LastEditablePositionBeforePositionInRoot(position, highest_root));
-}
-
 template <typename Strategy>
 PositionTemplate<Strategy> LastEditablePositionBeforePositionInRootAlgorithm(
     const PositionTemplate<Strategy>& position,

third_party/blink/renderer/core/editing/editing_utilities.h

@@ -266,26 +266,6 @@ Position ComputePositionForNodeRemoval(const Position&, const Node&);
 
 // Functions returning VisiblePosition
 
-// TODO(yosin) We should rename
-// |firstEditableVisiblePositionAfterPositionInRoot()| to a better name which
-// describes what this function returns, since it returns a position before
-// specified position due by canonicalization.
-CORE_EXPORT VisiblePosition
-FirstEditableVisiblePositionAfterPositionInRoot(const Position&,
-                                                ContainerNode&);
-CORE_EXPORT VisiblePositionInFlatTree
-FirstEditableVisiblePositionAfterPositionInRoot(const PositionInFlatTree&,
-                                                ContainerNode&);
-// TODO(yosin) We should rename
-// |lastEditableVisiblePositionBeforePositionInRoot()| to a better name which
-// describes what this function returns, since it returns a position after
-// specified position due by canonicalization.
-CORE_EXPORT VisiblePosition
-LastEditableVisiblePositionBeforePositionInRoot(const Position&,
-                                                ContainerNode&);
-CORE_EXPORT VisiblePositionInFlatTree
-LastEditableVisiblePositionBeforePositionInRoot(const PositionInFlatTree&,
-                                                ContainerNode&);
 CORE_EXPORT VisiblePosition VisiblePositionBeforeNode(const Node&);
 VisiblePosition VisiblePositionAfterNode(const Node&);
 

third_party/blink/renderer/core/editing/editing_utilities_test.cc

@@ -42,32 +42,32 @@ TEST_F(EditingUtilitiesTest, firstEditablePositionAfterPositionInRoot) {
 
   EXPECT_EQ(Position(one, 0),
             FirstEditablePositionAfterPositionInRoot(Position(one, 0), *host));
-  EXPECT_EQ(
-      Position(one->firstChild(), 0),
-      FirstEditableVisiblePositionAfterPositionInRoot(Position(one, 0), *host)
-          .DeepEquivalent());
+  EXPECT_EQ(Position(one->firstChild(), 0),
+            CreateVisiblePosition(FirstEditablePositionAfterPositionInRoot(
+                                      Position(one, 0), *host))
+                .DeepEquivalent());
 
   EXPECT_EQ(PositionInFlatTree(one, 0),
             FirstEditablePositionAfterPositionInRoot(PositionInFlatTree(one, 0),
                                                      *host));
   EXPECT_EQ(PositionInFlatTree(two->firstChild(), 2),
-            FirstEditableVisiblePositionAfterPositionInRoot(
-                PositionInFlatTree(one, 0), *host)
+            CreateVisiblePosition(FirstEditablePositionAfterPositionInRoot(
+                                      PositionInFlatTree(one, 0), *host))
                 .DeepEquivalent());
 
   EXPECT_EQ(
       Position::FirstPositionInNode(*host),
       FirstEditablePositionAfterPositionInRoot(Position(three, 0), *host));
-  EXPECT_EQ(
-      Position(one->firstChild(), 0),
-      FirstEditableVisiblePositionAfterPositionInRoot(Position(three, 0), *host)
-          .DeepEquivalent());
+  EXPECT_EQ(Position(one->firstChild(), 0),
+            CreateVisiblePosition(FirstEditablePositionAfterPositionInRoot(
+                                      Position(three, 0), *host))
+                .DeepEquivalent());
   EXPECT_EQ(PositionInFlatTree::AfterNode(*host),
             FirstEditablePositionAfterPositionInRoot(
                 PositionInFlatTree(three, 0), *host));
   EXPECT_EQ(PositionInFlatTree::LastPositionInNode(*host),
-            FirstEditableVisiblePositionAfterPositionInRoot(
-                PositionInFlatTree(three, 0), *host)
+            CreateVisiblePosition(FirstEditablePositionAfterPositionInRoot(
+                                      PositionInFlatTree(three, 0), *host))
                 .DeepEquivalent());
 }
 
@@ -194,32 +194,32 @@ TEST_F(EditingUtilitiesTest, lastEditablePositionBeforePositionInRoot) {
 
   EXPECT_EQ(Position(one, 0),
             LastEditablePositionBeforePositionInRoot(Position(one, 0), *host));
-  EXPECT_EQ(
-      Position(one->firstChild(), 0),
-      LastEditableVisiblePositionBeforePositionInRoot(Position(one, 0), *host)
-          .DeepEquivalent());
+  EXPECT_EQ(Position(one->firstChild(), 0),
+            CreateVisiblePosition(LastEditablePositionBeforePositionInRoot(
+                                      Position(one, 0), *host))
+                .DeepEquivalent());
 
   EXPECT_EQ(PositionInFlatTree(one, 0),
             LastEditablePositionBeforePositionInRoot(PositionInFlatTree(one, 0),
                                                      *host));
   EXPECT_EQ(PositionInFlatTree(two->firstChild(), 2),
-            LastEditableVisiblePositionBeforePositionInRoot(
-                PositionInFlatTree(one, 0), *host)
+            CreateVisiblePosition(LastEditablePositionBeforePositionInRoot(
+                                      PositionInFlatTree(one, 0), *host))
                 .DeepEquivalent());
 
   EXPECT_EQ(
       Position::FirstPositionInNode(*host),
       LastEditablePositionBeforePositionInRoot(Position(three, 0), *host));
-  EXPECT_EQ(
-      Position(one->firstChild(), 0),
-      LastEditableVisiblePositionBeforePositionInRoot(Position(three, 0), *host)
-          .DeepEquivalent());
+  EXPECT_EQ(Position(one->firstChild(), 0),
+            CreateVisiblePosition(LastEditablePositionBeforePositionInRoot(
+                                      Position(three, 0), *host))
+                .DeepEquivalent());
   EXPECT_EQ(PositionInFlatTree::FirstPositionInNode(*host),
             LastEditablePositionBeforePositionInRoot(
                 PositionInFlatTree(three, 0), *host));
   EXPECT_EQ(PositionInFlatTree(two->firstChild(), 0),
-            LastEditableVisiblePositionBeforePositionInRoot(
-                PositionInFlatTree(three, 0), *host)
+            CreateVisiblePosition(LastEditablePositionBeforePositionInRoot(
+                                      PositionInFlatTree(three, 0), *host))
                 .DeepEquivalent());
 }
 

third_party/blink/renderer/core/editing/spellcheck/spell_checker.cc

@@ -163,8 +163,9 @@ void SpellChecker::AdvanceToNextMisspelling(bool start_before_selection) {
 
     if (!GetFrame().GetDocument()->documentElement())
       return;
-    position = FirstEditableVisiblePositionAfterPositionInRoot(
-                   position, *GetFrame().GetDocument()->documentElement())
+    position = CreateVisiblePosition(
+                   FirstEditablePositionAfterPositionInRoot(
+                       position, *GetFrame().GetDocument()->documentElement()))
                    .DeepEquivalent();
     if (position.IsNull())
       return;

third_party/blink/renderer/core/editing/visible_units.cc

@@ -1079,8 +1079,8 @@ static VisiblePositionTemplate<Strategy> SkipToEndOfEditingBoundary(
   // That must mean that |pos| is not editable. Return the next position after
   // |pos| that is in the same editable region as this position
   DCHECK(highest_root);
-  return FirstEditableVisiblePositionAfterPositionInRoot(pos.DeepEquivalent(),
-                                                         *highest_root);
+  return CreateVisiblePosition(FirstEditablePositionAfterPositionInRoot(
+      pos.DeepEquivalent(), *highest_root));
 }
 
 template <typename Strategy>
@@ -1193,8 +1193,8 @@ static VisiblePositionTemplate<Strategy> SkipToStartOfEditingBoundary(
   // That must mean that |pos| is not editable. Return the last position
   // before |pos| that is in the same editable region as this position
   DCHECK(highest_root);
-  return LastEditableVisiblePositionBeforePositionInRoot(pos.DeepEquivalent(),
-                                                         *highest_root);
+  return CreateVisiblePosition(LastEditablePositionBeforePositionInRoot(
+      pos.DeepEquivalent(), *highest_root));
 }
 
 template <typename Strategy>