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

ui/views/controls/textfield/textfield_model_unittest.cc

 // 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 "ui/views/controls/textfield/textfield_model.h"
 
 #include <stddef.h>
 
 #include <memory>
 #include <vector>
@@ skipping 70 matching lines @@
 
 TEST_F(TextfieldModelTest, EditString) {
   TextfieldModel model(NULL);
   // Append two strings.
   model.Append(base::ASCIIToUTF16("HILL"));
   EXPECT_STR_EQ("HILL", model.text());
   model.Append(base::ASCIIToUTF16("WORLD"));
   EXPECT_STR_EQ("HILLWORLD", model.text());
 
   // Insert "E" and replace "I" with "L" to make "HELLO".
-  model.MoveCursor(gfx::CHARACTER_BREAK, gfx::CURSOR_RIGHT, false);
+  model.MoveCursor(gfx::CHARACTER_BREAK, gfx::CURSOR_RIGHT,
+                   gfx::SELECTION_NONE);
   model.InsertChar('E');
   EXPECT_STR_EQ("HEILLWORLD", model.text());
   model.ReplaceChar('L');
   EXPECT_STR_EQ("HELLLWORLD", model.text());
   model.ReplaceChar('L');
   model.ReplaceChar('O');
   EXPECT_STR_EQ("HELLOWORLD", model.text());
 
   // Delete 6th char "W", then delete 5th char "O".
   EXPECT_EQ(5U, model.GetCursorPosition());
   EXPECT_TRUE(model.Delete());
   EXPECT_STR_EQ("HELLOORLD", model.text());
   EXPECT_TRUE(model.Backspace());
   EXPECT_EQ(4U, model.GetCursorPosition());
   EXPECT_STR_EQ("HELLORLD", model.text());
 
   // Move the cursor to start; backspace should fail.
-  model.MoveCursor(gfx::LINE_BREAK, gfx::CURSOR_LEFT, false);
+  model.MoveCursor(gfx::LINE_BREAK, gfx::CURSOR_LEFT, gfx::SELECTION_NONE);
   EXPECT_FALSE(model.Backspace());
   EXPECT_STR_EQ("HELLORLD", model.text());
   // Move the cursor to the end; delete should fail, but backspace should work.
-  model.MoveCursor(gfx::LINE_BREAK, gfx::CURSOR_RIGHT, false);
+  model.MoveCursor(gfx::LINE_BREAK, gfx::CURSOR_RIGHT, gfx::SELECTION_NONE);
   EXPECT_FALSE(model.Delete());
   EXPECT_STR_EQ("HELLORLD", model.text());
   EXPECT_TRUE(model.Backspace());
   EXPECT_STR_EQ("HELLORL", model.text());
 
   MoveCursorTo(model, 5);
   model.ReplaceText(base::ASCIIToUTF16(" WOR"));
   EXPECT_STR_EQ("HELLO WORL", model.text());
 }
 
@@ skipping 110 matching lines @@
   MoveCursorTo(model, 0);
   EXPECT_TRUE(model.Delete());
   EXPECT_TRUE(model.Delete());
   EXPECT_TRUE(model.Delete());
   EXPECT_TRUE(model.Delete());
   EXPECT_EQ(base::WideToUTF16(L""), model.text());
 
   // The first 2 characters are not strong directionality characters.
   model.SetText(
       base::WideToUTF16(L"\x002C\x0020\x05D1\x05BC\x05B7\x05E9\x05BC"));
-  model.MoveCursor(gfx::LINE_BREAK, gfx::CURSOR_LEFT, false);
+  model.MoveCursor(gfx::LINE_BREAK, gfx::CURSOR_LEFT, gfx::SELECTION_NONE);
   EXPECT_TRUE(model.Backspace());
   EXPECT_EQ(base::WideToUTF16(L"\x002C\x0020\x05D1\x05BC\x05B7\x05E9"),
             model.text());
 }
 
 TEST_F(TextfieldModelTest, EmptyString) {
   TextfieldModel model(NULL);
   EXPECT_EQ(base::string16(), model.text());
   EXPECT_EQ(base::string16(), model.GetSelectedText());
 
-  model.MoveCursor(gfx::CHARACTER_BREAK, gfx::CURSOR_LEFT, true);
+  model.MoveCursor(gfx::CHARACTER_BREAK, gfx::CURSOR_LEFT,
+                   gfx::SELECTION_RETAIN);
   EXPECT_EQ(0U, model.GetCursorPosition());
-  model.MoveCursor(gfx::CHARACTER_BREAK, gfx::CURSOR_RIGHT, true);
+  model.MoveCursor(gfx::CHARACTER_BREAK, gfx::CURSOR_RIGHT,
+                   gfx::SELECTION_RETAIN);
   EXPECT_EQ(0U, model.GetCursorPosition());
 
   EXPECT_EQ(base::string16(), model.GetSelectedText());
 
   EXPECT_FALSE(model.Delete());
   EXPECT_FALSE(model.Backspace());
 }
 
 TEST_F(TextfieldModelTest, Selection) {
   TextfieldModel model(NULL);
   model.Append(base::ASCIIToUTF16("HELLO"));
-  model.MoveCursor(gfx::CHARACTER_BREAK, gfx::CURSOR_RIGHT, false);
-  model.MoveCursor(gfx::CHARACTER_BREAK, gfx::CURSOR_RIGHT, true);
+  model.MoveCursor(gfx::CHARACTER_BREAK, gfx::CURSOR_RIGHT,
+                   gfx::SELECTION_NONE);
+  model.MoveCursor(gfx::CHARACTER_BREAK, gfx::CURSOR_RIGHT,
+                   gfx::SELECTION_RETAIN);
   EXPECT_STR_EQ("E", model.GetSelectedText());
-  model.MoveCursor(gfx::CHARACTER_BREAK, gfx::CURSOR_RIGHT, true);
+  model.MoveCursor(gfx::CHARACTER_BREAK, gfx::CURSOR_RIGHT,
+                   gfx::SELECTION_RETAIN);
   EXPECT_STR_EQ("EL", model.GetSelectedText());
 
-  model.MoveCursor(gfx::LINE_BREAK, gfx::CURSOR_LEFT, true);
+  model.MoveCursor(gfx::LINE_BREAK, gfx::CURSOR_LEFT, gfx::SELECTION_RETAIN);
   EXPECT_STR_EQ("H", model.GetSelectedText());
-  model.MoveCursor(gfx::LINE_BREAK, gfx::CURSOR_RIGHT, true);
+  model.MoveCursor(gfx::LINE_BREAK, gfx::CURSOR_RIGHT, gfx::SELECTION_RETAIN);
   EXPECT_STR_EQ("ELLO", model.GetSelectedText());
   model.ClearSelection();
   EXPECT_EQ(base::string16(), model.GetSelectedText());
 
   // SelectAll(false) selects towards the end.
   model.SelectAll(false);
   EXPECT_STR_EQ("HELLO", model.GetSelectedText());
   EXPECT_EQ(gfx::Range(0, 5), model.render_text()->selection());
 
   // SelectAll(true) selects towards the beginning.
   model.SelectAll(true);
   EXPECT_STR_EQ("HELLO", model.GetSelectedText());
   EXPECT_EQ(gfx::Range(5, 0), model.render_text()->selection());
 
   // Select and move cursor.
   model.SelectRange(gfx::Range(1U, 3U));
   EXPECT_STR_EQ("EL", model.GetSelectedText());
-  model.MoveCursor(gfx::CHARACTER_BREAK, gfx::CURSOR_LEFT, false);
+  model.MoveCursor(gfx::CHARACTER_BREAK, gfx::CURSOR_LEFT, gfx::SELECTION_NONE);
   EXPECT_EQ(1U, model.GetCursorPosition());
   model.SelectRange(gfx::Range(1U, 3U));
-  model.MoveCursor(gfx::CHARACTER_BREAK, gfx::CURSOR_RIGHT, false);
+  model.MoveCursor(gfx::CHARACTER_BREAK, gfx::CURSOR_RIGHT,
+                   gfx::SELECTION_NONE);
   EXPECT_EQ(3U, model.GetCursorPosition());
 
   // Select all and move cursor.
   model.SelectAll(false);
-  model.MoveCursor(gfx::CHARACTER_BREAK, gfx::CURSOR_LEFT, false);
+  model.MoveCursor(gfx::CHARACTER_BREAK, gfx::CURSOR_LEFT, gfx::SELECTION_NONE);
   EXPECT_EQ(0U, model.GetCursorPosition());
   model.SelectAll(false);
-  model.MoveCursor(gfx::CHARACTER_BREAK, gfx::CURSOR_RIGHT, false);
+  model.MoveCursor(gfx::CHARACTER_BREAK, gfx::CURSOR_RIGHT,
+                   gfx::SELECTION_NONE);
   EXPECT_EQ(5U, model.GetCursorPosition());
 }
 
 TEST_F(TextfieldModelTest, Selection_BidiWithNonSpacingMarks) {
   // Selection is a logical operation. And it should work with the arrow
   // keys doing visual movements, while the selection is logical between
   // the (logical) start and end points. Selection is simply defined as
   // the portion of text between the logical positions of the start and end
   // caret positions.
   TextfieldModel model(NULL);
   // TODO(xji): temporarily disable in platform Win since the complex script
   // characters turned into empty square due to font regression. So, not able
   // to test 2 characters belong to the same grapheme.
 #if defined(OS_LINUX)
   model.Append(base::WideToUTF16(
       L"abc\x05E9\x05BC\x05C1\x05B8\x05E0\x05B8" L"def"));
-  model.MoveCursor(gfx::CHARACTER_BREAK, gfx::CURSOR_RIGHT, false);
-  model.MoveCursor(gfx::CHARACTER_BREAK, gfx::CURSOR_RIGHT, false);
+  model.MoveCursor(gfx::CHARACTER_BREAK, gfx::CURSOR_RIGHT,
+                   gfx::SELECTION_NONE);
+  model.MoveCursor(gfx::CHARACTER_BREAK, gfx::CURSOR_RIGHT,
+                   gfx::SELECTION_NONE);
 
-  model.MoveCursor(gfx::CHARACTER_BREAK, gfx::CURSOR_RIGHT, true);
+  model.MoveCursor(gfx::CHARACTER_BREAK, gfx::CURSOR_RIGHT,
+                   gfx::SELECTION_RETAIN);
   EXPECT_EQ(gfx::Range(2, 3), model.render_text()->selection());
   EXPECT_EQ(base::WideToUTF16(L"c"), model.GetSelectedText());
 
-  model.MoveCursor(gfx::CHARACTER_BREAK, gfx::CURSOR_RIGHT, true);
+  model.MoveCursor(gfx::CHARACTER_BREAK, gfx::CURSOR_RIGHT,
+                   gfx::SELECTION_RETAIN);
   EXPECT_EQ(gfx::Range(2, 7), model.render_text()->selection());
   EXPECT_EQ(base::WideToUTF16(L"c\x05E9\x05BC\x05C1\x05B8"),
             model.GetSelectedText());
 
-  model.MoveCursor(gfx::CHARACTER_BREAK, gfx::CURSOR_RIGHT, true);
+  model.MoveCursor(gfx::CHARACTER_BREAK, gfx::CURSOR_RIGHT,
+                   gfx::SELECTION_RETAIN);
   EXPECT_EQ(gfx::Range(2, 3), model.render_text()->selection());
   EXPECT_EQ(base::WideToUTF16(L"c"), model.GetSelectedText());
 
-  model.MoveCursor(gfx::CHARACTER_BREAK, gfx::CURSOR_RIGHT, true);
+  model.MoveCursor(gfx::CHARACTER_BREAK, gfx::CURSOR_RIGHT,
+                   gfx::SELECTION_RETAIN);
   EXPECT_EQ(gfx::Range(2, 10), model.render_text()->selection());
   EXPECT_EQ(base::WideToUTF16(L"c\x05E9\x05BC\x05C1\x05B8\x05E0\x05B8" L"d"),
             model.GetSelectedText());
 
   model.ClearSelection();
   EXPECT_EQ(base::string16(), model.GetSelectedText());
   model.SelectAll(false);
   EXPECT_EQ(
       base::WideToUTF16(L"abc\x05E9\x05BC\x05C1\x05B8\x05E0\x05B8" L"def"),
       model.GetSelectedText());
 #endif
 
   // In case of "aBc", this test shows how to select "aB" or "Bc", assume 'B' is
   // an RTL character.
   model.SetText(base::WideToUTF16(L"a\x05E9" L"b"));
   MoveCursorTo(model, 0);
-  model.MoveCursor(gfx::CHARACTER_BREAK, gfx::CURSOR_RIGHT, true);
+  model.MoveCursor(gfx::CHARACTER_BREAK, gfx::CURSOR_RIGHT,
+                   gfx::SELECTION_RETAIN);
   EXPECT_EQ(base::WideToUTF16(L"a"), model.GetSelectedText());
 
-  model.MoveCursor(gfx::CHARACTER_BREAK, gfx::CURSOR_RIGHT, true);
+  model.MoveCursor(gfx::CHARACTER_BREAK, gfx::CURSOR_RIGHT,
+                   gfx::SELECTION_RETAIN);
   EXPECT_EQ(base::WideToUTF16(L"a"), model.GetSelectedText());
 
-  model.MoveCursor(gfx::CHARACTER_BREAK, gfx::CURSOR_RIGHT, true);
+  model.MoveCursor(gfx::CHARACTER_BREAK, gfx::CURSOR_RIGHT,
+                   gfx::SELECTION_RETAIN);
   EXPECT_EQ(base::WideToUTF16(L"a\x05E9" L"b"), model.GetSelectedText());
 
-  model.MoveCursor(gfx::CHARACTER_BREAK, gfx::CURSOR_RIGHT, false);
+  model.MoveCursor(gfx::CHARACTER_BREAK, gfx::CURSOR_RIGHT,
+                   gfx::SELECTION_NONE);
   EXPECT_EQ(3U, model.GetCursorPosition());
-  model.MoveCursor(gfx::CHARACTER_BREAK, gfx::CURSOR_LEFT, true);
+  model.MoveCursor(gfx::CHARACTER_BREAK, gfx::CURSOR_LEFT,
+                   gfx::SELECTION_RETAIN);
   EXPECT_EQ(base::WideToUTF16(L"b"), model.GetSelectedText());
 
-  model.MoveCursor(gfx::CHARACTER_BREAK, gfx::CURSOR_LEFT, true);
+  model.MoveCursor(gfx::CHARACTER_BREAK, gfx::CURSOR_LEFT,
+                   gfx::SELECTION_RETAIN);
   EXPECT_EQ(base::WideToUTF16(L"b"), model.GetSelectedText());
 
-  model.MoveCursor(gfx::CHARACTER_BREAK, gfx::CURSOR_LEFT, true);
+  model.MoveCursor(gfx::CHARACTER_BREAK, gfx::CURSOR_LEFT,
+                   gfx::SELECTION_RETAIN);
   EXPECT_EQ(base::WideToUTF16(L"a\x05E9" L"b"), model.GetSelectedText());
 
-  model.MoveCursor(gfx::LINE_BREAK, gfx::CURSOR_LEFT, false);
-  model.MoveCursor(gfx::CHARACTER_BREAK, gfx::CURSOR_RIGHT, true);
-  model.MoveCursor(gfx::CHARACTER_BREAK, gfx::CURSOR_RIGHT, true);
-  model.MoveCursor(gfx::CHARACTER_BREAK, gfx::CURSOR_LEFT, true);
+  model.MoveCursor(gfx::LINE_BREAK, gfx::CURSOR_LEFT, gfx::SELECTION_NONE);
+  model.MoveCursor(gfx::CHARACTER_BREAK, gfx::CURSOR_RIGHT,
+                   gfx::SELECTION_RETAIN);
+  model.MoveCursor(gfx::CHARACTER_BREAK, gfx::CURSOR_RIGHT,
+                   gfx::SELECTION_RETAIN);
+  model.MoveCursor(gfx::CHARACTER_BREAK, gfx::CURSOR_LEFT,
+                   gfx::SELECTION_RETAIN);
   EXPECT_EQ(base::WideToUTF16(L"a\x05E9"), model.GetSelectedText());
 
-  model.MoveCursor(gfx::LINE_BREAK, gfx::CURSOR_RIGHT, false);
-  model.MoveCursor(gfx::CHARACTER_BREAK, gfx::CURSOR_LEFT, true);
-  model.MoveCursor(gfx::CHARACTER_BREAK, gfx::CURSOR_LEFT, true);
-  model.MoveCursor(gfx::CHARACTER_BREAK, gfx::CURSOR_RIGHT, true);
+  model.MoveCursor(gfx::LINE_BREAK, gfx::CURSOR_RIGHT, gfx::SELECTION_NONE);
+  model.MoveCursor(gfx::CHARACTER_BREAK, gfx::CURSOR_LEFT,
+                   gfx::SELECTION_RETAIN);
+  model.MoveCursor(gfx::CHARACTER_BREAK, gfx::CURSOR_LEFT,
+                   gfx::SELECTION_RETAIN);
+  model.MoveCursor(gfx::CHARACTER_BREAK, gfx::CURSOR_RIGHT,
+                   gfx::SELECTION_RETAIN);
   EXPECT_EQ(base::WideToUTF16(L"\x05E9" L"b"), model.GetSelectedText());
 
   model.ClearSelection();
   EXPECT_EQ(base::string16(), model.GetSelectedText());
   model.SelectAll(false);
   EXPECT_EQ(base::WideToUTF16(L"a\x05E9" L"b"), model.GetSelectedText());
 }
 
 TEST_F(TextfieldModelTest, SelectionAndEdit) {
   TextfieldModel model(NULL);
   model.Append(base::ASCIIToUTF16("HELLO"));
-  model.MoveCursor(gfx::CHARACTER_BREAK, gfx::CURSOR_RIGHT, false);
-  model.MoveCursor(gfx::CHARACTER_BREAK, gfx::CURSOR_RIGHT, true);
-  model.MoveCursor(gfx::CHARACTER_BREAK, gfx::CURSOR_RIGHT, true);  // "EL"
+  model.MoveCursor(gfx::CHARACTER_BREAK, gfx::CURSOR_RIGHT,
+                   gfx::SELECTION_NONE);
+  model.MoveCursor(gfx::CHARACTER_BREAK, gfx::CURSOR_RIGHT,
+                   gfx::SELECTION_RETAIN);
+  model.MoveCursor(gfx::CHARACTER_BREAK, gfx::CURSOR_RIGHT,
+                   gfx::SELECTION_RETAIN);  // "EL"
   EXPECT_TRUE(model.Backspace());
   EXPECT_STR_EQ("HLO", model.text());
 
   model.Append(base::ASCIIToUTF16("ILL"));
-  model.MoveCursor(gfx::CHARACTER_BREAK, gfx::CURSOR_RIGHT, true);
-  model.MoveCursor(gfx::CHARACTER_BREAK, gfx::CURSOR_RIGHT, true);  // "LO"
+  model.MoveCursor(gfx::CHARACTER_BREAK, gfx::CURSOR_RIGHT,
+                   gfx::SELECTION_RETAIN);
+  model.MoveCursor(gfx::CHARACTER_BREAK, gfx::CURSOR_RIGHT,
+                   gfx::SELECTION_RETAIN);  // "LO"
   EXPECT_TRUE(model.Delete());
   EXPECT_STR_EQ("HILL", model.text());
   EXPECT_EQ(1U, model.GetCursorPosition());
-  model.MoveCursor(gfx::CHARACTER_BREAK, gfx::CURSOR_RIGHT, true);  // "I"
+  model.MoveCursor(gfx::CHARACTER_BREAK, gfx::CURSOR_RIGHT,
+                   gfx::SELECTION_RETAIN);  // "I"
   model.InsertChar('E');
   EXPECT_STR_EQ("HELL", model.text());
-  model.MoveCursor(gfx::LINE_BREAK, gfx::CURSOR_LEFT, false);
-  model.MoveCursor(gfx::CHARACTER_BREAK, gfx::CURSOR_RIGHT, true);  // "H"
+  model.MoveCursor(gfx::LINE_BREAK, gfx::CURSOR_LEFT, gfx::SELECTION_NONE);
+  model.MoveCursor(gfx::CHARACTER_BREAK, gfx::CURSOR_RIGHT,
+                   gfx::SELECTION_RETAIN);  // "H"
   model.ReplaceChar('B');
   EXPECT_STR_EQ("BELL", model.text());
-  model.MoveCursor(gfx::LINE_BREAK, gfx::CURSOR_RIGHT, false);
-  model.MoveCursor(gfx::CHARACTER_BREAK, gfx::CURSOR_LEFT, true);
-  model.MoveCursor(gfx::CHARACTER_BREAK, gfx::CURSOR_LEFT, true);  // "ELL"
+  model.MoveCursor(gfx::LINE_BREAK, gfx::CURSOR_RIGHT, gfx::SELECTION_NONE);
+  model.MoveCursor(gfx::CHARACTER_BREAK, gfx::CURSOR_LEFT,
+                   gfx::SELECTION_RETAIN);
+  model.MoveCursor(gfx::CHARACTER_BREAK, gfx::CURSOR_LEFT,
+                   gfx::SELECTION_RETAIN);  // "ELL"
   model.ReplaceChar('E');
   EXPECT_STR_EQ("BEE", model.text());
 }
 
 TEST_F(TextfieldModelTest, Word) {
   TextfieldModel model(NULL);
   model.Append(
       base::ASCIIToUTF16("The answer to Life, the Universe, and Everything"));
-  model.MoveCursor(gfx::WORD_BREAK, gfx::CURSOR_RIGHT, false);
+  model.MoveCursor(gfx::WORD_BREAK, gfx::CURSOR_RIGHT, gfx::SELECTION_NONE);
   EXPECT_EQ(3U, model.GetCursorPosition());
-  model.MoveCursor(gfx::WORD_BREAK, gfx::CURSOR_RIGHT, false);
+  model.MoveCursor(gfx::WORD_BREAK, gfx::CURSOR_RIGHT, gfx::SELECTION_NONE);
   EXPECT_EQ(10U, model.GetCursorPosition());
-  model.MoveCursor(gfx::WORD_BREAK, gfx::CURSOR_RIGHT, false);
-  model.MoveCursor(gfx::WORD_BREAK, gfx::CURSOR_RIGHT, false);
+  model.MoveCursor(gfx::WORD_BREAK, gfx::CURSOR_RIGHT, gfx::SELECTION_NONE);
+  model.MoveCursor(gfx::WORD_BREAK, gfx::CURSOR_RIGHT, gfx::SELECTION_NONE);
   EXPECT_EQ(18U, model.GetCursorPosition());
 
   // Should passes the non word char ','
-  model.MoveCursor(gfx::WORD_BREAK, gfx::CURSOR_RIGHT, true);
+  model.MoveCursor(gfx::WORD_BREAK, gfx::CURSOR_RIGHT, gfx::SELECTION_RETAIN);
   EXPECT_EQ(23U, model.GetCursorPosition());
   EXPECT_STR_EQ(", the", model.GetSelectedText());
 
   // Move to the end.
-  model.MoveCursor(gfx::WORD_BREAK, gfx::CURSOR_RIGHT, true);
-  model.MoveCursor(gfx::WORD_BREAK, gfx::CURSOR_RIGHT, true);
-  model.MoveCursor(gfx::WORD_BREAK, gfx::CURSOR_RIGHT, true);
+  model.MoveCursor(gfx::WORD_BREAK, gfx::CURSOR_RIGHT, gfx::SELECTION_RETAIN);
+  model.MoveCursor(gfx::WORD_BREAK, gfx::CURSOR_RIGHT, gfx::SELECTION_RETAIN);
+  model.MoveCursor(gfx::WORD_BREAK, gfx::CURSOR_RIGHT, gfx::SELECTION_RETAIN);
   EXPECT_STR_EQ(", the Universe, and Everything", model.GetSelectedText());
   // Should be safe to go next word at the end.
-  model.MoveCursor(gfx::WORD_BREAK, gfx::CURSOR_RIGHT, true);
+  model.MoveCursor(gfx::WORD_BREAK, gfx::CURSOR_RIGHT, gfx::SELECTION_RETAIN);
   EXPECT_STR_EQ(", the Universe, and Everything", model.GetSelectedText());
   model.InsertChar('2');
   EXPECT_EQ(19U, model.GetCursorPosition());
 
   // Now backwards.
-  model.MoveCursor(gfx::CHARACTER_BREAK, gfx::CURSOR_LEFT, false);  // leave 2.
-  model.MoveCursor(gfx::WORD_BREAK, gfx::CURSOR_LEFT, true);
+  model.MoveCursor(gfx::CHARACTER_BREAK, gfx::CURSOR_LEFT,
+                   gfx::SELECTION_NONE);  // leave 2.
+  model.MoveCursor(gfx::WORD_BREAK, gfx::CURSOR_LEFT, gfx::SELECTION_RETAIN);
   EXPECT_EQ(14U, model.GetCursorPosition());
   EXPECT_STR_EQ("Life", model.GetSelectedText());
-  model.MoveCursor(gfx::WORD_BREAK, gfx::CURSOR_LEFT, true);
+  model.MoveCursor(gfx::WORD_BREAK, gfx::CURSOR_LEFT, gfx::SELECTION_RETAIN);
   EXPECT_STR_EQ("to Life", model.GetSelectedText());
-  model.MoveCursor(gfx::WORD_BREAK, gfx::CURSOR_LEFT, true);
-  model.MoveCursor(gfx::WORD_BREAK, gfx::CURSOR_LEFT, true);
-  model.MoveCursor(gfx::WORD_BREAK, gfx::CURSOR_LEFT, true);  // Now at start.
+  model.MoveCursor(gfx::WORD_BREAK, gfx::CURSOR_LEFT, gfx::SELECTION_RETAIN);
+  model.MoveCursor(gfx::WORD_BREAK, gfx::CURSOR_LEFT, gfx::SELECTION_RETAIN);
+  model.MoveCursor(gfx::WORD_BREAK, gfx::CURSOR_LEFT,
+                   gfx::SELECTION_RETAIN);  // Now at start.
   EXPECT_STR_EQ("The answer to Life", model.GetSelectedText());
   // Should be safe to go to the previous word at the beginning.
-  model.MoveCursor(gfx::WORD_BREAK, gfx::CURSOR_LEFT, true);
+  model.MoveCursor(gfx::WORD_BREAK, gfx::CURSOR_LEFT, gfx::SELECTION_RETAIN);
   EXPECT_STR_EQ("The answer to Life", model.GetSelectedText());
   model.ReplaceChar('4');
   EXPECT_EQ(base::string16(), model.GetSelectedText());
   EXPECT_STR_EQ("42", model.text());
 }
 
 TEST_F(TextfieldModelTest, SetText) {
   TextfieldModel model(NULL);
   model.Append(base::ASCIIToUTF16("HELLO"));
-  model.MoveCursor(gfx::LINE_BREAK, gfx::CURSOR_RIGHT, false);
+  model.MoveCursor(gfx::LINE_BREAK, gfx::CURSOR_RIGHT, gfx::SELECTION_NONE);
   model.SetText(base::ASCIIToUTF16("GOODBYE"));
   EXPECT_STR_EQ("GOODBYE", model.text());
   // SetText move the cursor to the end of the new text.
   EXPECT_EQ(7U, model.GetCursorPosition());
   model.SelectAll(false);
   EXPECT_STR_EQ("GOODBYE", model.GetSelectedText());
-  model.MoveCursor(gfx::LINE_BREAK, gfx::CURSOR_RIGHT, false);
+  model.MoveCursor(gfx::LINE_BREAK, gfx::CURSOR_RIGHT, gfx::SELECTION_NONE);
   EXPECT_EQ(7U, model.GetCursorPosition());
 
   model.SetText(base::ASCIIToUTF16("BYE"));
   // Setting shorter string moves the cursor to the end of the new string.
   EXPECT_EQ(3U, model.GetCursorPosition());
   EXPECT_EQ(base::string16(), model.GetSelectedText());
   model.SetText(base::string16());
   EXPECT_EQ(0U, model.GetCursorPosition());
 }
 
 TEST_F(TextfieldModelTest, Clipboard) {
   ui::Clipboard* clipboard = ui::Clipboard::GetForCurrentThread();
   const base::string16 initial_clipboard_text =
       base::ASCIIToUTF16("initial text");
   ui::ScopedClipboardWriter(ui::CLIPBOARD_TYPE_COPY_PASTE)
       .WriteText(initial_clipboard_text);
 
   base::string16 clipboard_text;
   TextfieldModel model(NULL);
   model.Append(base::ASCIIToUTF16("HELLO WORLD"));
 
   // Cut with an empty selection should do nothing.
-  model.MoveCursor(gfx::LINE_BREAK, gfx::CURSOR_RIGHT, false);
+  model.MoveCursor(gfx::LINE_BREAK, gfx::CURSOR_RIGHT, gfx::SELECTION_NONE);
   EXPECT_FALSE(model.Cut());
   clipboard->ReadText(ui::CLIPBOARD_TYPE_COPY_PASTE, &clipboard_text);
   EXPECT_EQ(initial_clipboard_text, clipboard_text);
   EXPECT_STR_EQ("HELLO WORLD", model.text());
   EXPECT_EQ(11U, model.GetCursorPosition());
 
   // Copy with an empty selection should do nothing.
   model.Copy();
   clipboard->ReadText(ui::CLIPBOARD_TYPE_COPY_PASTE, &clipboard_text);
   EXPECT_EQ(initial_clipboard_text, clipboard_text);
@@ skipping 12 matching lines @@
   // Copy on obscured (password) text should do nothing.
   model.SelectAll(false);
   EXPECT_FALSE(model.Copy());
   clipboard->ReadText(ui::CLIPBOARD_TYPE_COPY_PASTE, &clipboard_text);
   EXPECT_EQ(initial_clipboard_text, clipboard_text);
   EXPECT_STR_EQ("HELLO WORLD", model.text());
   EXPECT_STR_EQ("HELLO WORLD", model.GetSelectedText());
 
   // Cut with non-empty selection.
   model.render_text()->SetObscured(false);
-  model.MoveCursor(gfx::LINE_BREAK, gfx::CURSOR_RIGHT, false);
-  model.MoveCursor(gfx::WORD_BREAK, gfx::CURSOR_LEFT, true);
+  model.MoveCursor(gfx::LINE_BREAK, gfx::CURSOR_RIGHT, gfx::SELECTION_NONE);
+  model.MoveCursor(gfx::WORD_BREAK, gfx::CURSOR_LEFT, gfx::SELECTION_RETAIN);
   EXPECT_TRUE(model.Cut());
   clipboard->ReadText(ui::CLIPBOARD_TYPE_COPY_PASTE, &clipboard_text);
   EXPECT_STR_EQ("WORLD", clipboard_text);
   EXPECT_STR_EQ("HELLO ", model.text());
   EXPECT_EQ(6U, model.GetCursorPosition());
 
   // Copy with non-empty selection.
   model.SelectAll(false);
   EXPECT_TRUE(model.Copy());
   clipboard->ReadText(ui::CLIPBOARD_TYPE_COPY_PASTE, &clipboard_text);
   EXPECT_STR_EQ("HELLO ", clipboard_text);
   EXPECT_STR_EQ("HELLO ", model.text());
   EXPECT_EQ(6U, model.GetCursorPosition());
 
   // Test that paste works regardless of the obscured bit. Please note that
   // trailing spaces and tabs in clipboard strings will be stripped.
-  model.MoveCursor(gfx::LINE_BREAK, gfx::CURSOR_RIGHT, false);
+  model.MoveCursor(gfx::LINE_BREAK, gfx::CURSOR_RIGHT, gfx::SELECTION_NONE);
   EXPECT_TRUE(model.Paste());
   EXPECT_STR_EQ("HELLO HELLO", model.text());
   EXPECT_EQ(11U, model.GetCursorPosition());
   model.render_text()->SetObscured(true);
   EXPECT_TRUE(model.Paste());
   EXPECT_STR_EQ("HELLO HELLOHELLO", model.text());
   EXPECT_EQ(16U, model.GetCursorPosition());
 }
 
 static void SelectWordTestVerifier(
     const TextfieldModel& model,
     const base::string16 &expected_selected_string,
     size_t expected_cursor_pos) {
   EXPECT_EQ(expected_selected_string, model.GetSelectedText());
   EXPECT_EQ(expected_cursor_pos, model.GetCursorPosition());
 }
 
 TEST_F(TextfieldModelTest, SelectWordTest) {
   TextfieldModel model(NULL);
   model.Append(base::ASCIIToUTF16("  HELLO  !!  WO     RLD "));
 
   // Test when cursor is at the beginning.
-  model.MoveCursor(gfx::LINE_BREAK, gfx::CURSOR_LEFT, false);
+  model.MoveCursor(gfx::LINE_BREAK, gfx::CURSOR_LEFT, gfx::SELECTION_NONE);
   model.SelectWord();
   SelectWordTestVerifier(model, base::ASCIIToUTF16("  "), 2U);
 
   // Test when cursor is at the beginning of a word.
   MoveCursorTo(model, 2);
   model.SelectWord();
   SelectWordTestVerifier(model, base::ASCIIToUTF16("HELLO"), 7U);
 
   // Test when cursor is at the end of a word.
   MoveCursorTo(model, 15);
   model.SelectWord();
   SelectWordTestVerifier(model, base::ASCIIToUTF16("     "), 20U);
 
   // Test when cursor is somewhere in a non-alpha-numeric fragment.
   for (size_t cursor_pos = 8; cursor_pos < 13U; cursor_pos++) {
     MoveCursorTo(model, cursor_pos);
     model.SelectWord();
     SelectWordTestVerifier(model, base::ASCIIToUTF16("  !!  "), 13U);
   }
 
   // Test when cursor is somewhere in a whitespace fragment.
   MoveCursorTo(model, 17);
   model.SelectWord();
   SelectWordTestVerifier(model, base::ASCIIToUTF16("     "), 20U);
 
   // Test when cursor is at the end.
-  model.MoveCursor(gfx::LINE_BREAK, gfx::CURSOR_RIGHT, false);
+  model.MoveCursor(gfx::LINE_BREAK, gfx::CURSOR_RIGHT, gfx::SELECTION_NONE);
   model.SelectWord();
   SelectWordTestVerifier(model, base::ASCIIToUTF16(" "), 24U);
 }
 
 // TODO(xji): temporarily disable in platform Win since the complex script
 // characters and Chinese characters are turned into empty square due to font
 // regression.
 #if defined(OS_LINUX)
 TEST_F(TextfieldModelTest, SelectWordTest_MixScripts) {
   TextfieldModel model(NULL);
   std::vector<WordAndCursor> word_and_cursor;
   word_and_cursor.push_back(WordAndCursor(L"a\x05d0", 2));
   word_and_cursor.push_back(WordAndCursor(L"a\x05d0", 2));
   word_and_cursor.push_back(WordAndCursor(L"\x05d1\x05d2", 5));
   word_and_cursor.push_back(WordAndCursor(L"\x05d1\x05d2", 5));
   word_and_cursor.push_back(WordAndCursor(L" ", 3));
   word_and_cursor.push_back(WordAndCursor(L"a\x05d0", 2));
   word_and_cursor.push_back(WordAndCursor(L"\x0915\x094d\x0915", 9));
   word_and_cursor.push_back(WordAndCursor(L"\x0915\x094d\x0915", 9));
   word_and_cursor.push_back(WordAndCursor(L" ", 10));
   word_and_cursor.push_back(WordAndCursor(L"\x4E2D\x56FD", 12));
   word_and_cursor.push_back(WordAndCursor(L"\x4E2D\x56FD", 12));
   word_and_cursor.push_back(WordAndCursor(L"\x82B1", 13));
   word_and_cursor.push_back(WordAndCursor(L"\x5929", 14));
 
   // The text consists of Ascii, Hebrew, Hindi with Virama sign, and Chinese.
   model.SetText(base::WideToUTF16(L"a\x05d0 \x05d1\x05d2 \x0915\x094d\x0915 "
                                   L"\x4E2D\x56FD\x82B1\x5929"));
   for (size_t i = 0; i < word_and_cursor.size(); ++i) {
-    model.MoveCursor(gfx::LINE_BREAK, gfx::CURSOR_LEFT, false);
+    model.MoveCursor(gfx::LINE_BREAK, gfx::CURSOR_LEFT, gfx::SELECTION_NONE);
     for (size_t j = 0; j < i; ++j)
-      model.MoveCursor(gfx::CHARACTER_BREAK, gfx::CURSOR_RIGHT, false);
+      model.MoveCursor(gfx::CHARACTER_BREAK, gfx::CURSOR_RIGHT,
+                       gfx::SELECTION_NONE);
     model.SelectWord();
     SelectWordTestVerifier(model, base::WideToUTF16(word_and_cursor[i].word),
                            word_and_cursor[i].cursor);
   }
 }
 #endif
 
 TEST_F(TextfieldModelTest, RangeTest) {
   TextfieldModel model(NULL);
   model.Append(base::ASCIIToUTF16("HELLO WORLD"));
-  model.MoveCursor(gfx::LINE_BREAK, gfx::CURSOR_LEFT, false);
+  model.MoveCursor(gfx::LINE_BREAK, gfx::CURSOR_LEFT, gfx::SELECTION_NONE);
   gfx::Range range = model.render_text()->selection();
   EXPECT_TRUE(range.is_empty());
   EXPECT_EQ(0U, range.start());
   EXPECT_EQ(0U, range.end());
 
-  model.MoveCursor(gfx::WORD_BREAK, gfx::CURSOR_RIGHT, true);
+  model.MoveCursor(gfx::WORD_BREAK, gfx::CURSOR_RIGHT, gfx::SELECTION_RETAIN);
   range = model.render_text()->selection();
   EXPECT_FALSE(range.is_empty());
   EXPECT_FALSE(range.is_reversed());
   EXPECT_EQ(0U, range.start());
   EXPECT_EQ(5U, range.end());
 
-  model.MoveCursor(gfx::CHARACTER_BREAK, gfx::CURSOR_LEFT, true);
+  model.MoveCursor(gfx::CHARACTER_BREAK, gfx::CURSOR_LEFT,
+                   gfx::SELECTION_RETAIN);
   range = model.render_text()->selection();
   EXPECT_FALSE(range.is_empty());
   EXPECT_EQ(0U, range.start());
   EXPECT_EQ(4U, range.end());
 
-  model.MoveCursor(gfx::WORD_BREAK, gfx::CURSOR_LEFT, true);
+  model.MoveCursor(gfx::WORD_BREAK, gfx::CURSOR_LEFT, gfx::SELECTION_RETAIN);
   range = model.render_text()->selection();
   EXPECT_TRUE(range.is_empty());
   EXPECT_EQ(0U, range.start());
   EXPECT_EQ(0U, range.end());
 
   // now from the end.
-  model.MoveCursor(gfx::LINE_BREAK, gfx::CURSOR_RIGHT, false);
+  model.MoveCursor(gfx::LINE_BREAK, gfx::CURSOR_RIGHT, gfx::SELECTION_NONE);
   range = model.render_text()->selection();
   EXPECT_TRUE(range.is_empty());
   EXPECT_EQ(11U, range.start());
   EXPECT_EQ(11U, range.end());
 
-  model.MoveCursor(gfx::WORD_BREAK, gfx::CURSOR_LEFT, true);
+  model.MoveCursor(gfx::WORD_BREAK, gfx::CURSOR_LEFT, gfx::SELECTION_RETAIN);
   range = model.render_text()->selection();
   EXPECT_FALSE(range.is_empty());
   EXPECT_TRUE(range.is_reversed());
   EXPECT_EQ(11U, range.start());
   EXPECT_EQ(6U, range.end());
 
-  model.MoveCursor(gfx::CHARACTER_BREAK, gfx::CURSOR_RIGHT, true);
+  model.MoveCursor(gfx::CHARACTER_BREAK, gfx::CURSOR_RIGHT,
+                   gfx::SELECTION_RETAIN);
   range = model.render_text()->selection();
   EXPECT_FALSE(range.is_empty());
   EXPECT_TRUE(range.is_reversed());
   EXPECT_EQ(11U, range.start());
   EXPECT_EQ(7U, range.end());
 
-  model.MoveCursor(gfx::WORD_BREAK, gfx::CURSOR_RIGHT, true);
+  model.MoveCursor(gfx::WORD_BREAK, gfx::CURSOR_RIGHT, gfx::SELECTION_RETAIN);
   range = model.render_text()->selection();
   EXPECT_TRUE(range.is_empty());
   EXPECT_EQ(11U, range.start());
   EXPECT_EQ(11U, range.end());
 
   // Select All
-  model.MoveCursor(gfx::LINE_BREAK, gfx::CURSOR_LEFT, true);
+  model.MoveCursor(gfx::LINE_BREAK, gfx::CURSOR_LEFT, gfx::SELECTION_RETAIN);
   range = model.render_text()->selection();
   EXPECT_FALSE(range.is_empty());
   EXPECT_TRUE(range.is_reversed());
   EXPECT_EQ(11U, range.start());
   EXPECT_EQ(0U, range.end());
 }
 
 TEST_F(TextfieldModelTest, SelectRangeTest) {
   TextfieldModel model(NULL);
   model.Append(base::ASCIIToUTF16("HELLO WORLD"));
@@ skipping 34 matching lines @@
 
   range = gfx::Range(1000, 1000);
   EXPECT_TRUE(range.is_empty());
   model.SelectRange(range);
   EXPECT_TRUE(model.GetSelectedText().empty());
 }
 
 TEST_F(TextfieldModelTest, SelectionTest) {
   TextfieldModel model(NULL);
   model.Append(base::ASCIIToUTF16("HELLO WORLD"));
-  model.MoveCursor(gfx::LINE_BREAK, gfx::CURSOR_LEFT, false);
+  model.MoveCursor(gfx::LINE_BREAK, gfx::CURSOR_LEFT, gfx::SELECTION_NONE);
   gfx::Range selection = model.render_text()->selection();
   EXPECT_EQ(gfx::Range(0), selection);
 
-  model.MoveCursor(gfx::WORD_BREAK, gfx::CURSOR_RIGHT, true);
+  model.MoveCursor(gfx::WORD_BREAK, gfx::CURSOR_RIGHT, gfx::SELECTION_RETAIN);
   selection = model.render_text()->selection();
   EXPECT_EQ(gfx::Range(0, 5), selection);
 
-  model.MoveCursor(gfx::CHARACTER_BREAK, gfx::CURSOR_LEFT, true);
+  model.MoveCursor(gfx::CHARACTER_BREAK, gfx::CURSOR_LEFT,
+                   gfx::SELECTION_RETAIN);
   selection = model.render_text()->selection();
   EXPECT_EQ(gfx::Range(0, 4), selection);
 
-  model.MoveCursor(gfx::WORD_BREAK, gfx::CURSOR_LEFT, true);
+  model.MoveCursor(gfx::WORD_BREAK, gfx::CURSOR_LEFT, gfx::SELECTION_RETAIN);
   selection = model.render_text()->selection();
   EXPECT_EQ(gfx::Range(0), selection);
 
   // now from the end.
-  model.MoveCursor(gfx::LINE_BREAK, gfx::CURSOR_RIGHT, false);
+  model.MoveCursor(gfx::LINE_BREAK, gfx::CURSOR_RIGHT, gfx::SELECTION_NONE);
   selection = model.render_text()->selection();
   EXPECT_EQ(gfx::Range(11), selection);
 
-  model.MoveCursor(gfx::WORD_BREAK, gfx::CURSOR_LEFT, true);
+  model.MoveCursor(gfx::WORD_BREAK, gfx::CURSOR_LEFT, gfx::SELECTION_RETAIN);
   selection = model.render_text()->selection();
   EXPECT_EQ(gfx::Range(11, 6), selection);
 
-  model.MoveCursor(gfx::CHARACTER_BREAK, gfx::CURSOR_RIGHT, true);
+  model.MoveCursor(gfx::CHARACTER_BREAK, gfx::CURSOR_RIGHT,
+                   gfx::SELECTION_RETAIN);
   selection = model.render_text()->selection();
   EXPECT_EQ(gfx::Range(11, 7), selection);
 
-  model.MoveCursor(gfx::WORD_BREAK, gfx::CURSOR_RIGHT, true);
+  model.MoveCursor(gfx::WORD_BREAK, gfx::CURSOR_RIGHT, gfx::SELECTION_RETAIN);
   selection = model.render_text()->selection();
   EXPECT_EQ(gfx::Range(11), selection);
 
   // Select All
-  model.MoveCursor(gfx::LINE_BREAK, gfx::CURSOR_LEFT, true);
+  model.MoveCursor(gfx::LINE_BREAK, gfx::CURSOR_LEFT, gfx::SELECTION_RETAIN);
   selection = model.render_text()->selection();
   EXPECT_EQ(gfx::Range(11, 0), selection);
 }
 
 TEST_F(TextfieldModelTest, SelectSelectionModelTest) {
   TextfieldModel model(NULL);
   model.Append(base::ASCIIToUTF16("HELLO WORLD"));
   model.SelectSelectionModel(gfx::SelectionModel(gfx::Range(0, 6),
       gfx::CURSOR_BACKWARD));
   EXPECT_STR_EQ("HELLO ", model.GetSelectedText());
@@ skipping 75 matching lines @@
   composition_text_confirmed_or_cleared_ = false;
   EXPECT_FALSE(model.HasCompositionText());
   EXPECT_FALSE(model.HasSelection());
   EXPECT_EQ(5U, model.GetCursorPosition());
 
   model.SetCompositionText(composition);
   EXPECT_STR_EQ("1234567890", model.text());
   EXPECT_TRUE(model.SetText(base::ASCIIToUTF16("1234567890")));
   EXPECT_TRUE(composition_text_confirmed_or_cleared_);
   composition_text_confirmed_or_cleared_ = false;
-  model.MoveCursor(gfx::LINE_BREAK, gfx::CURSOR_RIGHT, false);
+  model.MoveCursor(gfx::LINE_BREAK, gfx::CURSOR_RIGHT, gfx::SELECTION_NONE);
 
   model.SetCompositionText(composition);
   EXPECT_STR_EQ("1234567890678", model.text());
 
   model.InsertText(base::UTF8ToUTF16("-"));
   EXPECT_TRUE(composition_text_confirmed_or_cleared_);
   composition_text_confirmed_or_cleared_ = false;
   EXPECT_STR_EQ("1234567890-", model.text());
   EXPECT_FALSE(model.HasCompositionText());
   EXPECT_FALSE(model.HasSelection());
 
-  model.MoveCursor(gfx::CHARACTER_BREAK, gfx::CURSOR_LEFT, true);
+  model.MoveCursor(gfx::CHARACTER_BREAK, gfx::CURSOR_LEFT,
+                   gfx::SELECTION_RETAIN);
   EXPECT_STR_EQ("-", model.GetSelectedText());
   model.SetCompositionText(composition);
   EXPECT_STR_EQ("1234567890678", model.text());
 
   model.ReplaceText(base::UTF8ToUTF16("-"));
   EXPECT_TRUE(composition_text_confirmed_or_cleared_);
   composition_text_confirmed_or_cleared_ = false;
   EXPECT_STR_EQ("1234567890-", model.text());
   EXPECT_FALSE(model.HasCompositionText());
   EXPECT_FALSE(model.HasSelection());
@@ skipping 11 matching lines @@
   EXPECT_STR_EQ("1234567890-678-", model.text());
 
   model.SetCompositionText(composition);
   model.Backspace();
   EXPECT_TRUE(composition_text_confirmed_or_cleared_);
   composition_text_confirmed_or_cleared_ = false;
   EXPECT_STR_EQ("1234567890-678-", model.text());
 
   model.SetText(base::string16());
   model.SetCompositionText(composition);
-  model.MoveCursor(gfx::CHARACTER_BREAK, gfx::CURSOR_LEFT, false);
+  model.MoveCursor(gfx::CHARACTER_BREAK, gfx::CURSOR_LEFT, gfx::SELECTION_NONE);
   EXPECT_TRUE(composition_text_confirmed_or_cleared_);
   composition_text_confirmed_or_cleared_ = false;
   EXPECT_STR_EQ("678", model.text());
   EXPECT_EQ(2U, model.GetCursorPosition());
 
   model.SetCompositionText(composition);
-  model.MoveCursor(gfx::CHARACTER_BREAK, gfx::CURSOR_RIGHT, false);
+  model.MoveCursor(gfx::CHARACTER_BREAK, gfx::CURSOR_RIGHT,
+                   gfx::SELECTION_NONE);
   EXPECT_TRUE(composition_text_confirmed_or_cleared_);
   composition_text_confirmed_or_cleared_ = false;
   EXPECT_STR_EQ("676788", model.text());
   EXPECT_EQ(6U, model.GetCursorPosition());
 
   model.SetCompositionText(composition);
-  model.MoveCursor(gfx::WORD_BREAK, gfx::CURSOR_LEFT, false);
+  model.MoveCursor(gfx::WORD_BREAK, gfx::CURSOR_LEFT, gfx::SELECTION_NONE);
   EXPECT_TRUE(composition_text_confirmed_or_cleared_);
   composition_text_confirmed_or_cleared_ = false;
   EXPECT_STR_EQ("676788678", model.text());
 
   model.SetText(base::string16());
   model.SetCompositionText(composition);
-  model.MoveCursor(gfx::WORD_BREAK, gfx::CURSOR_RIGHT, false);
+  model.MoveCursor(gfx::WORD_BREAK, gfx::CURSOR_RIGHT, gfx::SELECTION_NONE);
   EXPECT_TRUE(composition_text_confirmed_or_cleared_);
   composition_text_confirmed_or_cleared_ = false;
 
   model.SetCompositionText(composition);
-  model.MoveCursor(gfx::LINE_BREAK, gfx::CURSOR_LEFT, true);
+  model.MoveCursor(gfx::LINE_BREAK, gfx::CURSOR_LEFT, gfx::SELECTION_RETAIN);
   EXPECT_TRUE(composition_text_confirmed_or_cleared_);
   composition_text_confirmed_or_cleared_ = false;
   EXPECT_STR_EQ("678678", model.text());
 
   model.SetCompositionText(composition);
-  model.MoveCursor(gfx::LINE_BREAK, gfx::CURSOR_RIGHT, false);
+  model.MoveCursor(gfx::LINE_BREAK, gfx::CURSOR_RIGHT, gfx::SELECTION_NONE);
   EXPECT_TRUE(composition_text_confirmed_or_cleared_);
   composition_text_confirmed_or_cleared_ = false;
   EXPECT_STR_EQ("678", model.text());
 
   model.SetCompositionText(composition);
   gfx::SelectionModel sel(
       gfx::Range(model.render_text()->selection().start(), 0),
       gfx::CURSOR_FORWARD);
   model.MoveCursorTo(sel);
   EXPECT_TRUE(composition_text_confirmed_or_cleared_);
@@ skipping 94 matching lines @@
   EXPECT_FALSE(model.Redo());
   EXPECT_STR_EQ("a", model.text());
   EXPECT_EQ(1U, model.GetCursorPosition());
 
   // Delete ===============================
   model.SetText(base::ASCIIToUTF16("ABCDE"));
   model.ClearEditHistory();
   MoveCursorTo(model, 2);
   EXPECT_TRUE(model.Delete());
   EXPECT_STR_EQ("ABDE", model.text());
-  model.MoveCursor(gfx::LINE_BREAK, gfx::CURSOR_LEFT, false);
+  model.MoveCursor(gfx::LINE_BREAK, gfx::CURSOR_LEFT, gfx::SELECTION_NONE);
   EXPECT_TRUE(model.Delete());
   EXPECT_STR_EQ("BDE", model.text());
   EXPECT_TRUE(model.Undo());
   EXPECT_STR_EQ("ABDE", model.text());
   EXPECT_EQ(0U, model.GetCursorPosition());
   EXPECT_TRUE(model.Undo());
   EXPECT_STR_EQ("ABCDE", model.text());
   EXPECT_EQ(2U, model.GetCursorPosition());
   EXPECT_TRUE(model.Redo());
   EXPECT_STR_EQ("ABDE", model.text());
@@ skipping 75 matching lines @@
 TEST_F(TextfieldModelTest, UndoRedo_BackspaceThenSetText) {
   // This is to test the undo/redo behavior of omnibox.
   TextfieldModel model(NULL);
   model.InsertChar('w');
   EXPECT_STR_EQ("w", model.text());
   EXPECT_EQ(1U, model.GetCursorPosition());
   model.SetText(base::ASCIIToUTF16("www.google.com"));
   EXPECT_EQ(14U, model.GetCursorPosition());
   EXPECT_STR_EQ("www.google.com", model.text());
   model.SetText(base::ASCIIToUTF16("www.google.com"));  // Confirm the text.
-  model.MoveCursor(gfx::LINE_BREAK, gfx::CURSOR_RIGHT, false);
+  model.MoveCursor(gfx::LINE_BREAK, gfx::CURSOR_RIGHT, gfx::SELECTION_NONE);
   EXPECT_EQ(14U, model.GetCursorPosition());
   EXPECT_TRUE(model.Backspace());
   EXPECT_TRUE(model.Backspace());
   EXPECT_STR_EQ("www.google.c", model.text());
   // Autocomplete sets the text.
   model.SetText(base::ASCIIToUTF16("www.google.com/search=www.google.c"));
   EXPECT_STR_EQ("www.google.com/search=www.google.c", model.text());
   EXPECT_TRUE(model.Undo());
   EXPECT_STR_EQ("www.google.c", model.text());
   EXPECT_TRUE(model.Undo());
@@ skipping 67 matching lines @@
   EXPECT_EQ(7U, model.GetCursorPosition());
   EXPECT_FALSE(model.Redo());
 
   // Test using SelectRange.
   model.SelectRange(gfx::Range(1, 3));
   EXPECT_TRUE(model.Cut());
   EXPECT_STR_EQ("ABCBCDE", model.text());
   EXPECT_EQ(1U, model.GetCursorPosition());
   model.SelectRange(gfx::Range(1, 1));
   EXPECT_FALSE(model.Cut());
-  model.MoveCursor(gfx::LINE_BREAK, gfx::CURSOR_RIGHT, false);
+  model.MoveCursor(gfx::LINE_BREAK, gfx::CURSOR_RIGHT, gfx::SELECTION_NONE);
   EXPECT_TRUE(model.Paste());
   EXPECT_STR_EQ("ABCBCDEBC", model.text());
   EXPECT_EQ(9U, model.GetCursorPosition());
   EXPECT_TRUE(model.Undo());
   EXPECT_STR_EQ("ABCBCDE", model.text());
   EXPECT_EQ(7U, model.GetCursorPosition());
   // An empty cut shouldn't create an edit.
   EXPECT_TRUE(model.Undo());
   EXPECT_STR_EQ("ABCBCBCDE", model.text());
   EXPECT_EQ(3U, model.GetCursorPosition());
@@ skipping 33 matching lines @@
   EXPECT_TRUE(model.Redo());
   EXPECT_STR_EQ("1232345", model.text());
   EXPECT_EQ(5U, model.GetCursorPosition());
   EXPECT_FALSE(model.Redo());
   EXPECT_STR_EQ("1232345", model.text());
 
   // Test using SelectRange.
   model.SelectRange(gfx::Range(1, 3));
   model.Copy();
   EXPECT_STR_EQ("1232345", model.text());
-  model.MoveCursor(gfx::LINE_BREAK, gfx::CURSOR_RIGHT, false);
+  model.MoveCursor(gfx::LINE_BREAK, gfx::CURSOR_RIGHT, gfx::SELECTION_NONE);
   EXPECT_TRUE(model.Paste());
   EXPECT_STR_EQ("123234523", model.text());
   EXPECT_EQ(9U, model.GetCursorPosition());
   EXPECT_TRUE(model.Undo());
   EXPECT_STR_EQ("1232345", model.text());
   EXPECT_EQ(7U, model.GetCursorPosition());
 }
 
 TEST_F(TextfieldModelTest, UndoRedo_CursorTest) {
   TextfieldModel model(NULL);
   model.InsertChar('a');
-  model.MoveCursor(gfx::CHARACTER_BREAK, gfx::CURSOR_LEFT, false);
-  model.MoveCursor(gfx::CHARACTER_BREAK, gfx::CURSOR_RIGHT, false);
+  model.MoveCursor(gfx::CHARACTER_BREAK, gfx::CURSOR_LEFT, gfx::SELECTION_NONE);
+  model.MoveCursor(gfx::CHARACTER_BREAK, gfx::CURSOR_RIGHT,
+                   gfx::SELECTION_NONE);
   model.InsertChar('b');
   // Moving the cursor shouldn't create a new edit.
   EXPECT_STR_EQ("ab", model.text());
   EXPECT_FALSE(model.Redo());
   EXPECT_TRUE(model.Undo());
   EXPECT_STR_EQ("", model.text());
   EXPECT_FALSE(model.Undo());
   EXPECT_STR_EQ("", model.text());
   EXPECT_TRUE(model.Redo());
   EXPECT_STR_EQ("ab", model.text());
@@ skipping 81 matching lines @@
 
 TEST_F(TextfieldModelTest, UndoRedo_CompositionText) {
   TextfieldModel model(NULL);
 
   ui::CompositionText composition;
   composition.text = base::ASCIIToUTF16("abc");
   composition.underlines.push_back(ui::CompositionUnderline(0, 3, 0, false));
   composition.selection = gfx::Range(2, 3);
 
   model.SetText(base::ASCIIToUTF16("ABCDE"));
-  model.MoveCursor(gfx::LINE_BREAK, gfx::CURSOR_RIGHT, false);
+  model.MoveCursor(gfx::LINE_BREAK, gfx::CURSOR_RIGHT, gfx::SELECTION_NONE);
   model.InsertChar('x');
   EXPECT_STR_EQ("ABCDEx", model.text());
   EXPECT_TRUE(model.Undo());  // set composition should forget undone edit.
   model.SetCompositionText(composition);
   EXPECT_TRUE(model.HasCompositionText());
   EXPECT_TRUE(model.HasSelection());
   EXPECT_STR_EQ("ABCDEabc", model.text());
 
   // Confirm the composition.
   model.ConfirmCompositionText();
   EXPECT_STR_EQ("ABCDEabc", model.text());
   EXPECT_TRUE(model.Undo());
   EXPECT_STR_EQ("ABCDE", model.text());
   EXPECT_TRUE(model.Undo());
   EXPECT_STR_EQ("", model.text());
   EXPECT_TRUE(model.Redo());
   EXPECT_STR_EQ("ABCDE", model.text());
   EXPECT_TRUE(model.Redo());
   EXPECT_STR_EQ("ABCDEabc", model.text());
   EXPECT_FALSE(model.Redo());
 
   // Cancel the composition.
-  model.MoveCursor(gfx::LINE_BREAK, gfx::CURSOR_LEFT, false);
+  model.MoveCursor(gfx::LINE_BREAK, gfx::CURSOR_LEFT, gfx::SELECTION_NONE);
   model.SetCompositionText(composition);
   EXPECT_STR_EQ("abcABCDEabc", model.text());
   model.CancelCompositionText();
   EXPECT_STR_EQ("ABCDEabc", model.text());
   EXPECT_FALSE(model.Redo());
   EXPECT_STR_EQ("ABCDEabc", model.text());
   EXPECT_TRUE(model.Undo());
   EXPECT_STR_EQ("ABCDE", model.text());
   EXPECT_TRUE(model.Redo());
   EXPECT_STR_EQ("ABCDEabc", model.text());
   EXPECT_FALSE(model.Redo());
 
   // Call SetText with the same text as the result.
   ResetModel(&model);
   model.SetText(base::ASCIIToUTF16("ABCDE"));
-  model.MoveCursor(gfx::LINE_BREAK, gfx::CURSOR_RIGHT, false);
+  model.MoveCursor(gfx::LINE_BREAK, gfx::CURSOR_RIGHT, gfx::SELECTION_NONE);
   model.SetCompositionText(composition);
   EXPECT_STR_EQ("ABCDEabc", model.text());
   model.SetText(base::ASCIIToUTF16("ABCDEabc"));
   EXPECT_STR_EQ("ABCDEabc", model.text());
   EXPECT_TRUE(model.Undo());
   EXPECT_STR_EQ("ABCDE", model.text());
   EXPECT_TRUE(model.Redo());
   EXPECT_STR_EQ("ABCDEabc", model.text());
   EXPECT_FALSE(model.Redo());
 
   // Call SetText with a different result; the composition should be forgotten.
   ResetModel(&model);
   model.SetText(base::ASCIIToUTF16("ABCDE"));
-  model.MoveCursor(gfx::LINE_BREAK, gfx::CURSOR_RIGHT, false);
+  model.MoveCursor(gfx::LINE_BREAK, gfx::CURSOR_RIGHT, gfx::SELECTION_NONE);
   model.SetCompositionText(composition);
   EXPECT_STR_EQ("ABCDEabc", model.text());
   model.SetText(base::ASCIIToUTF16("1234"));
   EXPECT_STR_EQ("1234", model.text());
   EXPECT_TRUE(model.Undo());
   EXPECT_STR_EQ("ABCDE", model.text());
   EXPECT_TRUE(model.Redo());
   EXPECT_STR_EQ("1234", model.text());
   EXPECT_FALSE(model.Redo());
 
   // TODO(oshima): Test the behavior with an IME.
 }
 
 // Tests that clipboard text with leading, trailing and interspersed tabs
 // spaces etc is pasted correctly. Leading and trailing tabs should be
 // stripped. Text separated by multiple tabs/spaces should be collapsed into
 // one space. Text with just tabs and spaces should be pasted as one space.
 TEST_F(TextfieldModelTest, Clipboard_WhiteSpaceStringTest) {
   // Test 1
   // Clipboard text with a leading tab should be pasted with the tab stripped.
   ui::ScopedClipboardWriter(ui::CLIPBOARD_TYPE_COPY_PASTE)
       .WriteText(base::ASCIIToUTF16("\tB"));
 
   TextfieldModel model(NULL);
   model.Append(base::ASCIIToUTF16("HELLO WORLD"));
   EXPECT_STR_EQ("HELLO WORLD", model.text());
-  model.MoveCursor(gfx::LINE_BREAK, gfx::CURSOR_RIGHT, false);
+  model.MoveCursor(gfx::LINE_BREAK, gfx::CURSOR_RIGHT, gfx::SELECTION_NONE);
   EXPECT_EQ(11U, model.GetCursorPosition());
 
   EXPECT_TRUE(model.Paste());
   EXPECT_STR_EQ("HELLO WORLDB", model.text());
 
   model.SelectAll(false);
   model.DeleteSelection();
   EXPECT_STR_EQ("", model.text());
 
   // Test 2
   // Clipboard text with multiple leading tabs and spaces should be pasted with
   // all tabs and spaces stripped.
   ui::ScopedClipboardWriter(ui::CLIPBOARD_TYPE_COPY_PASTE)
       .WriteText(base::ASCIIToUTF16("\t\t\t B"));
 
   model.Append(base::ASCIIToUTF16("HELLO WORLD"));
   EXPECT_STR_EQ("HELLO WORLD", model.text());
-  model.MoveCursor(gfx::LINE_BREAK, gfx::CURSOR_RIGHT, false);
+  model.MoveCursor(gfx::LINE_BREAK, gfx::CURSOR_RIGHT, gfx::SELECTION_NONE);
   EXPECT_EQ(11U, model.GetCursorPosition());
   EXPECT_TRUE(model.Paste());
   EXPECT_STR_EQ("HELLO WORLDB", model.text());
 
   model.SelectAll(false);
   model.DeleteSelection();
   EXPECT_STR_EQ("", model.text());
 
   // Test 3
   // Clipboard text with multiple tabs separating the words should be pasted
   // with one space replacing all tabs.
   ui::ScopedClipboardWriter(ui::CLIPBOARD_TYPE_COPY_PASTE)
       .WriteText(base::ASCIIToUTF16("FOO \t\t BAR"));
 
   model.Append(base::ASCIIToUTF16("HELLO WORLD"));
   EXPECT_STR_EQ("HELLO WORLD", model.text());
-  model.MoveCursor(gfx::LINE_BREAK, gfx::CURSOR_RIGHT, false);
+  model.MoveCursor(gfx::LINE_BREAK, gfx::CURSOR_RIGHT, gfx::SELECTION_NONE);
   EXPECT_EQ(11U, model.GetCursorPosition());
   EXPECT_TRUE(model.Paste());
   EXPECT_STR_EQ("HELLO WORLDFOO BAR", model.text());
 
   model.SelectAll(false);
   model.DeleteSelection();
   EXPECT_STR_EQ("", model.text());
 
   // Test 4
   // Clipboard text with multiple leading tabs and multiple tabs separating
@@ skipping 148 matching lines @@
   model.Backspace(true);
   model.Backspace(true);
   EXPECT_STR_EQ("aa", model.text());
 
   // Ensure yanking inserts the modified kill buffer text.
   model.Yank();
   EXPECT_STR_EQ("aad", model.text());
 }
 
 }  // namespace views