Simplify handling of BiDi cursor movement

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 "base/memory/scoped_ptr.h"
 #include "base/utf_string_conversions.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/base/l10n/l10n_util.h"
@@ skipping 269 matching lines @@
   EXPECT_EQ(1U, render_text->style_ranges().size());
   EXPECT_EQ(ui::Range(0, 1), render_text->style_ranges()[0].range);
 }
 
 void TestVisualCursorMotionInObscuredField(RenderText* render_text,
                                            const string16& text,
                                            bool select) {
   render_text->SetText(text);
   int len = text.length();
   render_text->MoveCursor(LINE_BREAK, CURSOR_RIGHT, select);
-  EXPECT_TRUE(render_text->selection_model().Equals(SelectionModel(
-      select ? 0 : len, len, len - 1, SelectionModel::TRAILING)));
+  EXPECT_EQ(SelectionModel(ui::Range(select ? 0 : len, len), CURSOR_FORWARD),
+            render_text->selection_model());
   render_text->MoveCursor(LINE_BREAK, CURSOR_LEFT, select);
-  EXPECT_TRUE(render_text->selection_model().Equals(SelectionModel(
-      0, 0, SelectionModel::LEADING)));
+  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);
-    EXPECT_TRUE(render_text->selection_model().Equals(SelectionModel(
-        select ? 0 : j, j, j - 1, SelectionModel::TRAILING)));
+    EXPECT_EQ(SelectionModel(ui::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);
-    EXPECT_TRUE(render_text->selection_model().Equals(SelectionModel(
-        select ? 0 : j, j, j, SelectionModel::LEADING)));
+    EXPECT_EQ(SelectionModel(ui::Range(select ? 0 : j, j), CURSOR_FORWARD),
+              render_text->selection_model());
   }
   render_text->MoveCursor(WORD_BREAK, CURSOR_RIGHT, select);
-  EXPECT_TRUE(render_text->selection_model().Equals(SelectionModel(
-      select ? 0 : len, len, len - 1, SelectionModel::TRAILING)));
+  EXPECT_EQ(SelectionModel(ui::Range(select ? 0 : len, len), CURSOR_FORWARD),
+            render_text->selection_model());
   render_text->MoveCursor(WORD_BREAK, CURSOR_LEFT, select);
-  EXPECT_TRUE(render_text->selection_model().Equals(SelectionModel(
-      0, 0, SelectionModel::LEADING)));
+  EXPECT_EQ(SelectionModel(0, CURSOR_BACKWARD), render_text->selection_model());
 }
 
 TEST_F(RenderTextTest, PasswordCensorship) {
   const string16 seuss = ASCIIToUTF16("hop on pop");
   const string16 no_seuss = ASCIIToUTF16("**********");
   scoped_ptr<RenderText> render_text(RenderText::CreateRenderText());
 
   // GetObscuredText 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());
 
 // TODO(benrg): No Windows implementation yet.
 #if !defined(OS_WIN)
 
   render_text->SetObscured(true);
 
   // Surrogate pairs are counted as one code point.
   const char16 invalid_surrogates[] = {0xDC00, 0xD800, 0};
   render_text->SetText(invalid_surrogates);
   EXPECT_EQ(ASCIIToUTF16("**"), render_text->GetDisplayText());
   const char16 valid_surrogates[] = {0xD800, 0xDC00, 0};
   render_text->SetText(valid_surrogates);
   EXPECT_EQ(ASCIIToUTF16("*"), render_text->GetDisplayText());
-  EXPECT_EQ(0U, render_text->GetCursorPosition());
+  EXPECT_EQ(0U, render_text->cursor_position());
   render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, false);
-  EXPECT_EQ(2U, render_text->GetCursorPosition());
+  EXPECT_EQ(2U, render_text->cursor_position());
 
   // Cursoring is independent of the underlying characters when the text is
   // obscured.
   const wchar_t* const texts[] = {
     L"hop on pop",           // word boundaries
     L"ab \x5D0\x5D1" L"12",  // bidi embedding level of 2
     L"\x5D0\x5D1" L"12",     // RTL paragraph direction on Linux
     L"\x5D0\x5D1"            // pure RTL
   };
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(texts); ++i) {
     string16 text = WideToUTF16(texts[i]);
     TestVisualCursorMotionInObscuredField(render_text.get(), text, false);
     TestVisualCursorMotionInObscuredField(render_text.get(), text, true);
   }
 #endif  // !defined(OS_WIN)
 }
 
 void RunMoveCursorLeftRightTest(RenderText* render_text,
     const std::vector<SelectionModel>& expected,
-    bool move_right) {
-  for (int i = 0; i < static_cast<int>(expected.size()); ++i) {
-    SelectionModel sel = expected[i];
-    EXPECT_TRUE(render_text->selection_model().Equals(sel));
-    if (move_right)
-      render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, false);
-    else
-      render_text->MoveCursor(CHARACTER_BREAK, CURSOR_LEFT, false);
+    VisualCursorDirection direction) {
+  for (size_t i = 0; i < expected.size(); ++i) {
+    EXPECT_EQ(expected[i], render_text->selection_model());
+    render_text->MoveCursor(CHARACTER_BREAK, direction, false);
   }
-
-  SelectionModel sel = expected[expected.size() - 1];
-  if (move_right)
-    render_text->MoveCursor(LINE_BREAK, CURSOR_RIGHT, false);
-  else
-    render_text->MoveCursor(LINE_BREAK, CURSOR_LEFT, false);
-  EXPECT_TRUE(render_text->selection_model().Equals(sel));
+  // 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);
+  EXPECT_EQ(expected.back(), render_text->selection_model());
 }
 
 TEST_F(RenderTextTest, MoveCursorLeftRightInLtr) {
   scoped_ptr<RenderText> render_text(RenderText::CreateRenderText());
 
   // Pure LTR.
   render_text->SetText(ASCIIToUTF16("abc"));
   // |expected| saves the expected SelectionModel when moving cursor from left
   // to right.
   std::vector<SelectionModel> expected;
-  expected.push_back(SelectionModel(0, 0, SelectionModel::LEADING));
-  expected.push_back(SelectionModel(1, 0, SelectionModel::TRAILING));
-  expected.push_back(SelectionModel(2, 1, SelectionModel::TRAILING));
-  expected.push_back(SelectionModel(3, 2, SelectionModel::TRAILING));
-  // The last element is to test the clamped line ends.
-  expected.push_back(SelectionModel(3, 2, SelectionModel::TRAILING));
-  RunMoveCursorLeftRightTest(render_text.get(), expected, true);
+  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_RIGHT);
 
   expected.clear();
-  expected.push_back(SelectionModel(3, 2, SelectionModel::TRAILING));
-  expected.push_back(SelectionModel(2, 2, SelectionModel::LEADING));
-  expected.push_back(SelectionModel(1, 1, SelectionModel::LEADING));
-  expected.push_back(SelectionModel(0, 0, SelectionModel::LEADING));
-  expected.push_back(SelectionModel(0, 0, SelectionModel::LEADING));
-  RunMoveCursorLeftRightTest(render_text.get(), expected, false);
+  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_LEFT);
 }
 
 TEST_F(RenderTextTest, MoveCursorLeftRightInLtrRtl) {
   scoped_ptr<RenderText> render_text(RenderText::CreateRenderText());
   // LTR-RTL
   render_text->SetText(WideToUTF16(L"abc\x05d0\x05d1\x05d2"));
   // The last one is the expected END position.
   std::vector<SelectionModel> expected;
-  expected.push_back(SelectionModel(0, 0, SelectionModel::LEADING));
-  expected.push_back(SelectionModel(1, 0, SelectionModel::TRAILING));
-  expected.push_back(SelectionModel(2, 1, SelectionModel::TRAILING));
-  expected.push_back(SelectionModel(3, 2, SelectionModel::TRAILING));
-  expected.push_back(SelectionModel(5, 5, SelectionModel::LEADING));
-  expected.push_back(SelectionModel(4, 4, SelectionModel::LEADING));
-  expected.push_back(SelectionModel(3, 3, SelectionModel::LEADING));
-  expected.push_back(SelectionModel(6, 3, SelectionModel::LEADING));
-  expected.push_back(SelectionModel(6, 3, SelectionModel::LEADING));
-  RunMoveCursorLeftRightTest(render_text.get(), expected, true);
+  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_RIGHT);
 
   expected.clear();
-  expected.push_back(SelectionModel(6, 3, SelectionModel::LEADING));
-  expected.push_back(SelectionModel(4, 3, SelectionModel::TRAILING));
-  expected.push_back(SelectionModel(5, 4, SelectionModel::TRAILING));
-  expected.push_back(SelectionModel(6, 5, SelectionModel::TRAILING));
-  expected.push_back(SelectionModel(2, 2, SelectionModel::LEADING));
-  expected.push_back(SelectionModel(1, 1, SelectionModel::LEADING));
-  expected.push_back(SelectionModel(0, 0, SelectionModel::LEADING));
-  expected.push_back(SelectionModel(0, 0, SelectionModel::LEADING));
-  RunMoveCursorLeftRightTest(render_text.get(), expected, false);
+  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_LEFT);
 }
 
 TEST_F(RenderTextTest, MoveCursorLeftRightInLtrRtlLtr) {
   scoped_ptr<RenderText> render_text(RenderText::CreateRenderText());
   // LTR-RTL-LTR.
   render_text->SetText(WideToUTF16(L"a"L"\x05d1"L"b"));
   std::vector<SelectionModel> expected;
-  expected.push_back(SelectionModel(0, 0, SelectionModel::LEADING));
-  expected.push_back(SelectionModel(1, 0, SelectionModel::TRAILING));
-  expected.push_back(SelectionModel(1, 1, SelectionModel::LEADING));
-  expected.push_back(SelectionModel(3, 2, SelectionModel::TRAILING));
-  expected.push_back(SelectionModel(3, 2, SelectionModel::TRAILING));
-  RunMoveCursorLeftRightTest(render_text.get(), expected, true);
+  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_RIGHT);
 
   expected.clear();
-  expected.push_back(SelectionModel(3, 2, SelectionModel::TRAILING));
-  expected.push_back(SelectionModel(2, 2, SelectionModel::LEADING));
-  expected.push_back(SelectionModel(2, 1, SelectionModel::TRAILING));
-  expected.push_back(SelectionModel(0, 0, SelectionModel::LEADING));
-  expected.push_back(SelectionModel(0, 0, SelectionModel::LEADING));
-  RunMoveCursorLeftRightTest(render_text.get(), expected, false);
+  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_LEFT);
 }
 
 TEST_F(RenderTextTest, MoveCursorLeftRightInRtl) {
   scoped_ptr<RenderText> render_text(RenderText::CreateRenderText());
   // Pure RTL.
   render_text->SetText(WideToUTF16(L"\x05d0\x05d1\x05d2"));
   render_text->MoveCursor(LINE_BREAK, CURSOR_RIGHT, false);
   std::vector<SelectionModel> expected;
 
 #if defined(OS_LINUX)
-  expected.push_back(SelectionModel(0, 0, SelectionModel::LEADING));
+  expected.push_back(SelectionModel(0, CURSOR_BACKWARD));
 #else
-  expected.push_back(SelectionModel(3, 0, SelectionModel::LEADING));
+  expected.push_back(SelectionModel(3, CURSOR_FORWARD));
 #endif
-  expected.push_back(SelectionModel(1, 0, SelectionModel::TRAILING));
-  expected.push_back(SelectionModel(2, 1, SelectionModel::TRAILING));
-  expected.push_back(SelectionModel(3, 2, SelectionModel::TRAILING));
+  expected.push_back(SelectionModel(1, CURSOR_BACKWARD));
+  expected.push_back(SelectionModel(2, CURSOR_BACKWARD));
+  expected.push_back(SelectionModel(3, CURSOR_BACKWARD));
 #if defined(OS_LINUX)
-  expected.push_back(SelectionModel(3, 2, SelectionModel::TRAILING));
+  expected.push_back(SelectionModel(3, CURSOR_FORWARD));
 #else
-  expected.push_back(SelectionModel(0, 2, SelectionModel::TRAILING));
-  // TODO(xji): expected (0, 2, TRAILING), actual (3, 0, LEADING).
-  // cursor moves from leftmost to rightmost.
-  // expected.push_back(SelectionModel(0, 2, SelectionModel::TRAILING));
+  expected.push_back(SelectionModel(0, CURSOR_BACKWARD));
 #endif
-  RunMoveCursorLeftRightTest(render_text.get(), expected, false);
+  RunMoveCursorLeftRightTest(render_text.get(), expected, CURSOR_LEFT);
 
   expected.clear();
 
 #if defined(OS_LINUX)
-  expected.push_back(SelectionModel(3, 2, SelectionModel::TRAILING));
+  expected.push_back(SelectionModel(3, CURSOR_FORWARD));
 #else
-  expected.push_back(SelectionModel(0, 2, SelectionModel::TRAILING));
+  expected.push_back(SelectionModel(0, CURSOR_BACKWARD));
 #endif
-  expected.push_back(SelectionModel(2, 2, SelectionModel::LEADING));
-  expected.push_back(SelectionModel(1, 1, SelectionModel::LEADING));
-  expected.push_back(SelectionModel(0, 0, SelectionModel::LEADING));
+  expected.push_back(SelectionModel(2, CURSOR_FORWARD));
+  expected.push_back(SelectionModel(1, CURSOR_FORWARD));
+  expected.push_back(SelectionModel(0, CURSOR_FORWARD));
 #if defined(OS_LINUX)
-  expected.push_back(SelectionModel(0, 0, SelectionModel::LEADING));
+  expected.push_back(SelectionModel(0, CURSOR_BACKWARD));
 #else
-  expected.push_back(SelectionModel(3, 0, SelectionModel::LEADING));
-  expected.push_back(SelectionModel(3, 0, SelectionModel::LEADING));
+  expected.push_back(SelectionModel(3, CURSOR_FORWARD));
 #endif
-  RunMoveCursorLeftRightTest(render_text.get(), expected, true);
+  RunMoveCursorLeftRightTest(render_text.get(), expected, CURSOR_RIGHT);
 }
 
 TEST_F(RenderTextTest, MoveCursorLeftRightInRtlLtr) {
   scoped_ptr<RenderText> render_text(RenderText::CreateRenderText());
   // RTL-LTR
   render_text->SetText(WideToUTF16(L"\x05d0\x05d1\x05d2"L"abc"));
   render_text->MoveCursor(LINE_BREAK, CURSOR_RIGHT, false);
   std::vector<SelectionModel> expected;
 #if defined(OS_LINUX)
-  expected.push_back(SelectionModel(0, 0, SelectionModel::LEADING));
-  expected.push_back(SelectionModel(1, 0, SelectionModel::TRAILING));
-  expected.push_back(SelectionModel(2, 1, SelectionModel::TRAILING));
-  expected.push_back(SelectionModel(3, 2, SelectionModel::TRAILING));
-  expected.push_back(SelectionModel(5, 5, SelectionModel::LEADING));
-  expected.push_back(SelectionModel(4, 4, SelectionModel::LEADING));
-  expected.push_back(SelectionModel(3, 3, SelectionModel::LEADING));
-  expected.push_back(SelectionModel(6, 3, SelectionModel::LEADING));
-  expected.push_back(SelectionModel(6, 3, SelectionModel::LEADING));
+  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));
 #else
-  expected.push_back(SelectionModel(6, 5, SelectionModel::TRAILING));
-  expected.push_back(SelectionModel(5, 5, SelectionModel::LEADING));
-  expected.push_back(SelectionModel(4, 4, SelectionModel::LEADING));
-  expected.push_back(SelectionModel(3, 3, SelectionModel::LEADING));
-  expected.push_back(SelectionModel(1, 0, SelectionModel::TRAILING));
-  expected.push_back(SelectionModel(2, 1, SelectionModel::TRAILING));
-  expected.push_back(SelectionModel(3, 2, SelectionModel::TRAILING));
-  expected.push_back(SelectionModel(0, 2, SelectionModel::TRAILING));
-  // TODO(xji): expected (0, 2, TRAILING), actual (3, 0, LEADING).
-  // cursor moves from leftmost to middle.
-  // expected.push_back(SelectionModel(0, 2, SelectionModel::TRAILING));
+  expected.push_back(SelectionModel(6, 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(1, CURSOR_BACKWARD));
+  expected.push_back(SelectionModel(2, CURSOR_BACKWARD));
+  expected.push_back(SelectionModel(3, CURSOR_BACKWARD));
+  expected.push_back(SelectionModel(0, CURSOR_BACKWARD));
 #endif
 
-  RunMoveCursorLeftRightTest(render_text.get(), expected, false);
+  RunMoveCursorLeftRightTest(render_text.get(), expected, CURSOR_LEFT);
 
   expected.clear();
 #if defined(OS_LINUX)
-  expected.push_back(SelectionModel(6, 3, SelectionModel::LEADING));
-  expected.push_back(SelectionModel(4, 3, SelectionModel::TRAILING));
-  expected.push_back(SelectionModel(5, 4, SelectionModel::TRAILING));
-  expected.push_back(SelectionModel(6, 5, SelectionModel::TRAILING));
-  expected.push_back(SelectionModel(2, 2, SelectionModel::LEADING));
-  expected.push_back(SelectionModel(1, 1, SelectionModel::LEADING));
-  expected.push_back(SelectionModel(0, 0, SelectionModel::LEADING));
-  expected.push_back(SelectionModel(0, 0, SelectionModel::LEADING));
+  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));
 #else
-  expected.push_back(SelectionModel(0, 2, SelectionModel::TRAILING));
-  expected.push_back(SelectionModel(2, 2, SelectionModel::LEADING));
-  expected.push_back(SelectionModel(1, 1, SelectionModel::LEADING));
-  expected.push_back(SelectionModel(0, 0, SelectionModel::LEADING));
-  expected.push_back(SelectionModel(4, 3, SelectionModel::TRAILING));
-  expected.push_back(SelectionModel(5, 4, SelectionModel::TRAILING));
-  expected.push_back(SelectionModel(6, 5, SelectionModel::TRAILING));
-  expected.push_back(SelectionModel(6, 5, SelectionModel::TRAILING));
+  expected.push_back(SelectionModel(0, 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(4, CURSOR_BACKWARD));
+  expected.push_back(SelectionModel(5, CURSOR_BACKWARD));
+  expected.push_back(SelectionModel(6, CURSOR_BACKWARD));
 #endif
-  RunMoveCursorLeftRightTest(render_text.get(), expected, true);
+  RunMoveCursorLeftRightTest(render_text.get(), expected, CURSOR_RIGHT);
 }
 
 TEST_F(RenderTextTest, MoveCursorLeftRightInRtlLtrRtl) {
   scoped_ptr<RenderText> render_text(RenderText::CreateRenderText());
   // RTL-LTR-RTL.
   render_text->SetText(WideToUTF16(L"\x05d0"L"a"L"\x05d1"));
   render_text->MoveCursor(LINE_BREAK, CURSOR_RIGHT, false);
   std::vector<SelectionModel> expected;
 #if defined(OS_LINUX)
-  expected.push_back(SelectionModel(0, 0, SelectionModel::LEADING));
-  expected.push_back(SelectionModel(1, 0, SelectionModel::TRAILING));
-  expected.push_back(SelectionModel(1, 1, SelectionModel::LEADING));
-  expected.push_back(SelectionModel(3, 2, SelectionModel::TRAILING));
-  expected.push_back(SelectionModel(3, 2, SelectionModel::TRAILING));
+  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));
 #else
-  expected.push_back(SelectionModel(3, 2, SelectionModel::LEADING));
-  expected.push_back(SelectionModel(3, 2, SelectionModel::TRAILING));
-  expected.push_back(SelectionModel(1, 1, SelectionModel::LEADING));
-  expected.push_back(SelectionModel(1, 0, SelectionModel::TRAILING));
-  expected.push_back(SelectionModel(0, 0, SelectionModel::TRAILING));
-  // TODO(xji): expected (0, 0, TRAILING), actual (2, 1, LEADING).
-  // cursor moves from leftmost to middle.
-  // expected.push_back(SelectionModel(0, 0, SelectionModel::TRAILING));
+  expected.push_back(SelectionModel(3, CURSOR_FORWARD));
+  expected.push_back(SelectionModel(3, CURSOR_BACKWARD));
+  expected.push_back(SelectionModel(1, CURSOR_FORWARD));
+  expected.push_back(SelectionModel(1, CURSOR_BACKWARD));
+  expected.push_back(SelectionModel(0, CURSOR_BACKWARD));
 #endif
-  RunMoveCursorLeftRightTest(render_text.get(), expected, false);
+  RunMoveCursorLeftRightTest(render_text.get(), expected, CURSOR_LEFT);
 
   expected.clear();
 #if defined(OS_LINUX)
-  expected.push_back(SelectionModel(3, 2, SelectionModel::TRAILING));
-  expected.push_back(SelectionModel(2, 2, SelectionModel::LEADING));
-  expected.push_back(SelectionModel(2, 1, SelectionModel::TRAILING));
-  expected.push_back(SelectionModel(0, 0, SelectionModel::LEADING));
-  expected.push_back(SelectionModel(0, 0, SelectionModel::LEADING));
+  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));
 #else
-  expected.push_back(SelectionModel(0, 0, SelectionModel::TRAILING));
-  expected.push_back(SelectionModel(0, 0, SelectionModel::LEADING));
-  expected.push_back(SelectionModel(2, 1, SelectionModel::TRAILING));
-  expected.push_back(SelectionModel(2, 2, SelectionModel::LEADING));
-  expected.push_back(SelectionModel(3, 2, SelectionModel::LEADING));
-  expected.push_back(SelectionModel(3, 2, SelectionModel::LEADING));
+  expected.push_back(SelectionModel(0, CURSOR_BACKWARD));
+  expected.push_back(SelectionModel(0, CURSOR_FORWARD));
+  expected.push_back(SelectionModel(2, CURSOR_BACKWARD));
+  expected.push_back(SelectionModel(2, CURSOR_FORWARD));
+  expected.push_back(SelectionModel(3, CURSOR_FORWARD));
 #endif
-  RunMoveCursorLeftRightTest(render_text.get(), expected, true);
+  RunMoveCursorLeftRightTest(render_text.get(), expected, CURSOR_RIGHT);
 }
 
 // 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)
 TEST_F(RenderTextTest, MoveCursorLeftRight_ComplexScript) {
   scoped_ptr<RenderText> render_text(RenderText::CreateRenderText());
 
   render_text->SetText(WideToUTF16(L"\x0915\x093f\x0915\x094d\x0915"));
-  EXPECT_EQ(0U, render_text->GetCursorPosition());
+  EXPECT_EQ(0U, render_text->cursor_position());
   render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, false);
-  EXPECT_EQ(2U, render_text->GetCursorPosition());
+  EXPECT_EQ(2U, render_text->cursor_position());
   render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, false);
-  EXPECT_EQ(4U, render_text->GetCursorPosition());
+  EXPECT_EQ(4U, render_text->cursor_position());
   render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, false);
-  EXPECT_EQ(5U, render_text->GetCursorPosition());
+  EXPECT_EQ(5U, render_text->cursor_position());
   render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, false);
-  EXPECT_EQ(5U, render_text->GetCursorPosition());
+  EXPECT_EQ(5U, render_text->cursor_position());
 
   render_text->MoveCursor(CHARACTER_BREAK, CURSOR_LEFT, false);
-  EXPECT_EQ(4U, render_text->GetCursorPosition());
+  EXPECT_EQ(4U, render_text->cursor_position());
   render_text->MoveCursor(CHARACTER_BREAK, CURSOR_LEFT, false);
-  EXPECT_EQ(2U, render_text->GetCursorPosition());
+  EXPECT_EQ(2U, render_text->cursor_position());
   render_text->MoveCursor(CHARACTER_BREAK, CURSOR_LEFT, false);
-  EXPECT_EQ(0U, render_text->GetCursorPosition());
+  EXPECT_EQ(0U, render_text->cursor_position());
   render_text->MoveCursor(CHARACTER_BREAK, CURSOR_LEFT, false);
-  EXPECT_EQ(0U, render_text->GetCursorPosition());
+  EXPECT_EQ(0U, render_text->cursor_position());
 }
 #endif
 
 TEST_F(RenderTextTest, GraphemePositions) {
   // LTR 2-character grapheme, LTR abc, LTR 2-character grapheme.
   const string16 kText1 = WideToUTF16(L"\x0915\x093f"L"abc"L"\x0915\x093f");
 
   // LTR ab, LTR 2-character grapheme, LTR cd.
   const string16 kText2 = WideToUTF16(L"ab"L"\x0915\x093f"L"cd");
 
@@ skipping 43 matching lines @@
     EXPECT_EQ(cases[i].expected_next, next);
     EXPECT_TRUE(render_text->IsCursorablePosition(next));
 
     size_t previous = render_text->IndexOfAdjacentGrapheme(cases[i].index,
                                                            CURSOR_BACKWARD);
     EXPECT_EQ(cases[i].expected_previous, previous);
     EXPECT_TRUE(render_text->IsCursorablePosition(previous));
   }
 }
 
-TEST_F(RenderTextTest, SelectionModels) {
+TEST_F(RenderTextTest, EdgeSelectionModels) {
   // Simple Latin text.
   const string16 kLatin = WideToUTF16(L"abc");
   // LTR 2-character grapheme.
   const string16 kLTRGrapheme = WideToUTF16(L"\x0915\x093f");
   // LTR 2-character grapheme, LTR a, LTR 2-character grapheme.
   const string16 kHindiLatin = WideToUTF16(L"\x0915\x093f"L"a"L"\x0915\x093f");
   // RTL 2-character grapheme.
   const string16 kRTLGrapheme = WideToUTF16(L"\x05e0\x05b8");
   // RTL 2-character grapheme, LTR a, RTL 2-character grapheme.
   const string16 kHebrewLatin = WideToUTF16(L"\x05e0\x05b8"L"a"L"\x05e0\x05b8");
 
   struct {
     string16 text;
-    size_t expected_left_end_caret;
-    SelectionModel::CaretPlacement expected_left_end_placement;
-    size_t expected_right_end_caret;
-    SelectionModel::CaretPlacement expected_right_end_placement;
+    base::i18n::TextDirection expected_text_direction;
   } cases[] = {
-    { string16(), 0, SelectionModel::LEADING, 0, SelectionModel::LEADING },
-    { kLatin, 0, SelectionModel::LEADING, 2, SelectionModel::TRAILING },
-    { kLTRGrapheme, 0, SelectionModel::LEADING, 0, SelectionModel::TRAILING },
-    { kHindiLatin, 0, SelectionModel::LEADING, 3, SelectionModel::TRAILING },
-    { kRTLGrapheme, 0, SelectionModel::TRAILING, 0, SelectionModel::LEADING },
+    { string16(),   base::i18n::LEFT_TO_RIGHT },
+    { kLatin,       base::i18n::LEFT_TO_RIGHT },
+    { kLTRGrapheme, base::i18n::LEFT_TO_RIGHT },
+    { kHindiLatin,  base::i18n::LEFT_TO_RIGHT },
+    { kRTLGrapheme, base::i18n::RIGHT_TO_LEFT },
 #if defined(OS_LINUX)
     // On Linux, the whole string is displayed RTL, rather than individual runs.
-    { kHebrewLatin, 3, SelectionModel::TRAILING, 0, SelectionModel::LEADING },
+    { kHebrewLatin, base::i18n::RIGHT_TO_LEFT },
 #else
-    { kHebrewLatin, 0, SelectionModel::TRAILING, 3, SelectionModel::LEADING },
+    { kHebrewLatin, base::i18n::LEFT_TO_RIGHT },
 #endif
   };
 
   // TODO(asvitkine): Disable tests that fail on XP bots due to lack of complete
   //                  font support for some scripts - http://crbug.com/106450
 #if defined(OS_WIN)
   if (base::win::GetVersion() < base::win::VERSION_VISTA)
     return;
 #endif
 
   scoped_ptr<RenderText> render_text(RenderText::CreateRenderText());
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); i++) {
     render_text->SetText(cases[i].text);
+    bool ltr = (cases[i].expected_text_direction == base::i18n::LEFT_TO_RIGHT);
 
-    SelectionModel model = render_text->EdgeSelectionModel(CURSOR_LEFT);
-    EXPECT_EQ(cases[i].expected_left_end_caret, model.caret_pos());
-    EXPECT_TRUE(render_text->IsCursorablePosition(model.caret_pos()));
-    EXPECT_EQ(cases[i].expected_left_end_placement, model.caret_placement());
+    SelectionModel start_edge =
+        render_text->EdgeSelectionModel(ltr ? CURSOR_LEFT : CURSOR_RIGHT);
+    EXPECT_EQ(start_edge, SelectionModel(0, CURSOR_BACKWARD));
 
-    model = render_text->EdgeSelectionModel(CURSOR_RIGHT);
-    EXPECT_EQ(cases[i].expected_right_end_caret, model.caret_pos());
-    EXPECT_TRUE(render_text->IsCursorablePosition(model.caret_pos()));
-    EXPECT_EQ(cases[i].expected_right_end_placement, model.caret_placement());
+    SelectionModel end_edge =
+        render_text->EdgeSelectionModel(ltr ? CURSOR_RIGHT : CURSOR_LEFT);
+    EXPECT_EQ(end_edge, SelectionModel(cases[i].text.length(), CURSOR_FORWARD));
   }
 }
 
 TEST_F(RenderTextTest, MoveCursorLeftRightWithSelection) {
   scoped_ptr<RenderText> render_text(RenderText::CreateRenderText());
   render_text->SetText(WideToUTF16(L"abc\x05d0\x05d1\x05d2"));
   // Left arrow on select ranging (6, 4).
   render_text->MoveCursor(LINE_BREAK, CURSOR_RIGHT, false);
-  EXPECT_EQ(6U, render_text->GetCursorPosition());
+  EXPECT_EQ(ui::Range(6), render_text->selection());
   render_text->MoveCursor(CHARACTER_BREAK, CURSOR_LEFT, false);
-  EXPECT_EQ(4U, render_text->GetCursorPosition());
+  EXPECT_EQ(ui::Range(4), render_text->selection());
   render_text->MoveCursor(CHARACTER_BREAK, CURSOR_LEFT, false);
-  EXPECT_EQ(5U, render_text->GetCursorPosition());
+  EXPECT_EQ(ui::Range(5), render_text->selection());
   render_text->MoveCursor(CHARACTER_BREAK, CURSOR_LEFT, false);
-  EXPECT_EQ(6U, render_text->GetCursorPosition());
+  EXPECT_EQ(ui::Range(6), render_text->selection());
   render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, true);
-  EXPECT_EQ(6U, render_text->GetSelectionStart());
-  EXPECT_EQ(5U, render_text->GetCursorPosition());
+  EXPECT_EQ(ui::Range(6, 5), render_text->selection());
   render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, true);
-  EXPECT_EQ(6U, render_text->GetSelectionStart());
-  EXPECT_EQ(4U, render_text->GetCursorPosition());
+  EXPECT_EQ(ui::Range(6, 4), render_text->selection());
   render_text->MoveCursor(CHARACTER_BREAK, CURSOR_LEFT, false);
-  EXPECT_EQ(6U, render_text->GetCursorPosition());
+  EXPECT_EQ(ui::Range(6), render_text->selection());
 
   // Right arrow on select ranging (4, 6).
   render_text->MoveCursor(LINE_BREAK, CURSOR_LEFT, false);
-  EXPECT_EQ(0U, render_text->GetCursorPosition());
+  EXPECT_EQ(ui::Range(0), render_text->selection());
   render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, false);
-  EXPECT_EQ(1U, render_text->GetCursorPosition());
+  EXPECT_EQ(ui::Range(1), render_text->selection());
   render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, false);
-  EXPECT_EQ(2U, render_text->GetCursorPosition());
+  EXPECT_EQ(ui::Range(2), render_text->selection());
   render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, false);
-  EXPECT_EQ(3U, render_text->GetCursorPosition());
+  EXPECT_EQ(ui::Range(3), render_text->selection());
   render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, false);
-  EXPECT_EQ(5U, render_text->GetCursorPosition());
+  EXPECT_EQ(ui::Range(5), render_text->selection());
   render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, false);
-  EXPECT_EQ(4U, render_text->GetCursorPosition());
+  EXPECT_EQ(ui::Range(4), render_text->selection());
   render_text->MoveCursor(CHARACTER_BREAK, CURSOR_LEFT, true);
-  EXPECT_EQ(4U, render_text->GetSelectionStart());
-  EXPECT_EQ(5U, render_text->GetCursorPosition());
+  EXPECT_EQ(ui::Range(4, 5), render_text->selection());
   render_text->MoveCursor(CHARACTER_BREAK, CURSOR_LEFT, true);
-  EXPECT_EQ(4U, render_text->GetSelectionStart());
-  EXPECT_EQ(6U, render_text->GetCursorPosition());
+  EXPECT_EQ(ui::Range(4, 6), render_text->selection());
   render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, false);
-  EXPECT_EQ(4U, render_text->GetCursorPosition());
+  EXPECT_EQ(ui::Range(4), render_text->selection());
 }
 
 // TODO(xji): Make these work on Windows.
 #if defined(OS_LINUX)
 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);
   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);
     SelectionModel end = render_text->selection_model();
-    if (end.Equals(start))  // reach the end.
+    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);
-    EXPECT_TRUE(render_text->selection_model().Equals(end));
+    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);
-      EXPECT_TRUE(render_text->selection_model().Equals(end));
+      EXPECT_EQ(end, render_text->selection_model());
     }
   }
 
   // Test moving by word from right to left.
   render_text->MoveCursor(LINE_BREAK, CURSOR_RIGHT, false);
   first_word = true;
   while (true) {
     SelectionModel start = render_text->selection_model();
     render_text->MoveCursor(WORD_BREAK, CURSOR_LEFT, false);
     SelectionModel end = render_text->selection_model();
-    if (end.Equals(start))  // reach the end.
+    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);
-    EXPECT_TRUE(render_text->selection_model().Equals(end));
+    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);
-      EXPECT_TRUE(render_text->selection_model().Equals(end));
+      EXPECT_EQ(end, render_text->selection_model());
     }
   }
 }
 
 TEST_F(RenderTextTest, MoveLeftRightByWordInBidiText) {
   scoped_ptr<RenderText> render_text(RenderText::CreateRenderText());
 
   // For testing simplicity, each word is a 3-character word.
   std::vector<const wchar_t*> test;
   test.push_back(L"abc");
@@ skipping 29 matching lines @@
 TEST_F(RenderTextTest, MoveLeftRightByWordInBidiText_TestEndOfText) {
   scoped_ptr<RenderText> render_text(RenderText::CreateRenderText());
 
   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);
-  // EXPECT_TRUE(render_text->selection_model().Equals(SelectionModel(0)));
+  // 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);
-  EXPECT_TRUE(render_text->selection_model().Equals(
-      SelectionModel(3, 2, SelectionModel::LEADING)));
+  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);
-  EXPECT_TRUE(render_text->selection_model().Equals(
-      SelectionModel(3, 2, SelectionModel::LEADING)));
+  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);
-  // EXPECT_TRUE(render_text->selection_model().Equals(SelectionModel(0)));
+  // EXPECT_EQ(SelectionModel(), render_text->selection_model());
 }
 
 TEST_F(RenderTextTest, MoveLeftRightByWordInTextWithMultiSpaces) {
   scoped_ptr<RenderText> render_text(RenderText::CreateRenderText());
   render_text->SetText(WideToUTF16(L"abc     def"));
-  render_text->MoveCursorTo(SelectionModel(5));
+  render_text->MoveCursorTo(SelectionModel(5, CURSOR_FORWARD));
   render_text->MoveCursor(WORD_BREAK, CURSOR_RIGHT, false);
-  EXPECT_EQ(11U, render_text->GetCursorPosition());
+  EXPECT_EQ(11U, render_text->cursor_position());
 
-  render_text->MoveCursorTo(SelectionModel(5));
+  render_text->MoveCursorTo(SelectionModel(5, CURSOR_FORWARD));
   render_text->MoveCursor(WORD_BREAK, CURSOR_LEFT, false);
-  EXPECT_EQ(0U, render_text->GetCursorPosition());
+  EXPECT_EQ(0U, render_text->cursor_position());
 }
 
 TEST_F(RenderTextTest, MoveLeftRightByWordInChineseText) {
   scoped_ptr<RenderText> render_text(RenderText::CreateRenderText());
   render_text->SetText(WideToUTF16(L"\x6211\x4EEC\x53BB\x516C\x56ED\x73A9"));
   render_text->MoveCursor(LINE_BREAK, CURSOR_LEFT, false);
-  EXPECT_EQ(0U, render_text->GetCursorPosition());
+  EXPECT_EQ(0U, render_text->cursor_position());
   render_text->MoveCursor(WORD_BREAK, CURSOR_RIGHT, false);
-  EXPECT_EQ(2U, render_text->GetCursorPosition());
+  EXPECT_EQ(2U, render_text->cursor_position());
   render_text->MoveCursor(WORD_BREAK, CURSOR_RIGHT, false);
-  EXPECT_EQ(3U, render_text->GetCursorPosition());
+  EXPECT_EQ(3U, render_text->cursor_position());
   render_text->MoveCursor(WORD_BREAK, CURSOR_RIGHT, false);
-  EXPECT_EQ(5U, render_text->GetCursorPosition());
+  EXPECT_EQ(5U, render_text->cursor_position());
   render_text->MoveCursor(WORD_BREAK, CURSOR_RIGHT, false);
-  EXPECT_EQ(6U, render_text->GetCursorPosition());
+  EXPECT_EQ(6U, render_text->cursor_position());
   render_text->MoveCursor(WORD_BREAK, CURSOR_RIGHT, false);
-  EXPECT_EQ(6U, render_text->GetCursorPosition());
+  EXPECT_EQ(6U, render_text->cursor_position());
 }
 
 TEST_F(RenderTextTest, StringWidthTest) {
   scoped_ptr<RenderText> render_text(RenderText::CreateRenderText());
   render_text->SetText(UTF8ToUTF16("Hello World"));
 
   // Check that width is valid
-  int width = render_text->GetStringWidth();
+  int width = render_text->GetStringSize().width();
   EXPECT_GT(width, 0);
 
   // Apply a bold style and check that the new width is greater.
   StyleRange bold;
   bold.font_style |= gfx::Font::BOLD;
   render_text->set_default_style(bold);
   render_text->ApplyDefaultStyle();
-  EXPECT_GT(render_text->GetStringWidth(), width);
+  EXPECT_GT(render_text->GetStringSize().width(), width);
 }
 
 #endif
 
 TEST_F(RenderTextTest, CursorBoundsInReplacementMode) {
   scoped_ptr<RenderText> render_text(RenderText::CreateRenderText());
   render_text->SetText(ASCIIToUTF16("abcdefg"));
   render_text->SetDisplayRect(Rect(100, 17));
-  SelectionModel sel_b(1);
-  SelectionModel sel_c(2);
+  SelectionModel sel_b(1, CURSOR_FORWARD);
+  SelectionModel sel_c(2, CURSOR_FORWARD);
   Rect cursor_around_b = render_text->GetCursorBounds(sel_b, false);
   Rect cursor_before_b = render_text->GetCursorBounds(sel_b, true);
   Rect cursor_before_c = render_text->GetCursorBounds(sel_c, true);
   EXPECT_EQ(cursor_around_b.x(), cursor_before_b.x());
   EXPECT_EQ(cursor_around_b.right(), cursor_before_c.x());
 }
 
 TEST_F(RenderTextTest, OriginForSkiaDrawing) {
   scoped_ptr<RenderText> render_text(RenderText::CreateRenderText());
   render_text->SetText(ASCIIToUTF16("abcdefg"));
@@ skipping 13 matching lines @@
   render_text->SetDisplayRect(display_rect);
 
   origin = render_text->GetOriginForSkiaDrawing();
   EXPECT_EQ(origin.x(), 0);
   EXPECT_EQ(origin.y(), 14);
 }
 
 TEST_F(RenderTextTest, DisplayRectShowsCursorLTR) {
   scoped_ptr<RenderText> render_text(RenderText::CreateRenderText());
   render_text->SetText(WideToUTF16(L"abcdefghijklmnopqrstuvwxzyabcdefg"));
-  render_text->MoveCursorTo(SelectionModel(render_text->text().length()));
-  int width = render_text->GetStringWidth();
+  render_text->MoveCursorTo(SelectionModel(render_text->text().length(),
+                                           CURSOR_FORWARD));
+  int width = render_text->GetStringSize().width();
 
   // Ensure that the cursor is placed at the width of its preceding text.
   render_text->SetDisplayRect(Rect(width + 10, 1));
   EXPECT_EQ(width, render_text->GetUpdatedCursorBounds().x());
 
   // Ensure that shrinking the display rectangle keeps the cursor in view.
   render_text->SetDisplayRect(Rect(width - 10, 1));
   EXPECT_EQ(render_text->display_rect().width() - 1,
             render_text->GetUpdatedCursorBounds().x());
 
   // Ensure that the text will pan to fill its expanding display rectangle.
   render_text->SetDisplayRect(Rect(width - 5, 1));
   EXPECT_EQ(render_text->display_rect().width() - 1,
             render_text->GetUpdatedCursorBounds().x());
 
   // Ensure that a sufficiently large display rectangle shows all the text.
   render_text->SetDisplayRect(Rect(width + 10, 1));
   EXPECT_EQ(width, render_text->GetUpdatedCursorBounds().x());
 
   // Repeat the test with RTL text.
   render_text->SetText(WideToUTF16(L"\x5d0\x5d1\x5d2\x5d3\x5d4\x5d5\x5d6\x5d7"
       L"\x5d8\x5d9\x5da\x5db\x5dc\x5dd\x5de\x5df"));
-  render_text->MoveCursorTo(SelectionModel(0));
-  width = render_text->GetStringWidth();
+  render_text->MoveCursorTo(SelectionModel(0, CURSOR_FORWARD));
+  width = render_text->GetStringSize().width();
 
   // Ensure that the cursor is placed at the width of its preceding text.
   render_text->SetDisplayRect(Rect(width + 10, 1));
   EXPECT_EQ(width, render_text->GetUpdatedCursorBounds().x());
 
   // Ensure that shrinking the display rectangle keeps the cursor in view.
   render_text->SetDisplayRect(Rect(width - 10, 1));
   EXPECT_EQ(render_text->display_rect().width() - 1,
             render_text->GetUpdatedCursorBounds().x());
 
   // Ensure that the text will pan to fill its expanding display rectangle.
   render_text->SetDisplayRect(Rect(width - 5, 1));
   EXPECT_EQ(render_text->display_rect().width() - 1,
             render_text->GetUpdatedCursorBounds().x());
 
   // Ensure that a sufficiently large display rectangle shows all the text.
   render_text->SetDisplayRect(Rect(width + 10, 1));
   EXPECT_EQ(width, render_text->GetUpdatedCursorBounds().x());
 }
 
 TEST_F(RenderTextTest, DisplayRectShowsCursorRTL) {
   // Set the locale to Hebrew for RTL UI.
   std::string locale = l10n_util::GetApplicationLocale("");
   base::i18n::SetICUDefaultLocale("he");
 
   scoped_ptr<RenderText> render_text(RenderText::CreateRenderText());
   render_text->SetText(WideToUTF16(L"abcdefghijklmnopqrstuvwxzyabcdefg"));
-  render_text->MoveCursorTo(SelectionModel(0));
-  int width = render_text->GetStringWidth();
+  render_text->MoveCursorTo(SelectionModel(0, CURSOR_FORWARD));
+  int width = render_text->GetStringSize().width();
 
   // Ensure that the cursor is placed at the width of its preceding text.
   render_text->SetDisplayRect(Rect(width + 10, 1));
   EXPECT_EQ(render_text->display_rect().width() - width - 1,
             render_text->GetUpdatedCursorBounds().x());
 
   // Ensure that shrinking the display rectangle keeps the cursor in view.
   render_text->SetDisplayRect(Rect(width - 10, 1));
   EXPECT_EQ(0, render_text->GetUpdatedCursorBounds().x());
 
   // Ensure that the text will pan to fill its expanding display rectangle.
   render_text->SetDisplayRect(Rect(width - 5, 1));
   EXPECT_EQ(0, render_text->GetUpdatedCursorBounds().x());
 
   // Ensure that a sufficiently large display rectangle shows all the text.
   render_text->SetDisplayRect(Rect(width + 10, 1));
   EXPECT_EQ(render_text->display_rect().width() - width - 1,
             render_text->GetUpdatedCursorBounds().x());
 
   // Repeat the test with RTL text.
   render_text->SetText(WideToUTF16(L"\x5d0\x5d1\x5d2\x5d3\x5d4\x5d5\x5d6\x5d7"
       L"\x5d8\x5d9\x5da\x5db\x5dc\x5dd\x5de\x5df"));
-  render_text->MoveCursorTo(SelectionModel(render_text->text().length()));
-  width = render_text->GetStringWidth();
+  render_text->MoveCursorTo(SelectionModel(render_text->text().length(),
+                                           CURSOR_FORWARD));
+  width = render_text->GetStringSize().width();
 
   // Ensure that the cursor is placed at the width of its preceding text.
   render_text->SetDisplayRect(Rect(width + 10, 1));
   EXPECT_EQ(render_text->display_rect().width() - width - 1,
             render_text->GetUpdatedCursorBounds().x());
 
   // Ensure that shrinking the display rectangle keeps the cursor in view.
   render_text->SetDisplayRect(Rect(width - 10, 1));
   EXPECT_EQ(0, render_text->GetUpdatedCursorBounds().x());
 
   // Ensure that the text will pan to fill its expanding display rectangle.
   render_text->SetDisplayRect(Rect(width - 5, 1));
   EXPECT_EQ(0, render_text->GetUpdatedCursorBounds().x());
 
   // Ensure that a sufficiently large display rectangle shows all the text.
   render_text->SetDisplayRect(Rect(width + 10, 1));
   EXPECT_EQ(render_text->display_rect().width() - width - 1,
             render_text->GetUpdatedCursorBounds().x());
 
   // Reset locale.
   base::i18n::SetICUDefaultLocale(locale);
 }
 
 }  // namespace gfx