MacViews: Fix behavior of move and select commands when selection direction changes.

ui/gfx/render_text_unittest.cc

 // Copyright (c) 2012 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 "ui/gfx/render_text.h"
 
 #include <limits.h>
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 91 matching lines @@
                                     render_text->selection().length());
 }
 
 // A test utility function to set the application default text direction.
 void SetRTL(bool rtl) {
   // Override the current locale/direction.
   base::i18n::SetICUDefaultLocale(rtl ? "he" : "en");
   EXPECT_EQ(rtl, base::i18n::IsRTL());
 }
 
+// Execute MoveCursor on the given |render_text| instance for the given
+// arguments and verify the selected range matches |expected|. Also, clears the
+// expectations.
+void RunMoveCursorTestAndClearExpectations(RenderText* render_text,
+                                           BreakType break_type,
+                                           VisualCursorDirection direction,
+                                           SelectionBehavior selection_behavior,
+                                           std::vector<Range>* expected) {
+  for (size_t i = 0; i < expected->size(); ++i) {
+    SCOPED_TRACE(base::StringPrintf(
+        "BreakType-%d VisualCursorDirection-%d SelectionBehavior-%d Case-%d.",
+        break_type, direction, selection_behavior, static_cast<int>(i)));
+
+    render_text->MoveCursor(break_type, direction, selection_behavior);
+    EXPECT_EQ(expected->at(i), render_text->selection());
+  }
+  expected->clear();
+}
+
 // TODO(asvitkine): RenderTextMac cursor movements. http://crbug.com/131618
 #if !defined(OS_MACOSX)
 // Ensure cursor movement in the specified |direction| yields |expected| values.
 void RunMoveCursorLeftRightTest(RenderText* render_text,
                                 const std::vector<SelectionModel>& expected,
                                 VisualCursorDirection direction) {
   for (size_t i = 0; i < expected.size(); ++i) {
     SCOPED_TRACE(base::StringPrintf("Going %s; expected value index %d.",
         direction == CURSOR_LEFT ? "left" : "right", static_cast<int>(i)));
     EXPECT_EQ(expected[i], render_text->selection_model());
-    render_text->MoveCursor(CHARACTER_BREAK, direction, false);
+    render_text->MoveCursor(CHARACTER_BREAK, direction, SELECTION_NONE);
   }
   // Check that cursoring is clamped at the line edge.
   EXPECT_EQ(expected.back(), render_text->selection_model());
   // Check that it is the line edge.
-  render_text->MoveCursor(LINE_BREAK, direction, false);
+  render_text->MoveCursor(LINE_BREAK, direction, SELECTION_NONE);
   EXPECT_EQ(expected.back(), render_text->selection_model());
 }
 #endif  // !defined(OS_MACOSX)
 
 // The class which records the drawing operations so that the test case can
 // verify where exactly the glyphs are drawn.
 class TestSkiaTextRenderer : public internal::SkiaTextRenderer {
  public:
   struct TextLog {
     TextLog() : glyph_count(0u), color(SK_ColorTRANSPARENT) {}
@@ skipping 343 matching lines @@
       render_text->styles()[UNDERLINE].EqualsForTesting(expected_style));
   // Ensure AppendText maintains current text styles.
   render_text->AppendText(ASCIIToUTF16("def"));
   EXPECT_EQ(render_text->GetDisplayText(), ASCIIToUTF16("abcdef"));
   EXPECT_TRUE(render_text->colors().EqualsForTesting(expected_color));
   EXPECT_TRUE(render_text->baselines().EqualsForTesting(expected_baseline));
   EXPECT_TRUE(
       render_text->styles()[UNDERLINE].EqualsForTesting(expected_style));
 }
 
-void TestVisualCursorMotionInObscuredField(RenderText* render_text,
-                                           const base::string16& text,
-                                           bool select) {
+void TestVisualCursorMotionInObscuredField(
+    RenderText* render_text,
+    const base::string16& text,
+    SelectionBehavior selection_behavior) {
+  const bool select = selection_behavior != SELECTION_NONE;
   ASSERT_TRUE(render_text->obscured());
   render_text->SetText(text);
   int len = text.length();
-  render_text->MoveCursor(LINE_BREAK, CURSOR_RIGHT, select);
+  render_text->MoveCursor(LINE_BREAK, CURSOR_RIGHT, selection_behavior);
   EXPECT_EQ(SelectionModel(Range(select ? 0 : len, len), CURSOR_FORWARD),
             render_text->selection_model());
-  render_text->MoveCursor(LINE_BREAK, CURSOR_LEFT, select);
+  render_text->MoveCursor(LINE_BREAK, CURSOR_LEFT, selection_behavior);
   EXPECT_EQ(SelectionModel(0, CURSOR_BACKWARD), render_text->selection_model());
   for (int j = 1; j <= len; ++j) {
-    render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, select);
+    render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, selection_behavior);
     EXPECT_EQ(SelectionModel(Range(select ? 0 : j, j), CURSOR_BACKWARD),
               render_text->selection_model());
   }
   for (int j = len - 1; j >= 0; --j) {
-    render_text->MoveCursor(CHARACTER_BREAK, CURSOR_LEFT, select);
+    render_text->MoveCursor(CHARACTER_BREAK, CURSOR_LEFT, selection_behavior);
     EXPECT_EQ(SelectionModel(Range(select ? 0 : j, j), CURSOR_FORWARD),
               render_text->selection_model());
   }
-  render_text->MoveCursor(WORD_BREAK, CURSOR_RIGHT, select);
+  render_text->MoveCursor(WORD_BREAK, CURSOR_RIGHT, selection_behavior);
   EXPECT_EQ(SelectionModel(Range(select ? 0 : len, len), CURSOR_FORWARD),
             render_text->selection_model());
-  render_text->MoveCursor(WORD_BREAK, CURSOR_LEFT, select);
+  render_text->MoveCursor(WORD_BREAK, CURSOR_LEFT, selection_behavior);
   EXPECT_EQ(SelectionModel(0, CURSOR_BACKWARD), render_text->selection_model());
 }
 
 // TODO(asvitkine): RenderTextMac cursor movements. http://crbug.com/131618
 #if !defined(OS_MACOSX)
 TEST_F(RenderTextTest, ObscuredText) {
   const base::string16 seuss = ASCIIToUTF16("hop on pop");
   const base::string16 no_seuss = ASCIIToUTF16("**********");
   std::unique_ptr<RenderText> render_text(RenderText::CreateInstance());
 
   // GetLayoutText() returns asterisks when the obscured bit is set.
   render_text->SetText(seuss);
   render_text->SetObscured(true);
   EXPECT_EQ(seuss, render_text->text());
   EXPECT_EQ(no_seuss, render_text->GetDisplayText());
   render_text->SetObscured(false);
   EXPECT_EQ(seuss, render_text->text());
   EXPECT_EQ(seuss, render_text->GetDisplayText());
 
   render_text->SetObscured(true);
 
   // Surrogate pairs are counted as one code point.
   const base::char16 invalid_surrogates[] = {0xDC00, 0xD800, 0};
   render_text->SetText(invalid_surrogates);
   EXPECT_EQ(ASCIIToUTF16("**"), render_text->GetDisplayText());
   const base::char16 valid_surrogates[] = {0xD800, 0xDC00, 0};
   render_text->SetText(valid_surrogates);
   EXPECT_EQ(ASCIIToUTF16("*"), render_text->GetDisplayText());
   EXPECT_EQ(0U, render_text->cursor_position());
-  render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, false);
+  render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, SELECTION_NONE);
   EXPECT_EQ(2U, render_text->cursor_position());
 
   // Test index conversion and cursor validity with a valid surrogate pair.
   EXPECT_EQ(0U, render_text->TextIndexToDisplayIndex(0U));
   EXPECT_EQ(1U, render_text->TextIndexToDisplayIndex(1U));
   EXPECT_EQ(1U, render_text->TextIndexToDisplayIndex(2U));
   EXPECT_EQ(0U, render_text->DisplayIndexToTextIndex(0U));
   EXPECT_EQ(2U, render_text->DisplayIndexToTextIndex(1U));
   EXPECT_TRUE(render_text->IsValidCursorIndex(0U));
   EXPECT_FALSE(render_text->IsValidCursorIndex(1U));
@@ skipping 13 matching lines @@
             static_cast<int>(render_text->GetGlyphBounds(0U).length()));
 
   // Cursoring is independent of underlying characters when text is obscured.
   const wchar_t* const texts[] = {
     kWeak, kLtr, kLtrRtl, kLtrRtlLtr, kRtl, kRtlLtr, kRtlLtrRtl,
     L"hop on pop",                              // Check LTR word boundaries.
     L"\x05d0\x05d1 \x05d0\x05d2 \x05d1\x05d2",  // Check RTL word boundaries.
   };
   for (size_t i = 0; i < arraysize(texts); ++i) {
     base::string16 text = WideToUTF16(texts[i]);
-    TestVisualCursorMotionInObscuredField(render_text.get(), text, false);
-    TestVisualCursorMotionInObscuredField(render_text.get(), text, true);
+    TestVisualCursorMotionInObscuredField(render_text.get(), text,
+                                          SELECTION_NONE);
+    TestVisualCursorMotionInObscuredField(render_text.get(), text,
+                                          SELECTION_RETAIN);
   }
 }
 #endif  // !defined(OS_MACOSX)
 
 TEST_F(RenderTextTest, RevealObscuredText) {
   const base::string16 seuss = ASCIIToUTF16("hop on pop");
   const base::string16 no_seuss = ASCIIToUTF16("**********");
   std::unique_ptr<RenderText> render_text(RenderText::CreateInstance());
 
   render_text->SetText(seuss);
@@ skipping 62 matching lines @@
       {'*', '*', '*', '*', 0xD800, 0xDC00, 0};
   EXPECT_EQ(valid_expect_5_and_6, render_text->GetDisplayText());
   render_text->RenderText::SetObscuredRevealIndex(6);
   EXPECT_EQ(valid_expect_5_and_6, render_text->GetDisplayText());
 }
 
 TEST_F(RenderTextTest, ObscuredEmoji) {
   // Ensures text itemization doesn't crash on obscured multi-char glyphs.
   std::unique_ptr<RenderText> render_text(RenderText::CreateInstance());
   render_text->SetObscured(true);
-  gfx::Canvas canvas;
+  Canvas canvas;
   // Test the "Grinning face with smiling eyes" character followed by 'y'.
   render_text->SetText(UTF8ToUTF16("\xF0\x9F\x98\x81y"));
   render_text->Draw(&canvas);
   // Test two "Camera" characters in a row.
   render_text->SetText(UTF8ToUTF16("\xF0\x9F\x93\xB7\xF0\x9F\x93\xB7"));
   render_text->Draw(&canvas);
 }
 
 // TODO(PORT): Fails for RenderTextMac.
 #if !defined(OS_MACOSX)
@@ skipping 220 matching lines @@
 }
 
 // TODO(asvitkine): RenderTextMac cursor movements. http://crbug.com/131618
 #if !defined(OS_MACOSX)
 TEST_F(RenderTextTest, TruncatedCursorMovementLTR) {
   std::unique_ptr<RenderText> render_text(RenderText::CreateInstance());
   render_text->set_truncate_length(2);
   render_text->SetText(WideToUTF16(L"abcd"));
 
   EXPECT_EQ(SelectionModel(0, CURSOR_BACKWARD), render_text->selection_model());
-  render_text->MoveCursor(LINE_BREAK, CURSOR_RIGHT, false);
+  render_text->MoveCursor(LINE_BREAK, CURSOR_RIGHT, SELECTION_NONE);
   EXPECT_EQ(SelectionModel(4, CURSOR_FORWARD), render_text->selection_model());
-  render_text->MoveCursor(LINE_BREAK, CURSOR_LEFT, false);
+  render_text->MoveCursor(LINE_BREAK, CURSOR_LEFT, SELECTION_NONE);
   EXPECT_EQ(SelectionModel(0, CURSOR_BACKWARD), render_text->selection_model());
 
   std::vector<SelectionModel> expected;
   expected.push_back(SelectionModel(0, CURSOR_BACKWARD));
   expected.push_back(SelectionModel(1, CURSOR_BACKWARD));
   // The cursor hops over the ellipsis and elided text to the line end.
   expected.push_back(SelectionModel(4, CURSOR_BACKWARD));
   expected.push_back(SelectionModel(4, CURSOR_FORWARD));
   RunMoveCursorLeftRightTest(render_text.get(), expected, CURSOR_RIGHT);
 
   expected.clear();
   expected.push_back(SelectionModel(4, CURSOR_FORWARD));
   // The cursor hops over the elided text to preceeding text.
   expected.push_back(SelectionModel(1, CURSOR_FORWARD));
   expected.push_back(SelectionModel(0, CURSOR_FORWARD));
   expected.push_back(SelectionModel(0, CURSOR_BACKWARD));
   RunMoveCursorLeftRightTest(render_text.get(), expected, CURSOR_LEFT);
 }
 
 TEST_F(RenderTextTest, TruncatedCursorMovementRTL) {
   std::unique_ptr<RenderText> render_text(RenderText::CreateInstance());
   render_text->set_truncate_length(2);
   render_text->SetText(WideToUTF16(L"\x5d0\x5d1\x5d2\x5d3"));
 
   EXPECT_EQ(SelectionModel(0, CURSOR_BACKWARD), render_text->selection_model());
-  render_text->MoveCursor(LINE_BREAK, CURSOR_LEFT, false);
+  render_text->MoveCursor(LINE_BREAK, CURSOR_LEFT, SELECTION_NONE);
   EXPECT_EQ(SelectionModel(4, CURSOR_FORWARD), render_text->selection_model());
-  render_text->MoveCursor(LINE_BREAK, CURSOR_RIGHT, false);
+  render_text->MoveCursor(LINE_BREAK, CURSOR_RIGHT, SELECTION_NONE);
   EXPECT_EQ(SelectionModel(0, CURSOR_BACKWARD), render_text->selection_model());
 
   std::vector<SelectionModel> expected;
   expected.push_back(SelectionModel(0, CURSOR_BACKWARD));
   expected.push_back(SelectionModel(1, CURSOR_BACKWARD));
   // The cursor hops over the ellipsis and elided text to the line end.
   expected.push_back(SelectionModel(4, CURSOR_BACKWARD));
   expected.push_back(SelectionModel(4, CURSOR_FORWARD));
   RunMoveCursorLeftRightTest(render_text.get(), expected, CURSOR_LEFT);
 
   expected.clear();
   expected.push_back(SelectionModel(4, CURSOR_FORWARD));
   // The cursor hops over the elided text to preceeding text.
   expected.push_back(SelectionModel(1, CURSOR_FORWARD));
   expected.push_back(SelectionModel(0, CURSOR_FORWARD));
   expected.push_back(SelectionModel(0, CURSOR_BACKWARD));
   RunMoveCursorLeftRightTest(render_text.get(), expected, CURSOR_RIGHT);
 }
 #endif  // !defined(OS_MACOSX)
 
+TEST_F(RenderTextTest, MoveCursor_Character) {
+  std::unique_ptr<RenderText> render_text(
+      RenderText::CreateInstanceForEditing());
+  render_text->SetText(WideToUTF16(L"123 456 789"));
+  std::vector<Range> expected;
+
+  // SELECTION_NONE.
+  render_text->SelectRange(Range(6));
+
+  // Move right twice.
+  expected.push_back(Range(7));
+  expected.push_back(Range(8));
+  RunMoveCursorTestAndClearExpectations(render_text.get(), CHARACTER_BREAK,
+                                        CURSOR_RIGHT, SELECTION_NONE,
+                                        &expected);
+
+  // Move left twice.
+  expected.push_back(Range(7));
+  expected.push_back(Range(6));
+  RunMoveCursorTestAndClearExpectations(render_text.get(), CHARACTER_BREAK,
+                                        CURSOR_LEFT, SELECTION_NONE, &expected);
+
+  // SELECTION_CARET.
+  render_text->SelectRange(Range(6));
+  expected.push_back(Range(6, 7));
+
+  // Move right.
+  RunMoveCursorTestAndClearExpectations(render_text.get(), CHARACTER_BREAK,
+                                        CURSOR_RIGHT, SELECTION_CARET,
+                                        &expected);
+
+  // Move left twice.
+  expected.push_back(Range(6));
+  expected.push_back(Range(6, 5));
+  RunMoveCursorTestAndClearExpectations(render_text.get(), CHARACTER_BREAK,
+                                        CURSOR_LEFT, SELECTION_CARET,
+                                        &expected);
+
+  // SELECTION_RETAIN.
+  render_text->SelectRange(Range(6));
+
+  // Move right.
+  expected.push_back(Range(6, 7));
+  RunMoveCursorTestAndClearExpectations(render_text.get(), CHARACTER_BREAK,
+                                        CURSOR_RIGHT, SELECTION_RETAIN,
+                                        &expected);
+
+  // Move left twice.
+  expected.push_back(Range(6));
+  expected.push_back(Range(6, 5));
+  RunMoveCursorTestAndClearExpectations(render_text.get(), CHARACTER_BREAK,
+                                        CURSOR_LEFT, SELECTION_RETAIN,
+                                        &expected);
+
+  // SELECTION_EXTEND.
+  render_text->SelectRange(Range(6));
+
+  // Move right.
+  expected.push_back(Range(6, 7));
+  RunMoveCursorTestAndClearExpectations(render_text.get(), CHARACTER_BREAK,
+                                        CURSOR_RIGHT, SELECTION_EXTEND,
+                                        &expected);
+
+  // Move left twice.
+  expected.push_back(Range(7, 6));
+  expected.push_back(Range(7, 5));
+  RunMoveCursorTestAndClearExpectations(render_text.get(), CHARACTER_BREAK,
+                                        CURSOR_LEFT, SELECTION_EXTEND,
+                                        &expected);
+}
+
+TEST_F(RenderTextTest, MoveCursor_Word) {

[msw, 2016/08/16 18:37:58]

aside: I'm glad this works on all the bots, we have some weird move-by-word
behavior on windows that I tried to remove in
https://codereview.chromium.org/1130683005

+  std::unique_ptr<RenderText> render_text(
+      RenderText::CreateInstanceForEditing());
+  render_text->SetText(WideToUTF16(L"123 456 789"));
+  std::vector<Range> expected;
+
+  // SELECTION_NONE.
+  render_text->SelectRange(Range(6));
+
+  // Move left twice.
+  expected.push_back(Range(4));
+  expected.push_back(Range(0));
+  RunMoveCursorTestAndClearExpectations(render_text.get(), WORD_BREAK,
+                                        CURSOR_LEFT, SELECTION_NONE, &expected);
+
+  // Move right twice.
+  expected.push_back(Range(3));
+  expected.push_back(Range(7));
+  RunMoveCursorTestAndClearExpectations(
+      render_text.get(), WORD_BREAK, CURSOR_RIGHT, SELECTION_NONE, &expected);
+
+  // SELECTION_CARET.
+  render_text->SelectRange(Range(6));
+
+  // Move left.
+  expected.push_back(Range(6, 4));
+  RunMoveCursorTestAndClearExpectations(
+      render_text.get(), WORD_BREAK, CURSOR_LEFT, SELECTION_CARET, &expected);
+
+  // Move right twice.
+  expected.push_back(Range(6));
+  expected.push_back(Range(6, 7));
+  RunMoveCursorTestAndClearExpectations(
+      render_text.get(), WORD_BREAK, CURSOR_RIGHT, SELECTION_CARET, &expected);
+
+  // Move left.
+  expected.push_back(Range(6));
+  RunMoveCursorTestAndClearExpectations(
+      render_text.get(), WORD_BREAK, CURSOR_LEFT, SELECTION_CARET, &expected);
+
+  // SELECTION_RETAIN.
+  render_text->SelectRange(Range(6));
+
+  // Move left.
+  expected.push_back(Range(6, 4));
+  RunMoveCursorTestAndClearExpectations(
+      render_text.get(), WORD_BREAK, CURSOR_LEFT, SELECTION_RETAIN, &expected);
+
+  // Move right twice.
+  expected.push_back(Range(6, 7));
+  expected.push_back(Range(6, 11));
+  RunMoveCursorTestAndClearExpectations(
+      render_text.get(), WORD_BREAK, CURSOR_RIGHT, SELECTION_RETAIN, &expected);
+
+  // Move left.
+  expected.push_back(Range(6, 8));
+  RunMoveCursorTestAndClearExpectations(
+      render_text.get(), WORD_BREAK, CURSOR_LEFT, SELECTION_RETAIN, &expected);
+
+  // SELECTION_EXTEND.
+  render_text->SelectRange(Range(6));
+
+  // Move left.
+  expected.push_back(Range(6, 4));
+  RunMoveCursorTestAndClearExpectations(
+      render_text.get(), WORD_BREAK, CURSOR_LEFT, SELECTION_EXTEND, &expected);
+
+  // Move right twice.
+  expected.push_back(Range(4, 7));
+  expected.push_back(Range(4, 11));
+  RunMoveCursorTestAndClearExpectations(
+      render_text.get(), WORD_BREAK, CURSOR_RIGHT, SELECTION_EXTEND, &expected);
+
+  // Move left.
+  expected.push_back(Range(4, 8));
+  RunMoveCursorTestAndClearExpectations(
+      render_text.get(), WORD_BREAK, CURSOR_LEFT, SELECTION_EXTEND, &expected);
+}
+
+TEST_F(RenderTextTest, MoveCursor_Line) {
+  std::unique_ptr<RenderText> render_text(
+      RenderText::CreateInstanceForEditing());
+  render_text->SetText(WideToUTF16(L"123 456 789"));
+  std::vector<Range> expected;
+
+  // SELECTION_NONE.
+  render_text->SelectRange(Range(6));
+
+  // Move right twice.
+  expected.push_back(Range(11));
+  expected.push_back(Range(11));
+  RunMoveCursorTestAndClearExpectations(
+      render_text.get(), LINE_BREAK, CURSOR_RIGHT, SELECTION_NONE, &expected);
+
+  // Move left twice.
+  expected.push_back(Range(0));
+  expected.push_back(Range(0));
+  RunMoveCursorTestAndClearExpectations(render_text.get(), LINE_BREAK,
+                                        CURSOR_LEFT, SELECTION_NONE, &expected);
+
+  // SELECTION_CARET.
+  render_text->SelectRange(Range(6));
+
+  // Move right.
+  expected.push_back(Range(6, 11));
+  RunMoveCursorTestAndClearExpectations(
+      render_text.get(), LINE_BREAK, CURSOR_RIGHT, SELECTION_CARET, &expected);
+
+  // Move left twice.
+  expected.push_back(Range(6));
+  expected.push_back(Range(6, 0));
+  RunMoveCursorTestAndClearExpectations(
+      render_text.get(), LINE_BREAK, CURSOR_LEFT, SELECTION_CARET, &expected);
+
+  // Move right.
+  expected.push_back(Range(6));
+  RunMoveCursorTestAndClearExpectations(
+      render_text.get(), LINE_BREAK, CURSOR_RIGHT, SELECTION_CARET, &expected);
+
+  // SELECTION_RETAIN.
+  render_text->SelectRange(Range(6));
+
+  // Move right.
+  expected.push_back(Range(6, 11));
+  RunMoveCursorTestAndClearExpectations(
+      render_text.get(), LINE_BREAK, CURSOR_RIGHT, SELECTION_RETAIN, &expected);
+
+  // Move left twice.
+  expected.push_back(Range(6, 0));
+  expected.push_back(Range(6, 0));
+  RunMoveCursorTestAndClearExpectations(
+      render_text.get(), LINE_BREAK, CURSOR_LEFT, SELECTION_RETAIN, &expected);
+
+  // Move right.
+  expected.push_back(Range(6, 11));
+  RunMoveCursorTestAndClearExpectations(
+      render_text.get(), LINE_BREAK, CURSOR_RIGHT, SELECTION_RETAIN, &expected);
+
+  // SELECTION_EXTEND.
+  render_text->SelectRange(Range(6));
+
+  // Move right.
+  expected.push_back(Range(6, 11));
+  RunMoveCursorTestAndClearExpectations(
+      render_text.get(), LINE_BREAK, CURSOR_RIGHT, SELECTION_EXTEND, &expected);
+
+  // Move left twice.
+  expected.push_back(Range(11, 0));
+  expected.push_back(Range(11, 0));
+  RunMoveCursorTestAndClearExpectations(
+      render_text.get(), LINE_BREAK, CURSOR_LEFT, SELECTION_EXTEND, &expected);
+
+  // Move right.
+  expected.push_back(Range(0, 11));
+  RunMoveCursorTestAndClearExpectations(
+      render_text.get(), LINE_BREAK, CURSOR_RIGHT, SELECTION_EXTEND, &expected);
+}
+
 TEST_F(RenderTextTest, GetDisplayTextDirection) {
   struct {
     const wchar_t* text;
     const base::i18n::TextDirection text_direction;
   } cases[] = {
     // Blank strings and those with no/weak directionality default to LTR.
     { L"",        base::i18n::LEFT_TO_RIGHT },
     { kWeak,      base::i18n::LEFT_TO_RIGHT },
     // Strings that begin with strong LTR characters.
     { kLtr,       base::i18n::LEFT_TO_RIGHT },
@@ skipping 112 matching lines @@
   expected.push_back(SelectionModel(2, CURSOR_BACKWARD));
   expected.push_back(SelectionModel(0, CURSOR_FORWARD));
   expected.push_back(SelectionModel(0, CURSOR_BACKWARD));
   RunMoveCursorLeftRightTest(render_text.get(), expected, CURSOR_LEFT);
 }
 
 TEST_F(RenderTextTest, MoveCursorLeftRightInRtl) {
   std::unique_ptr<RenderText> render_text(RenderText::CreateInstance());
   // Pure RTL.
   render_text->SetText(WideToUTF16(L"\x05d0\x05d1\x05d2"));
-  render_text->MoveCursor(LINE_BREAK, CURSOR_RIGHT, false);
+  render_text->MoveCursor(LINE_BREAK, CURSOR_RIGHT, SELECTION_NONE);
   std::vector<SelectionModel> expected;
 
   expected.push_back(SelectionModel(0, CURSOR_BACKWARD));
   expected.push_back(SelectionModel(1, CURSOR_BACKWARD));
   expected.push_back(SelectionModel(2, CURSOR_BACKWARD));
   expected.push_back(SelectionModel(3, CURSOR_BACKWARD));
   expected.push_back(SelectionModel(3, CURSOR_FORWARD));
   RunMoveCursorLeftRightTest(render_text.get(), expected, CURSOR_LEFT);
 
   expected.clear();
 
   expected.push_back(SelectionModel(3, CURSOR_FORWARD));
   expected.push_back(SelectionModel(2, CURSOR_FORWARD));
   expected.push_back(SelectionModel(1, CURSOR_FORWARD));
   expected.push_back(SelectionModel(0, CURSOR_FORWARD));
   expected.push_back(SelectionModel(0, CURSOR_BACKWARD));
   RunMoveCursorLeftRightTest(render_text.get(), expected, CURSOR_RIGHT);
 }
 
 TEST_F(RenderTextTest, MoveCursorLeftRightInRtlLtr) {
   std::unique_ptr<RenderText> render_text(RenderText::CreateInstance());
   // RTL-LTR
   render_text->SetText(WideToUTF16(L"\x05d0\x05d1\x05d2" L"abc"));
-  render_text->MoveCursor(LINE_BREAK, CURSOR_RIGHT, false);
+  render_text->MoveCursor(LINE_BREAK, CURSOR_RIGHT, SELECTION_NONE);
   std::vector<SelectionModel> expected;
   expected.push_back(SelectionModel(0, CURSOR_BACKWARD));
   expected.push_back(SelectionModel(1, CURSOR_BACKWARD));
   expected.push_back(SelectionModel(2, CURSOR_BACKWARD));
   expected.push_back(SelectionModel(3, CURSOR_BACKWARD));
   expected.push_back(SelectionModel(5, CURSOR_FORWARD));
   expected.push_back(SelectionModel(4, CURSOR_FORWARD));
   expected.push_back(SelectionModel(3, CURSOR_FORWARD));
   expected.push_back(SelectionModel(6, CURSOR_FORWARD));
   RunMoveCursorLeftRightTest(render_text.get(), expected, CURSOR_LEFT);
 
   expected.clear();
   expected.push_back(SelectionModel(6, CURSOR_FORWARD));
   expected.push_back(SelectionModel(4, CURSOR_BACKWARD));
   expected.push_back(SelectionModel(5, CURSOR_BACKWARD));
   expected.push_back(SelectionModel(6, CURSOR_BACKWARD));
   expected.push_back(SelectionModel(2, CURSOR_FORWARD));
   expected.push_back(SelectionModel(1, CURSOR_FORWARD));
   expected.push_back(SelectionModel(0, CURSOR_FORWARD));
   expected.push_back(SelectionModel(0, CURSOR_BACKWARD));
   RunMoveCursorLeftRightTest(render_text.get(), expected, CURSOR_RIGHT);
 }
 
 TEST_F(RenderTextTest, MoveCursorLeftRightInRtlLtrRtl) {
   std::unique_ptr<RenderText> render_text(RenderText::CreateInstance());
   // RTL-LTR-RTL.
   render_text->SetText(WideToUTF16(L"\x05d0" L"a" L"\x05d1"));
-  render_text->MoveCursor(LINE_BREAK, CURSOR_RIGHT, false);
+  render_text->MoveCursor(LINE_BREAK, CURSOR_RIGHT, SELECTION_NONE);
   std::vector<SelectionModel> expected;
   expected.push_back(SelectionModel(0, CURSOR_BACKWARD));
   expected.push_back(SelectionModel(1, CURSOR_BACKWARD));
   expected.push_back(SelectionModel(1, CURSOR_FORWARD));
   expected.push_back(SelectionModel(3, CURSOR_BACKWARD));
   expected.push_back(SelectionModel(3, CURSOR_FORWARD));
   RunMoveCursorLeftRightTest(render_text.get(), expected, CURSOR_LEFT);
 
   expected.clear();
   expected.push_back(SelectionModel(3, CURSOR_FORWARD));
   expected.push_back(SelectionModel(2, CURSOR_FORWARD));
   expected.push_back(SelectionModel(2, CURSOR_BACKWARD));
   expected.push_back(SelectionModel(0, CURSOR_FORWARD));
   expected.push_back(SelectionModel(0, CURSOR_BACKWARD));
   RunMoveCursorLeftRightTest(render_text.get(), expected, CURSOR_RIGHT);
 }
 
 TEST_F(RenderTextTest, MoveCursorLeftRight_ComplexScript) {
   std::unique_ptr<RenderText> render_text(RenderText::CreateInstance());
 
   render_text->SetText(WideToUTF16(L"\x0915\x093f\x0915\x094d\x0915"));
   EXPECT_EQ(0U, render_text->cursor_position());
-  render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, false);
+  render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, SELECTION_NONE);
   EXPECT_EQ(2U, render_text->cursor_position());
-  render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, false);
+  render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, SELECTION_NONE);
   EXPECT_EQ(4U, render_text->cursor_position());
-  render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, false);
+  render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, SELECTION_NONE);
   EXPECT_EQ(5U, render_text->cursor_position());
-  render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, false);
+  render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, SELECTION_NONE);
   EXPECT_EQ(5U, render_text->cursor_position());
 
-  render_text->MoveCursor(CHARACTER_BREAK, CURSOR_LEFT, false);
+  render_text->MoveCursor(CHARACTER_BREAK, CURSOR_LEFT, SELECTION_NONE);
   EXPECT_EQ(4U, render_text->cursor_position());
-  render_text->MoveCursor(CHARACTER_BREAK, CURSOR_LEFT, false);
+  render_text->MoveCursor(CHARACTER_BREAK, CURSOR_LEFT, SELECTION_NONE);
   EXPECT_EQ(2U, render_text->cursor_position());
-  render_text->MoveCursor(CHARACTER_BREAK, CURSOR_LEFT, false);
+  render_text->MoveCursor(CHARACTER_BREAK, CURSOR_LEFT, SELECTION_NONE);
   EXPECT_EQ(0U, render_text->cursor_position());
-  render_text->MoveCursor(CHARACTER_BREAK, CURSOR_LEFT, false);
+  render_text->MoveCursor(CHARACTER_BREAK, CURSOR_LEFT, SELECTION_NONE);
   EXPECT_EQ(0U, render_text->cursor_position());
 }
 
 TEST_F(RenderTextTest, MoveCursorLeftRight_MeiryoUILigatures) {
   std::unique_ptr<RenderText> render_text(RenderText::CreateInstance());
   // Meiryo UI uses single-glyph ligatures for 'ff' and 'ffi', but each letter
   // (code point) has unique bounds, so mid-glyph cursoring should be possible.
   render_text->SetFontList(FontList("Meiryo UI, 12px"));
   render_text->SetText(WideToUTF16(L"ff ffi"));
   EXPECT_EQ(0U, render_text->cursor_position());
   for (size_t i = 0; i < render_text->text().length(); ++i) {
-    render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, false);
+    render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, SELECTION_NONE);
     EXPECT_EQ(i + 1, render_text->cursor_position());
   }
   EXPECT_EQ(6U, render_text->cursor_position());
 }
 
 TEST_F(RenderTextTest, GraphemePositions) {
   // LTR 2-character grapheme, LTR abc, LTR 2-character grapheme.
   const base::string16 kText1 =
       WideToUTF16(L"\x0915\x093f" L"abc" L"\x0915\x093f");
 
@@ skipping 85 matching lines @@
   for (size_t i = 0; i < arraysize(cases); i++) {
     SCOPED_TRACE(base::StringPrintf("Testing cases[%" PRIuS "]", i));
     render_text->SetText(cases[i]);
     EXPECT_TRUE(render_text->IsValidLogicalIndex(1));
     EXPECT_FALSE(render_text->IsValidCursorIndex(1));
     EXPECT_TRUE(render_text->SelectRange(Range(2, 1)));
     EXPECT_EQ(Range(2, 1), render_text->selection());
     EXPECT_EQ(1U, render_text->cursor_position());
     // Although selection bounds may be set within a multi-character grapheme,
     // cursor movement (e.g. via arrow key) should avoid those indices.
-    render_text->MoveCursor(CHARACTER_BREAK, CURSOR_LEFT, false);
+    render_text->MoveCursor(CHARACTER_BREAK, CURSOR_LEFT, SELECTION_NONE);
     EXPECT_EQ(0U, render_text->cursor_position());
-    render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, false);
+    render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, SELECTION_NONE);
     EXPECT_EQ(2U, render_text->cursor_position());
   }
 }
 
 TEST_F(RenderTextTest, FindCursorPosition) {
   const wchar_t* kTestStrings[] = { kLtrRtl, kLtrRtlLtr, kRtlLtr, kRtlLtrRtl };
   std::unique_ptr<RenderText> render_text(RenderText::CreateInstance());
   render_text->SetDisplayRect(Rect(0, 0, 100, 20));
   for (size_t i = 0; i < arraysize(kTestStrings); ++i) {
     SCOPED_TRACE(base::StringPrintf("Testing case[%" PRIuS "]", i));
@@ skipping 84 matching lines @@
 
   EXPECT_EQ(was_rtl, base::i18n::IsRTL());
 }
 
 // TODO(asvitkine): RenderTextMac cursor movements. http://crbug.com/131618
 #if !defined(OS_MACOSX)
 TEST_F(RenderTextTest, MoveCursorLeftRightWithSelection) {
   std::unique_ptr<RenderText> render_text(RenderText::CreateInstance());
   render_text->SetText(WideToUTF16(L"abc\x05d0\x05d1\x05d2"));
   // Left arrow on select ranging (6, 4).
-  render_text->MoveCursor(LINE_BREAK, CURSOR_RIGHT, false);
+  render_text->MoveCursor(LINE_BREAK, CURSOR_RIGHT, SELECTION_NONE);
   EXPECT_EQ(Range(6), render_text->selection());
-  render_text->MoveCursor(CHARACTER_BREAK, CURSOR_LEFT, false);
+  render_text->MoveCursor(CHARACTER_BREAK, CURSOR_LEFT, SELECTION_NONE);
   EXPECT_EQ(Range(4), render_text->selection());
-  render_text->MoveCursor(CHARACTER_BREAK, CURSOR_LEFT, false);
+  render_text->MoveCursor(CHARACTER_BREAK, CURSOR_LEFT, SELECTION_NONE);
   EXPECT_EQ(Range(5), render_text->selection());
-  render_text->MoveCursor(CHARACTER_BREAK, CURSOR_LEFT, false);
+  render_text->MoveCursor(CHARACTER_BREAK, CURSOR_LEFT, SELECTION_NONE);
   EXPECT_EQ(Range(6), render_text->selection());
-  render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, true);
+  render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, SELECTION_RETAIN);
   EXPECT_EQ(Range(6, 5), render_text->selection());
-  render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, true);
+  render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, SELECTION_RETAIN);
   EXPECT_EQ(Range(6, 4), render_text->selection());
-  render_text->MoveCursor(CHARACTER_BREAK, CURSOR_LEFT, false);
+  render_text->MoveCursor(CHARACTER_BREAK, CURSOR_LEFT, SELECTION_NONE);
   EXPECT_EQ(Range(6), render_text->selection());
 
   // Right arrow on select ranging (4, 6).
-  render_text->MoveCursor(LINE_BREAK, CURSOR_LEFT, false);
+  render_text->MoveCursor(LINE_BREAK, CURSOR_LEFT, SELECTION_NONE);
   EXPECT_EQ(Range(0), render_text->selection());
-  render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, false);
+  render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, SELECTION_NONE);
   EXPECT_EQ(Range(1), render_text->selection());
-  render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, false);
+  render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, SELECTION_NONE);
   EXPECT_EQ(Range(2), render_text->selection());
-  render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, false);
+  render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, SELECTION_NONE);
   EXPECT_EQ(Range(3), render_text->selection());
-  render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, false);
+  render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, SELECTION_NONE);
   EXPECT_EQ(Range(5), render_text->selection());
-  render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, false);
+  render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, SELECTION_NONE);
   EXPECT_EQ(Range(4), render_text->selection());
-  render_text->MoveCursor(CHARACTER_BREAK, CURSOR_LEFT, true);
+  render_text->MoveCursor(CHARACTER_BREAK, CURSOR_LEFT, SELECTION_RETAIN);
   EXPECT_EQ(Range(4, 5), render_text->selection());
-  render_text->MoveCursor(CHARACTER_BREAK, CURSOR_LEFT, true);
+  render_text->MoveCursor(CHARACTER_BREAK, CURSOR_LEFT, SELECTION_RETAIN);
   EXPECT_EQ(Range(4, 6), render_text->selection());
-  render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, false);
+  render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, SELECTION_NONE);
   EXPECT_EQ(Range(4), render_text->selection());
 }
 #endif  // !defined(OS_MACOSX)
 
 TEST_F(RenderTextTest, CenteredDisplayOffset) {
   std::unique_ptr<RenderText> render_text(RenderText::CreateInstance());
   render_text->SetText(ASCIIToUTF16("abcdefghij"));
   render_text->SetHorizontalAlignment(ALIGN_CENTER);
 
   const int kEnlargement = 10;
@@ skipping 28 matching lines @@
   EXPECT_EQ(display_rect.right(),
             render_text->GetUpdatedCursorBounds().right());
 #endif  // !defined(OS_MACOSX)
 }
 
 void MoveLeftRightByWordVerifier(RenderText* render_text,
                                  const wchar_t* str) {
   render_text->SetText(WideToUTF16(str));
 
   // Test moving by word from left ro right.
-  render_text->MoveCursor(LINE_BREAK, CURSOR_LEFT, false);
+  render_text->MoveCursor(LINE_BREAK, CURSOR_LEFT, SELECTION_NONE);
   bool first_word = true;
   while (true) {
     // First, test moving by word from a word break position, such as from
     // "|abc def" to "abc| def".
     SelectionModel start = render_text->selection_model();
-    render_text->MoveCursor(WORD_BREAK, CURSOR_RIGHT, false);
+    render_text->MoveCursor(WORD_BREAK, CURSOR_RIGHT, SELECTION_NONE);
     SelectionModel end = render_text->selection_model();
     if (end == start)  // reach the end.
       break;
 
     // For testing simplicity, each word is a 3-character word.
     int num_of_character_moves = first_word ? 3 : 4;
     first_word = false;
     render_text->MoveCursorTo(start);
     for (int j = 0; j < num_of_character_moves; ++j)
-      render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, false);
+      render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, SELECTION_NONE);
     EXPECT_EQ(end, render_text->selection_model());
 
     // Then, test moving by word from positions inside the word, such as from
     // "a|bc def" to "abc| def", and from "ab|c def" to "abc| def".
     for (int j = 1; j < num_of_character_moves; ++j) {
       render_text->MoveCursorTo(start);
       for (int k = 0; k < j; ++k)
-        render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, false);
-      render_text->MoveCursor(WORD_BREAK, CURSOR_RIGHT, false);
+        render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, SELECTION_NONE);
+      render_text->MoveCursor(WORD_BREAK, CURSOR_RIGHT, SELECTION_NONE);
       EXPECT_EQ(end, render_text->selection_model());
     }
   }
 
   // Test moving by word from right to left.
-  render_text->MoveCursor(LINE_BREAK, CURSOR_RIGHT, false);
+  render_text->MoveCursor(LINE_BREAK, CURSOR_RIGHT, SELECTION_NONE);
   first_word = true;
   while (true) {
     SelectionModel start = render_text->selection_model();
-    render_text->MoveCursor(WORD_BREAK, CURSOR_LEFT, false);
+    render_text->MoveCursor(WORD_BREAK, CURSOR_LEFT, SELECTION_NONE);
     SelectionModel end = render_text->selection_model();
     if (end == start)  // reach the end.
       break;
 
     int num_of_character_moves = first_word ? 3 : 4;
     first_word = false;
     render_text->MoveCursorTo(start);
     for (int j = 0; j < num_of_character_moves; ++j)
-      render_text->MoveCursor(CHARACTER_BREAK, CURSOR_LEFT, false);
+      render_text->MoveCursor(CHARACTER_BREAK, CURSOR_LEFT, SELECTION_NONE);
     EXPECT_EQ(end, render_text->selection_model());
 
     for (int j = 1; j < num_of_character_moves; ++j) {
       render_text->MoveCursorTo(start);
       for (int k = 0; k < j; ++k)
-        render_text->MoveCursor(CHARACTER_BREAK, CURSOR_LEFT, false);
-      render_text->MoveCursor(WORD_BREAK, CURSOR_LEFT, false);
+        render_text->MoveCursor(CHARACTER_BREAK, CURSOR_LEFT, SELECTION_NONE);
+      render_text->MoveCursor(WORD_BREAK, CURSOR_LEFT, SELECTION_NONE);
       EXPECT_EQ(end, render_text->selection_model());
     }
   }
 }
 
 // TODO(asvitkine): RenderTextMac cursor movements. http://crbug.com/131618
 #if !defined(OS_MACOSX)
 // TODO(msw): Make these work on Windows.
 #if !defined(OS_WIN)
 TEST_F(RenderTextTest, MoveLeftRightByWordInBidiText) {
@@ skipping 32 matching lines @@
 }
 
 TEST_F(RenderTextTest, MoveLeftRightByWordInBidiText_TestEndOfText) {
   std::unique_ptr<RenderText> render_text(RenderText::CreateInstance());
 
   render_text->SetText(WideToUTF16(L"ab\x05E1"));
   // Moving the cursor by word from "abC|" to the left should return "|abC".
   // But since end of text is always treated as a word break, it returns
   // position "ab|C".
   // TODO(xji): Need to make it work as expected.
-  render_text->MoveCursor(LINE_BREAK, CURSOR_RIGHT, false);
-  render_text->MoveCursor(WORD_BREAK, CURSOR_LEFT, false);
+  render_text->MoveCursor(LINE_BREAK, CURSOR_RIGHT, SELECTION_NONE);
+  render_text->MoveCursor(WORD_BREAK, CURSOR_LEFT, SELECTION_NONE);
   // EXPECT_EQ(SelectionModel(), render_text->selection_model());
 
   // Moving the cursor by word from "|abC" to the right returns "abC|".
-  render_text->MoveCursor(LINE_BREAK, CURSOR_LEFT, false);
-  render_text->MoveCursor(WORD_BREAK, CURSOR_RIGHT, false);
+  render_text->MoveCursor(LINE_BREAK, CURSOR_LEFT, SELECTION_NONE);
+  render_text->MoveCursor(WORD_BREAK, CURSOR_RIGHT, SELECTION_NONE);
   EXPECT_EQ(SelectionModel(3, CURSOR_FORWARD), render_text->selection_model());
 
   render_text->SetText(WideToUTF16(L"\x05E1\x05E2" L"a"));
   // For logical text "BCa", moving the cursor by word from "aCB|" to the left
   // returns "|aCB".
-  render_text->MoveCursor(LINE_BREAK, CURSOR_RIGHT, false);
-  render_text->MoveCursor(WORD_BREAK, CURSOR_LEFT, false);
+  render_text->MoveCursor(LINE_BREAK, CURSOR_RIGHT, SELECTION_NONE);
+  render_text->MoveCursor(WORD_BREAK, CURSOR_LEFT, SELECTION_NONE);
   EXPECT_EQ(SelectionModel(3, CURSOR_FORWARD), render_text->selection_model());
 
   // Moving the cursor by word from "|aCB" to the right should return "aCB|".
   // But since end of text is always treated as a word break, it returns
   // position "a|CB".
   // TODO(xji): Need to make it work as expected.
-  render_text->MoveCursor(LINE_BREAK, CURSOR_LEFT, false);
-  render_text->MoveCursor(WORD_BREAK, CURSOR_RIGHT, false);
+  render_text->MoveCursor(LINE_BREAK, CURSOR_LEFT, SELECTION_NONE);
+  render_text->MoveCursor(WORD_BREAK, CURSOR_RIGHT, SELECTION_NONE);
   // EXPECT_EQ(SelectionModel(), render_text->selection_model());
 }
 
 TEST_F(RenderTextTest, MoveLeftRightByWordInTextWithMultiSpaces) {
   std::unique_ptr<RenderText> render_text(RenderText::CreateInstance());
   render_text->SetText(WideToUTF16(L"abc     def"));
   render_text->MoveCursorTo(SelectionModel(5, CURSOR_FORWARD));
-  render_text->MoveCursor(WORD_BREAK, CURSOR_RIGHT, false);
+  render_text->MoveCursor(WORD_BREAK, CURSOR_RIGHT, SELECTION_NONE);
   EXPECT_EQ(11U, render_text->cursor_position());
 
   render_text->MoveCursorTo(SelectionModel(5, CURSOR_FORWARD));
-  render_text->MoveCursor(WORD_BREAK, CURSOR_LEFT, false);
+  render_text->MoveCursor(WORD_BREAK, CURSOR_LEFT, SELECTION_NONE);
   EXPECT_EQ(0U, render_text->cursor_position());
 }
 #endif  // !defined(OS_WIN)
 
 TEST_F(RenderTextTest, MoveLeftRightByWordInChineseText) {
   std::unique_ptr<RenderText> render_text(RenderText::CreateInstance());
   render_text->SetText(WideToUTF16(L"\x6211\x4EEC\x53BB\x516C\x56ED\x73A9"));
-  render_text->MoveCursor(LINE_BREAK, CURSOR_LEFT, false);
+  render_text->MoveCursor(LINE_BREAK, CURSOR_LEFT, SELECTION_NONE);
   EXPECT_EQ(0U, render_text->cursor_position());
-  render_text->MoveCursor(WORD_BREAK, CURSOR_RIGHT, false);
+  render_text->MoveCursor(WORD_BREAK, CURSOR_RIGHT, SELECTION_NONE);
   EXPECT_EQ(2U, render_text->cursor_position());
-  render_text->MoveCursor(WORD_BREAK, CURSOR_RIGHT, false);
+  render_text->MoveCursor(WORD_BREAK, CURSOR_RIGHT, SELECTION_NONE);
   EXPECT_EQ(3U, render_text->cursor_position());
-  render_text->MoveCursor(WORD_BREAK, CURSOR_RIGHT, false);
+  render_text->MoveCursor(WORD_BREAK, CURSOR_RIGHT, SELECTION_NONE);
   EXPECT_EQ(5U, render_text->cursor_position());
-  render_text->MoveCursor(WORD_BREAK, CURSOR_RIGHT, false);
+  render_text->MoveCursor(WORD_BREAK, CURSOR_RIGHT, SELECTION_NONE);
   EXPECT_EQ(6U, render_text->cursor_position());
-  render_text->MoveCursor(WORD_BREAK, CURSOR_RIGHT, false);
+  render_text->MoveCursor(WORD_BREAK, CURSOR_RIGHT, SELECTION_NONE);
   EXPECT_EQ(6U, render_text->cursor_position());
 }
 #endif  // !defined(OS_MACOSX)
 
 TEST_F(RenderTextTest, StringSizeSanity) {
   std::unique_ptr<RenderText> render_text(RenderText::CreateInstance());
   render_text->SetText(UTF8ToUTF16("Hello World"));
   const Size string_size = render_text->GetStringSize();
   EXPECT_GT(string_size.width(), 0);
   EXPECT_GT(string_size.height(), 0);
@@ skipping 1486 matching lines @@
   render_text.SetFontList(font_list);
   // Korean character "han".
   render_text.SetText(WideToUTF16(L"\xd55c"));
   render_text.EnsureLayout();
   internal::TextRunList* run_list = render_text.GetRunList();
   ASSERT_EQ(1U, run_list->size());
   EXPECT_EQ(0U, run_list->runs()[0]->CountMissingGlyphs());
 }
 #endif  // defined(OS_WIN)
 
-// Ensure that the fallback fonts offered by gfx::GetFallbackFonts() are
+// Ensure that the fallback fonts offered by GetFallbackFonts() are
 // tried. Note this test assumes the font "Arial" doesn't provide a unicode
 // glyph for a particular character, and that there exists a system fallback
 // font which does.
 // TODO(msw): Fallback doesn't find a glyph on Linux.
 #if !defined(OS_LINUX)
 TEST_F(RenderTextTest, HarfBuzz_UnicodeFallback) {
   RenderTextHarfBuzz render_text;
   render_text.SetFontList(FontList("Arial, 12px"));
 
   // Korean character "han".
@@ skipping 275 matching lines @@
     EXPECT_FALSE(backend.paint().isLCDRenderText());
     backend.GetHarfbuzzRunList()->runs()[0]->render_params.subpixel_rendering =
         FontRenderParams::SUBPIXEL_RENDERING_RGB;
     backend.DrawVisualText();
 #endif
     EXPECT_FALSE(backend.paint().isLCDRenderText());
   }
 }
 
 }  // namespace gfx