Rename VisibleSelection::end() to End()

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

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "core/editing/VisibleSelection.h"
 
 #include "core/dom/Range.h"
 #include "core/editing/EditingTestBase.h"
 #include "core/editing/SelectionAdjuster.h"
 
@@ skipping 35 matching lines @@
 };
 
 static void TestFlatTreePositionsToEqualToDOMTreePositions(
     const VisibleSelection& selection,
     const VisibleSelectionInFlatTree& selection_in_flat_tree) {
   // Since DOM tree positions can't be map to flat tree version, e.g.
   // shadow root, not distributed node, we map a position in flat tree
   // to DOM tree position.
   EXPECT_EQ(selection.Start(),
             ToPositionInDOMTree(selection_in_flat_tree.Start()));
-  EXPECT_EQ(selection.end(), ToPositionInDOMTree(selection_in_flat_tree.end()));
+  EXPECT_EQ(selection.End(), ToPositionInDOMTree(selection_in_flat_tree.End()));
   EXPECT_EQ(selection.Base(),
             ToPositionInDOMTree(selection_in_flat_tree.Base()));
   EXPECT_EQ(selection.Extent(),
             ToPositionInDOMTree(selection_in_flat_tree.Extent()));
 }
 
 template <typename Strategy>
 VisibleSelectionTemplate<Strategy> ExpandUsingGranularity(
     const VisibleSelectionTemplate<Strategy>& selection,
     TextGranularity granularity) {
@@ skipping 17 matching lines @@
   // compute selection.
   VisibleSelection selection =
       CreateVisibleSelection(SelectionInDOMTree::Builder()
                                  .Collapse(Position::BeforeNode(input))
                                  .Extend(Position::AfterNode(input))
                                  .SetGranularity(kWordGranularity)
                                  .Build());
   selection.AppendTrailingWhitespace();
 
   EXPECT_EQ(Position::BeforeNode(input), selection.Start());
-  EXPECT_EQ(Position::AfterNode(input), selection.end());
+  EXPECT_EQ(Position::AfterNode(input), selection.End());
 }
 
 TEST_F(VisibleSelectionTest, expandUsingGranularity) {
   const char* body_content =
       "<span id=host><a id=one>1</a><a id=two>22</a></span>";
   const char* shadow_content =
       "<p><b id=three>333</b><content select=#two></content><b "
       "id=four>4444</b><span id=space>  </span><content "
       "select=#one></content><b id=five>55555</b></p>";
   SetBodyContent(body_content);
@@ skipping 15 matching lines @@
   selection_in_flat_tree =
       CreateVisibleSelection(SelectionInFlatTree::Builder()
                                  .Collapse(PositionInFlatTree(one, 1))
                                  .Build());
   selection_in_flat_tree =
       ExpandUsingGranularity(selection_in_flat_tree, kWordGranularity);
 
   EXPECT_EQ(Position(one, 1), selection.Base());
   EXPECT_EQ(Position(one, 1), selection.Extent());
   EXPECT_EQ(Position(one, 0), selection.Start());
-  EXPECT_EQ(Position(two, 2), selection.end());
+  EXPECT_EQ(Position(two, 2), selection.End());
 
   EXPECT_EQ(PositionInFlatTree(one, 1), selection_in_flat_tree.Base());
   EXPECT_EQ(PositionInFlatTree(one, 1), selection_in_flat_tree.Extent());
   EXPECT_EQ(PositionInFlatTree(one, 0), selection_in_flat_tree.Start());
-  EXPECT_EQ(PositionInFlatTree(five, 5), selection_in_flat_tree.end());
+  EXPECT_EQ(PositionInFlatTree(five, 5), selection_in_flat_tree.End());
 
   // From a position at distributed node
   selection = CreateVisibleSelection(
       SelectionInDOMTree::Builder().Collapse(Position(two, 1)).Build());
   selection = ExpandUsingGranularity(selection, kWordGranularity);
   selection_in_flat_tree =
       CreateVisibleSelection(SelectionInFlatTree::Builder()
                                  .Collapse(PositionInFlatTree(two, 1))
                                  .Build());
   selection_in_flat_tree =
       ExpandUsingGranularity(selection_in_flat_tree, kWordGranularity);
 
   EXPECT_EQ(Position(two, 1), selection.Base());
   EXPECT_EQ(Position(two, 1), selection.Extent());
   EXPECT_EQ(Position(one, 0), selection.Start());
-  EXPECT_EQ(Position(two, 2), selection.end());
+  EXPECT_EQ(Position(two, 2), selection.End());
 
   EXPECT_EQ(PositionInFlatTree(two, 1), selection_in_flat_tree.Base());
   EXPECT_EQ(PositionInFlatTree(two, 1), selection_in_flat_tree.Extent());
   EXPECT_EQ(PositionInFlatTree(three, 0), selection_in_flat_tree.Start());
-  EXPECT_EQ(PositionInFlatTree(four, 4), selection_in_flat_tree.end());
+  EXPECT_EQ(PositionInFlatTree(four, 4), selection_in_flat_tree.End());
 
   // From a position at node in shadow tree
   selection = CreateVisibleSelection(
       SelectionInDOMTree::Builder().Collapse(Position(three, 1)).Build());
   selection = ExpandUsingGranularity(selection, kWordGranularity);
   selection_in_flat_tree =
       CreateVisibleSelection(SelectionInFlatTree::Builder()
                                  .Collapse(PositionInFlatTree(three, 1))
                                  .Build());
   selection_in_flat_tree =
       ExpandUsingGranularity(selection_in_flat_tree, kWordGranularity);
 
   EXPECT_EQ(Position(three, 1), selection.Base());
   EXPECT_EQ(Position(three, 1), selection.Extent());
   EXPECT_EQ(Position(three, 0), selection.Start());
-  EXPECT_EQ(Position(four, 4), selection.end());
+  EXPECT_EQ(Position(four, 4), selection.End());
 
   EXPECT_EQ(PositionInFlatTree(three, 1), selection_in_flat_tree.Base());
   EXPECT_EQ(PositionInFlatTree(three, 1), selection_in_flat_tree.Extent());
   EXPECT_EQ(PositionInFlatTree(three, 0), selection_in_flat_tree.Start());
-  EXPECT_EQ(PositionInFlatTree(four, 4), selection_in_flat_tree.end());
+  EXPECT_EQ(PositionInFlatTree(four, 4), selection_in_flat_tree.End());
 
   // From a position at node in shadow tree
   selection = CreateVisibleSelection(
       SelectionInDOMTree::Builder().Collapse(Position(four, 1)).Build());
   selection = ExpandUsingGranularity(selection, kWordGranularity);
   selection_in_flat_tree =
       CreateVisibleSelection(SelectionInFlatTree::Builder()
                                  .Collapse(PositionInFlatTree(four, 1))
                                  .Build());
   selection_in_flat_tree =
       ExpandUsingGranularity(selection_in_flat_tree, kWordGranularity);
 
   EXPECT_EQ(Position(four, 1), selection.Base());
   EXPECT_EQ(Position(four, 1), selection.Extent());
   EXPECT_EQ(Position(three, 0), selection.Start());
-  EXPECT_EQ(Position(four, 4), selection.end());
+  EXPECT_EQ(Position(four, 4), selection.End());
 
   EXPECT_EQ(PositionInFlatTree(four, 1), selection_in_flat_tree.Base());
   EXPECT_EQ(PositionInFlatTree(four, 1), selection_in_flat_tree.Extent());
   EXPECT_EQ(PositionInFlatTree(three, 0), selection_in_flat_tree.Start());
-  EXPECT_EQ(PositionInFlatTree(four, 4), selection_in_flat_tree.end());
+  EXPECT_EQ(PositionInFlatTree(four, 4), selection_in_flat_tree.End());
 
   // From a position at node in shadow tree
   selection = CreateVisibleSelection(
       SelectionInDOMTree::Builder().Collapse(Position(five, 1)).Build());
   selection = ExpandUsingGranularity(selection, kWordGranularity);
   selection_in_flat_tree =
       CreateVisibleSelection(SelectionInFlatTree::Builder()
                                  .Collapse(PositionInFlatTree(five, 1))
                                  .Build());
   selection_in_flat_tree =
       ExpandUsingGranularity(selection_in_flat_tree, kWordGranularity);
 
   EXPECT_EQ(Position(five, 1), selection.Base());
   EXPECT_EQ(Position(five, 1), selection.Extent());
   EXPECT_EQ(Position(five, 0), selection.Start());
-  EXPECT_EQ(Position(five, 5), selection.end());
+  EXPECT_EQ(Position(five, 5), selection.End());
 
   EXPECT_EQ(PositionInFlatTree(five, 1), selection_in_flat_tree.Base());
   EXPECT_EQ(PositionInFlatTree(five, 1), selection_in_flat_tree.Extent());
   EXPECT_EQ(PositionInFlatTree(one, 0), selection_in_flat_tree.Start());
-  EXPECT_EQ(PositionInFlatTree(five, 5), selection_in_flat_tree.end());
+  EXPECT_EQ(PositionInFlatTree(five, 5), selection_in_flat_tree.End());
 }
 
 TEST_F(VisibleSelectionTest, Initialisation) {
   SetBodyContent(LOREM_IPSUM);
 
   VisibleSelection selection;
   VisibleSelectionInFlatTree selection_in_flat_tree;
   SetSelection(selection, 0);
   SetSelection(selection_in_flat_tree, 0);
 
@@ skipping 66 matching lines @@
           .Extend(Position::LastPositionInNode(shadow_root))
           .Build());
   VisibleSelectionInFlatTree selection_in_flat_tree = CreateVisibleSelection(
       SelectionInFlatTree::Builder()
           .Collapse(PositionInFlatTree::FirstPositionInNode(one))
           .Extend(PositionInFlatTree::LastPositionInNode(host))
           .Build());
 
   EXPECT_EQ(Position(host, PositionAnchorType::kBeforeAnchor),
             selection.Start());
-  EXPECT_EQ(Position(one->firstChild(), 0), selection.end());
+  EXPECT_EQ(Position(one->firstChild(), 0), selection.End());
   EXPECT_EQ(PositionInFlatTree(one->firstChild(), 0),
             selection_in_flat_tree.Start());
   EXPECT_EQ(PositionInFlatTree(six->firstChild(), 2),
-            selection_in_flat_tree.end());
+            selection_in_flat_tree.End());
 }
 
 TEST_F(VisibleSelectionTest, ShadowV0DistributedNodes) {
   const char* body_content =
       "<p id='host'>00<b id='one'>11</b><b id='two'>22</b>33</p>";
   const char* shadow_content =
       "<a><span id='s4'>44</span><content select=#two></content><span "
       "id='s5'>55</span><content select=#one></content><span "
       "id='s6'>66</span></a>";
   SetBodyContent(body_content);
   ShadowRoot* shadow_root = SetShadowContent(shadow_content, "host");
 
   Element* body = GetDocument().body();
   Element* one = body->QuerySelector("#one");
   Element* two = body->QuerySelector("#two");
   Element* five = shadow_root->QuerySelector("#s5");
 
   VisibleSelection selection =
       CreateVisibleSelection(SelectionInDOMTree::Builder()
                                  .Collapse(Position::FirstPositionInNode(one))
                                  .Extend(Position::LastPositionInNode(two))
                                  .Build());
   VisibleSelectionInFlatTree selection_in_flat_tree = CreateVisibleSelection(
       SelectionInFlatTree::Builder()
           .Collapse(PositionInFlatTree::FirstPositionInNode(one))
           .Extend(PositionInFlatTree::LastPositionInNode(two))
           .Build());
 
   EXPECT_EQ(Position(one->firstChild(), 0), selection.Start());
-  EXPECT_EQ(Position(two->firstChild(), 2), selection.end());
+  EXPECT_EQ(Position(two->firstChild(), 2), selection.End());
   EXPECT_EQ(PositionInFlatTree(five->firstChild(), 0),
             selection_in_flat_tree.Start());
   EXPECT_EQ(PositionInFlatTree(five->firstChild(), 2),
-            selection_in_flat_tree.end());
+            selection_in_flat_tree.End());
 }
 
 TEST_F(VisibleSelectionTest, ShadowNested) {
   const char* body_content =
       "<p id='host'>00<b id='one'>11</b><b id='two'>22</b>33</p>";
   const char* shadow_content =
       "<a><span id='s4'>44</span><content select=#two></content><span "
       "id='s5'>55</span><content select=#one></content><span "
       "id='s6'>66</span></a>";
   const char* shadow_content2 =
@@ skipping 22 matching lines @@
           .Extend(Position::LastPositionInNode(shadow_root2))
           .Build());
   VisibleSelectionInFlatTree selection_in_flat_tree = CreateVisibleSelection(
       SelectionInFlatTree::Builder()
           .Collapse(PositionInFlatTree::FirstPositionInNode(one))
           .Extend(PositionInFlatTree::AfterNode(eight))
           .Build());
 
   EXPECT_EQ(Position(host, PositionAnchorType::kBeforeAnchor),
             selection.Start());
-  EXPECT_EQ(Position(one->firstChild(), 0), selection.end());
+  EXPECT_EQ(Position(one->firstChild(), 0), selection.End());
   EXPECT_EQ(PositionInFlatTree(eight->firstChild(), 2),
             selection_in_flat_tree.Start());
   EXPECT_EQ(PositionInFlatTree(eight->firstChild(), 2),
-            selection_in_flat_tree.end());
+            selection_in_flat_tree.End());
 }
 
 TEST_F(VisibleSelectionTest, WordGranularity) {
   SetBodyContent(LOREM_IPSUM);
 
   VisibleSelection selection;
   VisibleSelectionInFlatTree selection_in_flat_tree;
 
   // Beginning of a word.
   {
@@ skipping 130 matching lines @@
   Element* host = GetDocument().getElementById("host");
   host->AppendChild(sample);
   GetDocument().UpdateStyleAndLayout();
 
   // Simulates to restore selection from undo stack.
   selection = CreateVisibleSelection(selection.AsSelection());
   EXPECT_EQ(Position(sample->firstChild(), 0), selection.Start());
 }
 
 }  // namespace blink