Merge NativeTextfieldViews into views::Textfield.

ui/views/controls/textfield/textfield_views_model_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 <vector>
 
 #include "base/auto_reset.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/string16.h"
@@ skipping 56 matching lines @@
   bool composition_text_confirmed_or_cleared_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(TextfieldViewsModelTest);
 };
 
 TEST_F(TextfieldViewsModelTest, EditString) {
   TextfieldViewsModel model(NULL);
   // append two strings
   model.Append(ASCIIToUTF16("HILL"));
-  EXPECT_STR_EQ("HILL", model.GetText());
+  EXPECT_STR_EQ("HILL", model.text());
   model.Append(ASCIIToUTF16("WORLD"));
-  EXPECT_STR_EQ("HILLWORLD", model.GetText());
+  EXPECT_STR_EQ("HILLWORLD", model.text());
 
   // Insert "E" to make hello
   model.MoveCursor(gfx::CHARACTER_BREAK, gfx::CURSOR_RIGHT, false);
   model.InsertChar('E');
-  EXPECT_STR_EQ("HEILLWORLD", model.GetText());
+  EXPECT_STR_EQ("HEILLWORLD", model.text());
   // Replace "I" with "L"
   model.ReplaceChar('L');
-  EXPECT_STR_EQ("HELLLWORLD", model.GetText());
+  EXPECT_STR_EQ("HELLLWORLD", model.text());
   model.ReplaceChar('L');
   model.ReplaceChar('O');
-  EXPECT_STR_EQ("HELLOWORLD", model.GetText());
+  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.GetText());
+  EXPECT_STR_EQ("HELLOORLD", model.text());
   EXPECT_TRUE(model.Backspace());
   EXPECT_EQ(4U, model.GetCursorPosition());
-  EXPECT_STR_EQ("HELLORLD", model.GetText());
+  EXPECT_STR_EQ("HELLORLD", model.text());
 
   // Move the cursor to start. backspace should fail.
   model.MoveCursor(gfx::LINE_BREAK, gfx::CURSOR_LEFT, false);
   EXPECT_FALSE(model.Backspace());
-  EXPECT_STR_EQ("HELLORLD", model.GetText());
+  EXPECT_STR_EQ("HELLORLD", model.text());
   // Move the cursor to the end. delete should fail.
   model.MoveCursor(gfx::LINE_BREAK, gfx::CURSOR_RIGHT, false);
   EXPECT_FALSE(model.Delete());
-  EXPECT_STR_EQ("HELLORLD", model.GetText());
+  EXPECT_STR_EQ("HELLORLD", model.text());
   // but backspace should work.
   EXPECT_TRUE(model.Backspace());
-  EXPECT_STR_EQ("HELLORL", model.GetText());
+  EXPECT_STR_EQ("HELLORL", model.text());
 
   MoveCursorTo(model, 5);
   model.ReplaceText(ASCIIToUTF16(" WOR"));
-  EXPECT_STR_EQ("HELLO WORL", model.GetText());
+  EXPECT_STR_EQ("HELLO WORL", model.text());
 }
 
 TEST_F(TextfieldViewsModelTest, EditString_SimpleRTL) {
   TextfieldViewsModel model(NULL);
   // Append two strings.
   model.Append(WideToUTF16(L"\x05d0\x05d1\x05d2"));
-  EXPECT_EQ(WideToUTF16(L"\x05d0\x05d1\x05d2"), model.GetText());
+  EXPECT_EQ(WideToUTF16(L"\x05d0\x05d1\x05d2"), model.text());
   model.Append(WideToUTF16(L"\x05e0\x05e1\x05e2"));
-  EXPECT_EQ(WideToUTF16(L"\x05d0\x05d1\x05d2\x05e0\x05e1\x05e2"),
-            model.GetText());
+  EXPECT_EQ(WideToUTF16(L"\x05d0\x05d1\x05d2\x05e0\x05e1\x05e2"), model.text());
 
   // Insert 0x05f0.
   MoveCursorTo(model, 1);
   model.InsertChar(0x05f0);
   EXPECT_EQ(WideToUTF16(L"\x05d0\x05f0\x05d1\x05d2\x05e0\x05e1\x05e2"),
-            model.GetText());
+            model.text());
 
   // Replace "\x05d1" with "\x05f1".
   model.ReplaceChar(0x05f1);
   EXPECT_EQ(WideToUTF16(L"\x05d0\x05f0\x5f1\x05d2\x05e0\x05e1\x05e2"),
-            model.GetText());
+            model.text());
 
   // Delete and backspace.
   EXPECT_EQ(3U, model.GetCursorPosition());
   EXPECT_TRUE(model.Delete());
-  EXPECT_EQ(WideToUTF16(L"\x05d0\x05f0\x5f1\x05e0\x05e1\x05e2"),
-            model.GetText());
+  EXPECT_EQ(WideToUTF16(L"\x05d0\x05f0\x5f1\x05e0\x05e1\x05e2"), model.text());
   EXPECT_TRUE(model.Backspace());
   EXPECT_EQ(2U, model.GetCursorPosition());
-  EXPECT_EQ(WideToUTF16(L"\x05d0\x05f0\x05e0\x05e1\x05e2"), model.GetText());
+  EXPECT_EQ(WideToUTF16(L"\x05d0\x05f0\x05e0\x05e1\x05e2"), model.text());
 }
 
 TEST_F(TextfieldViewsModelTest, EditString_ComplexScript) {
   // TODO(asvitkine): Disable tests that fail on XP bots due to lack of complete
   //                  font support for some scripts - http://crbug.com/106450
   bool on_windows_xp = false;
 #if defined(OS_WIN)
   on_windows_xp = base::win::GetVersion() < base::win::VERSION_VISTA;
 #endif
 
   TextfieldViewsModel model(NULL);
 
   // Append two Hindi strings.
   model.Append(WideToUTF16(L"\x0915\x093f\x0915\x094d\x0915"));
-  EXPECT_EQ(WideToUTF16(L"\x0915\x093f\x0915\x094d\x0915"),
-            model.GetText());
+  EXPECT_EQ(WideToUTF16(L"\x0915\x093f\x0915\x094d\x0915"), model.text());
   model.Append(WideToUTF16(L"\x0915\x094d\x092e\x094d"));
   EXPECT_EQ(WideToUTF16(
-      L"\x0915\x093f\x0915\x094d\x0915\x0915\x094d\x092e\x094d"),
-      model.GetText());
+      L"\x0915\x093f\x0915\x094d\x0915\x0915\x094d\x092e\x094d"), model.text());
 
   // TODO(asvitkine): Disable tests that fail on XP bots due to lack of complete
   //                  font support for some scripts - http://crbug.com/106450
   if (!on_windows_xp) {
     // Check it is not able to place cursor in middle of a grapheme.
     MoveCursorTo(model, 1);
     EXPECT_EQ(0U, model.GetCursorPosition());
 
     MoveCursorTo(model, 2);
     EXPECT_EQ(2U, model.GetCursorPosition());
     model.InsertChar('a');
     EXPECT_EQ(WideToUTF16(
         L"\x0915\x093f\x0061\x0915\x094d\x0915\x0915\x094d\x092e\x094d"),
-        model.GetText());
+        model.text());
 
     // ReplaceChar will replace the whole grapheme.
     model.ReplaceChar('b');
     // 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)
     EXPECT_EQ(WideToUTF16(
         L"\x0915\x093f\x0061\x0062\x0915\x0915\x094d\x092e\x094d"),
-        model.GetText());
+        model.text());
 #endif
     EXPECT_EQ(4U, model.GetCursorPosition());
   }
 
   // Delete should delete the whole grapheme.
   MoveCursorTo(model, 0);
   // 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)
   EXPECT_TRUE(model.Delete());
   EXPECT_EQ(WideToUTF16(L"\x0061\x0062\x0915\x0915\x094d\x092e\x094d"),
-            model.GetText());
-  MoveCursorTo(model, model.GetText().length());
-  EXPECT_EQ(model.GetText().length(), model.GetCursorPosition());
+            model.text());
+  MoveCursorTo(model, model.text().length());
+  EXPECT_EQ(model.text().length(), model.GetCursorPosition());
   EXPECT_TRUE(model.Backspace());
-  EXPECT_EQ(WideToUTF16(L"\x0061\x0062\x0915\x0915\x094d\x092e"),
-            model.GetText());
+  EXPECT_EQ(WideToUTF16(L"\x0061\x0062\x0915\x0915\x094d\x092e"), model.text());
 #endif
 
   // Test cursor position and deletion for Hindi Virama.
   model.SetText(WideToUTF16(L"\x0D38\x0D4D\x0D15\x0D16\x0D2E"));
   MoveCursorTo(model, 0);
   EXPECT_EQ(0U, model.GetCursorPosition());
 
   // TODO(asvitkine): Disable tests that fail on XP bots due to lack of complete
   //                  font support for some scripts - http://crbug.com/106450
   if (!on_windows_xp) {
     MoveCursorTo(model, 1);
     EXPECT_EQ(0U, model.GetCursorPosition());
     MoveCursorTo(model, 3);
     EXPECT_EQ(3U, model.GetCursorPosition());
   }
 
   // TODO(asvitkine): Temporarily disable the following check on Windows. It
   // seems Windows treats "\x0D38\x0D4D\x0D15" as a single grapheme.
 #if !defined(OS_WIN)
   MoveCursorTo(model, 2);
   EXPECT_EQ(2U, model.GetCursorPosition());
   EXPECT_TRUE(model.Backspace());
-  EXPECT_EQ(WideToUTF16(L"\x0D38\x0D15\x0D16\x0D2E"), model.GetText());
+  EXPECT_EQ(WideToUTF16(L"\x0D38\x0D15\x0D16\x0D2E"), model.text());
 #endif
 
   model.SetText(WideToUTF16(L"\x05d5\x05b7\x05D9\x05B0\x05D4\x05B4\x05D9"));
   MoveCursorTo(model, 0);
   EXPECT_TRUE(model.Delete());
   EXPECT_TRUE(model.Delete());
   EXPECT_TRUE(model.Delete());
   EXPECT_TRUE(model.Delete());
-  EXPECT_EQ(WideToUTF16(L""), model.GetText());
+  EXPECT_EQ(WideToUTF16(L""), model.text());
 
   // The first 2 characters are not strong directionality characters.
   model.SetText(WideToUTF16(L"\x002C\x0020\x05D1\x05BC\x05B7\x05E9\x05BC"));
   model.MoveCursor(gfx::LINE_BREAK, gfx::CURSOR_LEFT, false);
   EXPECT_TRUE(model.Backspace());
-  EXPECT_EQ(WideToUTF16(L"\x002C\x0020\x05D1\x05BC\x05B7\x05E9"),
-            model.GetText());
+  EXPECT_EQ(WideToUTF16(L"\x002C\x0020\x05D1\x05BC\x05B7\x05E9"), model.text());
 }
 
 TEST_F(TextfieldViewsModelTest, EmptyString) {
   TextfieldViewsModel model(NULL);
-  EXPECT_EQ(base::string16(), model.GetText());
+  EXPECT_EQ(base::string16(), model.text());
   EXPECT_EQ(base::string16(), model.GetSelectedText());
 
   model.MoveCursor(gfx::CHARACTER_BREAK, gfx::CURSOR_LEFT, true);
   EXPECT_EQ(0U, model.GetCursorPosition());
   model.MoveCursor(gfx::CHARACTER_BREAK, gfx::CURSOR_RIGHT, true);
   EXPECT_EQ(0U, model.GetCursorPosition());
 
   EXPECT_EQ(base::string16(), model.GetSelectedText());
 
   EXPECT_FALSE(model.Delete());
@@ skipping 127 matching lines @@
   EXPECT_EQ(WideToUTF16(L"a\x05E9" L"b"), model.GetSelectedText());
 }
 
 TEST_F(TextfieldViewsModelTest, SelectionAndEdit) {
   TextfieldViewsModel model(NULL);
   model.Append(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"
   EXPECT_TRUE(model.Backspace());
-  EXPECT_STR_EQ("HLO", model.GetText());
+  EXPECT_STR_EQ("HLO", model.text());
 
   model.Append(ASCIIToUTF16("ILL"));
   model.MoveCursor(gfx::CHARACTER_BREAK, gfx::CURSOR_RIGHT, true);
   model.MoveCursor(gfx::CHARACTER_BREAK, gfx::CURSOR_RIGHT, true);  // "LO"
   EXPECT_TRUE(model.Delete());
-  EXPECT_STR_EQ("HILL", model.GetText());
+  EXPECT_STR_EQ("HILL", model.text());
   EXPECT_EQ(1U, model.GetCursorPosition());
   model.MoveCursor(gfx::CHARACTER_BREAK, gfx::CURSOR_RIGHT, true);  // "I"
   model.InsertChar('E');
-  EXPECT_STR_EQ("HELL", model.GetText());
+  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.ReplaceChar('B');
-  EXPECT_STR_EQ("BELL", model.GetText());
+  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.ReplaceChar('E');
-  EXPECT_STR_EQ("BEE", model.GetText());
+  EXPECT_STR_EQ("BEE", model.text());
 }
 
 TEST_F(TextfieldViewsModelTest, Word) {
   TextfieldViewsModel model(NULL);
   model.Append(
       ASCIIToUTF16("The answer to Life, the Universe, and Everything"));
   model.MoveCursor(gfx::WORD_BREAK, gfx::CURSOR_RIGHT, false);
   EXPECT_EQ(3U, model.GetCursorPosition());
   model.MoveCursor(gfx::WORD_BREAK, gfx::CURSOR_RIGHT, false);
   EXPECT_EQ(10U, model.GetCursorPosition());
@@ skipping 26 matching lines @@
   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.
   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);
   EXPECT_STR_EQ("The answer to Life", model.GetSelectedText());
   model.ReplaceChar('4');
   EXPECT_EQ(base::string16(), model.GetSelectedText());
-  EXPECT_STR_EQ("42", model.GetText());
+  EXPECT_STR_EQ("42", model.text());
 }
 
 TEST_F(TextfieldViewsModelTest, SetText) {
   TextfieldViewsModel model(NULL);
   model.Append(ASCIIToUTF16("HELLO"));
   model.MoveCursor(gfx::LINE_BREAK, gfx::CURSOR_RIGHT, false);
   model.SetText(ASCIIToUTF16("GOODBYE"));
-  EXPECT_STR_EQ("GOODBYE", model.GetText());
+  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);
   EXPECT_EQ(7U, model.GetCursorPosition());
 
   model.SetText(ASCIIToUTF16("BYE"));
   // Setting shorter string moves the cursor to the end of the new string.
   EXPECT_EQ(3U, model.GetCursorPosition());
@@ skipping 10 matching lines @@
 
   base::string16 clipboard_text;
   TextfieldViewsModel model(NULL);
   model.Append(ASCIIToUTF16("HELLO WORLD"));
 
   // Cut with an empty selection should do nothing.
   model.MoveCursor(gfx::LINE_BREAK, gfx::CURSOR_RIGHT, false);
   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.GetText());
+  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);
-  EXPECT_STR_EQ("HELLO WORLD", model.GetText());
+  EXPECT_STR_EQ("HELLO WORLD", model.text());
   EXPECT_EQ(11U, model.GetCursorPosition());
 
   // Cut on obscured (password) text should do nothing.
   model.render_text()->SetObscured(true);
   model.SelectAll(false);
   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.GetText());
+  EXPECT_STR_EQ("HELLO WORLD", model.text());
   EXPECT_STR_EQ("HELLO WORLD", model.GetSelectedText());
 
   // Copy on obscured 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.GetText());
+  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);
   EXPECT_TRUE(model.Cut());
   clipboard->ReadText(ui::CLIPBOARD_TYPE_COPY_PASTE, &clipboard_text);
   EXPECT_STR_EQ("WORLD", clipboard_text);
-  EXPECT_STR_EQ("HELLO ", model.GetText());
+  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.GetText());
+  EXPECT_STR_EQ("HELLO ", model.text());
   EXPECT_EQ(6U, model.GetCursorPosition());
 
   // Test that paste works regardless of the obscured bit.
   model.MoveCursor(gfx::LINE_BREAK, gfx::CURSOR_RIGHT, false);
   EXPECT_TRUE(model.Paste());
-  EXPECT_STR_EQ("HELLO HELLO ", model.GetText());
+  EXPECT_STR_EQ("HELLO HELLO ", model.text());
   EXPECT_EQ(12U, model.GetCursorPosition());
   model.render_text()->SetObscured(true);
   EXPECT_TRUE(model.Paste());
-  EXPECT_STR_EQ("HELLO HELLO HELLO ", model.GetText());
+  EXPECT_STR_EQ("HELLO HELLO HELLO ", model.text());
   EXPECT_EQ(18U, model.GetCursorPosition());
 }
 
 static void SelectWordTestVerifier(
     const TextfieldViewsModel& 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());
 }
@@ skipping 283 matching lines @@
   composition.underlines.clear();
   composition.underlines.push_back(ui::CompositionUnderline(0, 2, 0, true));
   composition.underlines.push_back(ui::CompositionUnderline(2, 3, 0, false));
   model.SetCompositionText(composition);
   EXPECT_TRUE(model.HasCompositionText());
   EXPECT_TRUE(model.HasSelection());
   EXPECT_EQ(gfx::Range(5, 7), model.render_text()->selection());
 
   model.GetTextRange(&range);
   EXPECT_EQ(10U, range.end());
-  EXPECT_STR_EQ("1234567890", model.GetText());
+  EXPECT_STR_EQ("1234567890", model.text());
 
   model.GetCompositionTextRange(&range);
   EXPECT_EQ(gfx::Range(5, 8), range);
   // composition text
   EXPECT_STR_EQ("456", model.GetTextFromRange(gfx::Range(3, 6)));
   EXPECT_EQ(gfx::Range(5, 7), model.render_text()->selection());
 
   EXPECT_FALSE(composition_text_confirmed_or_cleared_);
   model.CancelCompositionText();
   EXPECT_TRUE(composition_text_confirmed_or_cleared_);
   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.GetText());
+  EXPECT_STR_EQ("1234567890", model.text());
   EXPECT_TRUE(model.SetText(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.SetCompositionText(composition);
-  EXPECT_STR_EQ("1234567890678", model.GetText());
+  EXPECT_STR_EQ("1234567890678", model.text());
 
   model.InsertText(UTF8ToUTF16("-"));
   EXPECT_TRUE(composition_text_confirmed_or_cleared_);
   composition_text_confirmed_or_cleared_ = false;
-  EXPECT_STR_EQ("1234567890-", model.GetText());
+  EXPECT_STR_EQ("1234567890-", model.text());
   EXPECT_FALSE(model.HasCompositionText());
   EXPECT_FALSE(model.HasSelection());
 
   model.MoveCursor(gfx::CHARACTER_BREAK, gfx::CURSOR_LEFT, true);
   EXPECT_STR_EQ("-", model.GetSelectedText());
   model.SetCompositionText(composition);
-  EXPECT_STR_EQ("1234567890678", model.GetText());
+  EXPECT_STR_EQ("1234567890678", model.text());
 
   model.ReplaceText(UTF8ToUTF16("-"));
   EXPECT_TRUE(composition_text_confirmed_or_cleared_);
   composition_text_confirmed_or_cleared_ = false;
-  EXPECT_STR_EQ("1234567890-", model.GetText());
+  EXPECT_STR_EQ("1234567890-", model.text());
   EXPECT_FALSE(model.HasCompositionText());
   EXPECT_FALSE(model.HasSelection());
 
   model.SetCompositionText(composition);
   model.Append(UTF8ToUTF16("-"));
   EXPECT_TRUE(composition_text_confirmed_or_cleared_);
   composition_text_confirmed_or_cleared_ = false;
-  EXPECT_STR_EQ("1234567890-678-", model.GetText());
+  EXPECT_STR_EQ("1234567890-678-", model.text());
 
   model.SetCompositionText(composition);
   model.Delete();
   EXPECT_TRUE(composition_text_confirmed_or_cleared_);
   composition_text_confirmed_or_cleared_ = false;
-  EXPECT_STR_EQ("1234567890-678-", model.GetText());
+  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.GetText());
+  EXPECT_STR_EQ("1234567890-678-", model.text());
 
   model.SetText(base::string16());
   model.SetCompositionText(composition);
   model.MoveCursor(gfx::CHARACTER_BREAK, gfx::CURSOR_LEFT, false);
   EXPECT_TRUE(composition_text_confirmed_or_cleared_);
   composition_text_confirmed_or_cleared_ = false;
-  EXPECT_STR_EQ("678", model.GetText());
+  EXPECT_STR_EQ("678", model.text());
   EXPECT_EQ(2U, model.GetCursorPosition());
 
   model.SetCompositionText(composition);
   model.MoveCursor(gfx::CHARACTER_BREAK, gfx::CURSOR_RIGHT, false);
   EXPECT_TRUE(composition_text_confirmed_or_cleared_);
   composition_text_confirmed_or_cleared_ = false;
-  EXPECT_STR_EQ("676788", model.GetText());
+  EXPECT_STR_EQ("676788", model.text());
   EXPECT_EQ(6U, model.GetCursorPosition());
 
   model.SetCompositionText(composition);
   model.MoveCursor(gfx::WORD_BREAK, gfx::CURSOR_LEFT, false);
   EXPECT_TRUE(composition_text_confirmed_or_cleared_);
   composition_text_confirmed_or_cleared_ = false;
-  EXPECT_STR_EQ("676788678", model.GetText());
+  EXPECT_STR_EQ("676788678", model.text());
 
   model.SetText(base::string16());
   model.SetCompositionText(composition);
   model.MoveCursor(gfx::WORD_BREAK, gfx::CURSOR_RIGHT, false);
   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);
   EXPECT_TRUE(composition_text_confirmed_or_cleared_);
   composition_text_confirmed_or_cleared_ = false;
-  EXPECT_STR_EQ("678678", model.GetText());
+  EXPECT_STR_EQ("678678", model.text());
 
   model.SetCompositionText(composition);
   model.MoveCursor(gfx::LINE_BREAK, gfx::CURSOR_RIGHT, false);
   EXPECT_TRUE(composition_text_confirmed_or_cleared_);
   composition_text_confirmed_or_cleared_ = false;
-  EXPECT_STR_EQ("678", model.GetText());
+  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_);
   composition_text_confirmed_or_cleared_ = false;
-  EXPECT_STR_EQ("678678", model.GetText());
+  EXPECT_STR_EQ("678678", model.text());
 
   model.SetCompositionText(composition);
   model.SelectRange(gfx::Range(0, 3));
   EXPECT_TRUE(composition_text_confirmed_or_cleared_);
   composition_text_confirmed_or_cleared_ = false;
-  EXPECT_STR_EQ("678", model.GetText());
+  EXPECT_STR_EQ("678", model.text());
 
   model.SetCompositionText(composition);
   model.SelectAll(false);
   EXPECT_TRUE(composition_text_confirmed_or_cleared_);
   composition_text_confirmed_or_cleared_ = false;
-  EXPECT_STR_EQ("678", model.GetText());
+  EXPECT_STR_EQ("678", model.text());
 
   model.SetCompositionText(composition);
   model.SelectWord();
   EXPECT_TRUE(composition_text_confirmed_or_cleared_);
   composition_text_confirmed_or_cleared_ = false;
-  EXPECT_STR_EQ("678", model.GetText());
+  EXPECT_STR_EQ("678", model.text());
 
   model.SetCompositionText(composition);
   model.ClearSelection();
   EXPECT_TRUE(composition_text_confirmed_or_cleared_);
   composition_text_confirmed_or_cleared_ = false;
 
   model.SetCompositionText(composition);
   EXPECT_FALSE(model.Cut());
   EXPECT_FALSE(composition_text_confirmed_or_cleared_);
 }
 
 TEST_F(TextfieldViewsModelTest, UndoRedo_BasicTest) {
   TextfieldViewsModel model(NULL);
   model.InsertChar('a');
   EXPECT_FALSE(model.Redo());  // nothing to redo
   EXPECT_TRUE(model.Undo());
-  EXPECT_STR_EQ("", model.GetText());
+  EXPECT_STR_EQ("", model.text());
   EXPECT_TRUE(model.Redo());
-  EXPECT_STR_EQ("a", model.GetText());
+  EXPECT_STR_EQ("a", model.text());
 
   // Continuous inserts are treated as one edit.
   model.InsertChar('b');
   model.InsertChar('c');
-  EXPECT_STR_EQ("abc", model.GetText());
+  EXPECT_STR_EQ("abc", model.text());
   EXPECT_TRUE(model.Undo());
-  EXPECT_STR_EQ("a", model.GetText());
+  EXPECT_STR_EQ("a", model.text());
   EXPECT_EQ(1U, model.GetCursorPosition());
   EXPECT_TRUE(model.Undo());
-  EXPECT_STR_EQ("", model.GetText());
+  EXPECT_STR_EQ("", model.text());
   EXPECT_EQ(0U, model.GetCursorPosition());
 
   // Undoing further shouldn't change the text.
   EXPECT_FALSE(model.Undo());
-  EXPECT_STR_EQ("", model.GetText());
+  EXPECT_STR_EQ("", model.text());
   EXPECT_FALSE(model.Undo());
-  EXPECT_STR_EQ("", model.GetText());
+  EXPECT_STR_EQ("", model.text());
   EXPECT_EQ(0U, model.GetCursorPosition());
 
   // Redoing to the latest text.
   EXPECT_TRUE(model.Redo());
-  EXPECT_STR_EQ("a", model.GetText());
+  EXPECT_STR_EQ("a", model.text());
   EXPECT_EQ(1U, model.GetCursorPosition());
   EXPECT_TRUE(model.Redo());
-  EXPECT_STR_EQ("abc", model.GetText());
+  EXPECT_STR_EQ("abc", model.text());
   EXPECT_EQ(3U, model.GetCursorPosition());
 
   // Backspace ===============================
   EXPECT_TRUE(model.Backspace());
-  EXPECT_STR_EQ("ab", model.GetText());
+  EXPECT_STR_EQ("ab", model.text());
   EXPECT_TRUE(model.Undo());
-  EXPECT_STR_EQ("abc", model.GetText());
+  EXPECT_STR_EQ("abc", model.text());
   EXPECT_EQ(3U, model.GetCursorPosition());
   EXPECT_TRUE(model.Redo());
-  EXPECT_STR_EQ("ab", model.GetText());
+  EXPECT_STR_EQ("ab", model.text());
   EXPECT_EQ(2U, model.GetCursorPosition());
   // Continous backspaces are treated as one edit.
   EXPECT_TRUE(model.Backspace());
   EXPECT_TRUE(model.Backspace());
-  EXPECT_STR_EQ("", model.GetText());
+  EXPECT_STR_EQ("", model.text());
   // Extra backspace shouldn't affect the history.
   EXPECT_FALSE(model.Backspace());
   EXPECT_TRUE(model.Undo());
-  EXPECT_STR_EQ("ab", model.GetText());
+  EXPECT_STR_EQ("ab", model.text());
   EXPECT_EQ(2U, model.GetCursorPosition());
   EXPECT_TRUE(model.Undo());
-  EXPECT_STR_EQ("abc", model.GetText());
+  EXPECT_STR_EQ("abc", model.text());
   EXPECT_EQ(3U, model.GetCursorPosition());
   EXPECT_TRUE(model.Undo());
-  EXPECT_STR_EQ("a", model.GetText());
+  EXPECT_STR_EQ("a", model.text());
   EXPECT_EQ(1U, model.GetCursorPosition());
 
   // Clear history
   model.ClearEditHistory();
   EXPECT_FALSE(model.Undo());
   EXPECT_FALSE(model.Redo());
-  EXPECT_STR_EQ("a", model.GetText());
+  EXPECT_STR_EQ("a", model.text());
   EXPECT_EQ(1U, model.GetCursorPosition());
 
   // Delete ===============================
   model.SetText(ASCIIToUTF16("ABCDE"));
   model.ClearEditHistory();
   MoveCursorTo(model, 2);
   EXPECT_TRUE(model.Delete());
-  EXPECT_STR_EQ("ABDE", model.GetText());
+  EXPECT_STR_EQ("ABDE", model.text());
   model.MoveCursor(gfx::LINE_BREAK, gfx::CURSOR_LEFT, false);
   EXPECT_TRUE(model.Delete());
-  EXPECT_STR_EQ("BDE", model.GetText());
+  EXPECT_STR_EQ("BDE", model.text());
   EXPECT_TRUE(model.Undo());
-  EXPECT_STR_EQ("ABDE", model.GetText());
+  EXPECT_STR_EQ("ABDE", model.text());
   EXPECT_EQ(0U, model.GetCursorPosition());
   EXPECT_TRUE(model.Undo());
-  EXPECT_STR_EQ("ABCDE", model.GetText());
+  EXPECT_STR_EQ("ABCDE", model.text());
   EXPECT_EQ(2U, model.GetCursorPosition());
   EXPECT_TRUE(model.Redo());
-  EXPECT_STR_EQ("ABDE", model.GetText());
+  EXPECT_STR_EQ("ABDE", model.text());
   EXPECT_EQ(2U, model.GetCursorPosition());
   // Continous deletes are treated as one edit.
   EXPECT_TRUE(model.Delete());
   EXPECT_TRUE(model.Delete());
-  EXPECT_STR_EQ("AB", model.GetText());
+  EXPECT_STR_EQ("AB", model.text());
   EXPECT_TRUE(model.Undo());
-  EXPECT_STR_EQ("ABDE", model.GetText());
+  EXPECT_STR_EQ("ABDE", model.text());
   EXPECT_EQ(2U, model.GetCursorPosition());
   EXPECT_TRUE(model.Redo());
-  EXPECT_STR_EQ("AB", model.GetText());
+  EXPECT_STR_EQ("AB", model.text());
   EXPECT_EQ(2U, model.GetCursorPosition());
 }
 
 TEST_F(TextfieldViewsModelTest, UndoRedo_SetText) {
   // This is to test the undo/redo behavior of omnibox.
   TextfieldViewsModel model(NULL);
   model.InsertChar('w');
-  EXPECT_STR_EQ("w", model.GetText());
+  EXPECT_STR_EQ("w", model.text());
   EXPECT_EQ(1U, model.GetCursorPosition());
   model.SetText(ASCIIToUTF16("www.google.com"));
   EXPECT_EQ(14U, model.GetCursorPosition());
-  EXPECT_STR_EQ("www.google.com", model.GetText());
+  EXPECT_STR_EQ("www.google.com", model.text());
   model.SelectRange(gfx::Range(14, 1));
   model.InsertChar('w');
-  EXPECT_STR_EQ("ww", model.GetText());
+  EXPECT_STR_EQ("ww", model.text());
   model.SetText(ASCIIToUTF16("www.google.com"));
   model.SelectRange(gfx::Range(14, 2));
   model.InsertChar('w');
-  EXPECT_STR_EQ("www", model.GetText());
+  EXPECT_STR_EQ("www", model.text());
   model.SetText(ASCIIToUTF16("www.google.com"));
   model.SelectRange(gfx::Range(14, 3));
   model.InsertChar('.');
-  EXPECT_STR_EQ("www.", model.GetText());
+  EXPECT_STR_EQ("www.", model.text());
   model.SetText(ASCIIToUTF16("www.google.com"));
   model.SelectRange(gfx::Range(14, 4));
   model.InsertChar('y');
-  EXPECT_STR_EQ("www.y", model.GetText());
+  EXPECT_STR_EQ("www.y", model.text());
   model.SetText(ASCIIToUTF16("www.youtube.com"));
-  EXPECT_STR_EQ("www.youtube.com", model.GetText());
+  EXPECT_STR_EQ("www.youtube.com", model.text());
   EXPECT_EQ(15U, model.GetCursorPosition());
 
   EXPECT_TRUE(model.Undo());
-  EXPECT_STR_EQ("www.google.com", model.GetText());
+  EXPECT_STR_EQ("www.google.com", model.text());
   EXPECT_EQ(4U, model.GetCursorPosition());
   EXPECT_TRUE(model.Undo());
-  EXPECT_STR_EQ("www.google.com", model.GetText());
+  EXPECT_STR_EQ("www.google.com", model.text());
   EXPECT_EQ(3U, model.GetCursorPosition());
   EXPECT_TRUE(model.Undo());
-  EXPECT_STR_EQ("www.google.com", model.GetText());
+  EXPECT_STR_EQ("www.google.com", model.text());
   EXPECT_EQ(2U, model.GetCursorPosition());
   EXPECT_TRUE(model.Undo());
-  EXPECT_STR_EQ("www.google.com", model.GetText());
+  EXPECT_STR_EQ("www.google.com", model.text());
   EXPECT_EQ(1U, model.GetCursorPosition());
   EXPECT_TRUE(model.Undo());
-  EXPECT_STR_EQ("", model.GetText());
+  EXPECT_STR_EQ("", model.text());
   EXPECT_EQ(0U, model.GetCursorPosition());
   EXPECT_FALSE(model.Undo());
   EXPECT_TRUE(model.Redo());
-  EXPECT_STR_EQ("www.google.com", model.GetText());
+  EXPECT_STR_EQ("www.google.com", model.text());
   EXPECT_EQ(1U, model.GetCursorPosition());
   EXPECT_TRUE(model.Redo());
-  EXPECT_STR_EQ("www.google.com", model.GetText());
+  EXPECT_STR_EQ("www.google.com", model.text());
   EXPECT_EQ(2U, model.GetCursorPosition());
   EXPECT_TRUE(model.Redo());
-  EXPECT_STR_EQ("www.google.com", model.GetText());
+  EXPECT_STR_EQ("www.google.com", model.text());
   EXPECT_EQ(3U, model.GetCursorPosition());
   EXPECT_TRUE(model.Redo());
-  EXPECT_STR_EQ("www.google.com", model.GetText());
+  EXPECT_STR_EQ("www.google.com", model.text());
   EXPECT_EQ(4U, model.GetCursorPosition());
   EXPECT_TRUE(model.Redo());
-  EXPECT_STR_EQ("www.youtube.com", model.GetText());
+  EXPECT_STR_EQ("www.youtube.com", model.text());
   EXPECT_EQ(5U, model.GetCursorPosition());
   EXPECT_FALSE(model.Redo());
 }
 
 TEST_F(TextfieldViewsModelTest, UndoRedo_BackspaceThenSetText) {
   // This is to test the undo/redo behavior of omnibox.
   TextfieldViewsModel model(NULL);
   model.InsertChar('w');
-  EXPECT_STR_EQ("w", model.GetText());
+  EXPECT_STR_EQ("w", model.text());
   EXPECT_EQ(1U, model.GetCursorPosition());
   model.SetText(ASCIIToUTF16("www.google.com"));
   EXPECT_EQ(14U, model.GetCursorPosition());
-  EXPECT_STR_EQ("www.google.com", model.GetText());
+  EXPECT_STR_EQ("www.google.com", model.text());
   model.SetText(ASCIIToUTF16("www.google.com"));  // Confirm the text.
   model.MoveCursor(gfx::LINE_BREAK, gfx::CURSOR_RIGHT, false);
   EXPECT_EQ(14U, model.GetCursorPosition());
   EXPECT_TRUE(model.Backspace());
   EXPECT_TRUE(model.Backspace());
-  EXPECT_STR_EQ("www.google.c", model.GetText());
+  EXPECT_STR_EQ("www.google.c", model.text());
   // Autocomplete sets the text
   model.SetText(ASCIIToUTF16("www.google.com/search=www.google.c"));
-  EXPECT_STR_EQ("www.google.com/search=www.google.c", model.GetText());
+  EXPECT_STR_EQ("www.google.com/search=www.google.c", model.text());
   EXPECT_TRUE(model.Undo());
-  EXPECT_STR_EQ("www.google.c", model.GetText());
+  EXPECT_STR_EQ("www.google.c", model.text());
   EXPECT_TRUE(model.Undo());
-  EXPECT_STR_EQ("www.google.com", model.GetText());
+  EXPECT_STR_EQ("www.google.com", model.text());
 }
 
 TEST_F(TextfieldViewsModelTest, UndoRedo_CutCopyPasteTest) {
   TextfieldViewsModel model(NULL);
   model.SetText(ASCIIToUTF16("ABCDE"));
   EXPECT_FALSE(model.Redo());  // nothing to redo
   // Cut
   model.SelectRange(gfx::Range(1, 3));
   model.Cut();
-  EXPECT_STR_EQ("ADE", model.GetText());
+  EXPECT_STR_EQ("ADE", model.text());
   EXPECT_EQ(1U, model.GetCursorPosition());
   EXPECT_TRUE(model.Undo());
-  EXPECT_STR_EQ("ABCDE", model.GetText());
+  EXPECT_STR_EQ("ABCDE", model.text());
   EXPECT_EQ(3U, model.GetCursorPosition());
   EXPECT_TRUE(model.Undo());
-  EXPECT_STR_EQ("", model.GetText());
+  EXPECT_STR_EQ("", model.text());
   EXPECT_EQ(0U, model.GetCursorPosition());
   EXPECT_FALSE(model.Undo());  // no more undo
-  EXPECT_STR_EQ("", model.GetText());
+  EXPECT_STR_EQ("", model.text());
   EXPECT_TRUE(model.Redo());
-  EXPECT_STR_EQ("ABCDE", model.GetText());
+  EXPECT_STR_EQ("ABCDE", model.text());
   EXPECT_EQ(5U, model.GetCursorPosition());
   EXPECT_TRUE(model.Redo());
-  EXPECT_STR_EQ("ADE", model.GetText());
+  EXPECT_STR_EQ("ADE", model.text());
   EXPECT_EQ(1U, model.GetCursorPosition());
   EXPECT_FALSE(model.Redo());  // no more redo
-  EXPECT_STR_EQ("ADE", model.GetText());
+  EXPECT_STR_EQ("ADE", model.text());
 
   model.Paste();
   model.Paste();
   model.Paste();
-  EXPECT_STR_EQ("ABCBCBCDE", model.GetText());
+  EXPECT_STR_EQ("ABCBCBCDE", model.text());
   EXPECT_EQ(7U, model.GetCursorPosition());
   EXPECT_TRUE(model.Undo());
-  EXPECT_STR_EQ("ABCBCDE", model.GetText());
+  EXPECT_STR_EQ("ABCBCDE", model.text());
   EXPECT_EQ(5U, model.GetCursorPosition());
   EXPECT_TRUE(model.Undo());
-  EXPECT_STR_EQ("ABCDE", model.GetText());
+  EXPECT_STR_EQ("ABCDE", model.text());
   EXPECT_EQ(3U, model.GetCursorPosition());
   EXPECT_TRUE(model.Undo());
-  EXPECT_STR_EQ("ADE", model.GetText());
+  EXPECT_STR_EQ("ADE", model.text());
   EXPECT_EQ(1U, model.GetCursorPosition());
   EXPECT_TRUE(model.Undo());
-  EXPECT_STR_EQ("ABCDE", model.GetText());
+  EXPECT_STR_EQ("ABCDE", model.text());
   EXPECT_EQ(3U, model.GetCursorPosition());
   EXPECT_TRUE(model.Undo());
-  EXPECT_STR_EQ("", model.GetText());
+  EXPECT_STR_EQ("", model.text());
   EXPECT_EQ(0U, model.GetCursorPosition());
   EXPECT_FALSE(model.Undo());
-  EXPECT_STR_EQ("", model.GetText());
+  EXPECT_STR_EQ("", model.text());
   EXPECT_TRUE(model.Redo());
-  EXPECT_STR_EQ("ABCDE", model.GetText());  // Redoing SetText
+  EXPECT_STR_EQ("ABCDE", model.text());  // Redoing SetText
   EXPECT_EQ(5U, model.GetCursorPosition());
 
   // Redo
   EXPECT_TRUE(model.Redo());
-  EXPECT_STR_EQ("ADE", model.GetText());
+  EXPECT_STR_EQ("ADE", model.text());
   EXPECT_EQ(1U, model.GetCursorPosition());
   EXPECT_TRUE(model.Redo());
-  EXPECT_STR_EQ("ABCDE", model.GetText());
+  EXPECT_STR_EQ("ABCDE", model.text());
   EXPECT_EQ(3U, model.GetCursorPosition());
   EXPECT_TRUE(model.Redo());
-  EXPECT_STR_EQ("ABCBCDE", model.GetText());
+  EXPECT_STR_EQ("ABCBCDE", model.text());
   EXPECT_EQ(5U, model.GetCursorPosition());
   EXPECT_TRUE(model.Redo());
-  EXPECT_STR_EQ("ABCBCBCDE", model.GetText());
+  EXPECT_STR_EQ("ABCBCBCDE", model.text());
   EXPECT_EQ(7U, model.GetCursorPosition());
   EXPECT_FALSE(model.Redo());
 
   // with SelectRange
   model.SelectRange(gfx::Range(1, 3));
   EXPECT_TRUE(model.Cut());
-  EXPECT_STR_EQ("ABCBCDE", model.GetText());
+  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);
   EXPECT_TRUE(model.Paste());
-  EXPECT_STR_EQ("ABCBCDEBC", model.GetText());
+  EXPECT_STR_EQ("ABCBCDEBC", model.text());
   EXPECT_EQ(9U, model.GetCursorPosition());
   EXPECT_TRUE(model.Undo());
-  EXPECT_STR_EQ("ABCBCDE", model.GetText());
+  EXPECT_STR_EQ("ABCBCDE", model.text());
   EXPECT_EQ(7U, model.GetCursorPosition());
   // empty cut shouldn't create an edit.
   EXPECT_TRUE(model.Undo());
-  EXPECT_STR_EQ("ABCBCBCDE", model.GetText());
+  EXPECT_STR_EQ("ABCBCBCDE", model.text());
   EXPECT_EQ(3U, model.GetCursorPosition());
 
   // Copy
   ResetModel(&model);
   model.SetText(ASCIIToUTF16("12345"));
-  EXPECT_STR_EQ("12345", model.GetText());
+  EXPECT_STR_EQ("12345", model.text());
   EXPECT_EQ(5U, model.GetCursorPosition());
   model.SelectRange(gfx::Range(1, 3));
   model.Copy();  // Copy "23"
-  EXPECT_STR_EQ("12345", model.GetText());
+  EXPECT_STR_EQ("12345", model.text());
   EXPECT_EQ(3U, model.GetCursorPosition());
   model.Paste();  // Paste "23" into "23".
-  EXPECT_STR_EQ("12345", model.GetText());
+  EXPECT_STR_EQ("12345", model.text());
   EXPECT_EQ(3U, model.GetCursorPosition());
   model.Paste();
-  EXPECT_STR_EQ("1232345", model.GetText());
+  EXPECT_STR_EQ("1232345", model.text());
   EXPECT_EQ(5U, model.GetCursorPosition());
   EXPECT_TRUE(model.Undo());
-  EXPECT_STR_EQ("12345", model.GetText());
+  EXPECT_STR_EQ("12345", model.text());
   EXPECT_EQ(3U, model.GetCursorPosition());
   // TODO(oshima): We need to change the return type from bool to enum.
   EXPECT_FALSE(model.Undo());  // No text change.
-  EXPECT_STR_EQ("12345", model.GetText());
+  EXPECT_STR_EQ("12345", model.text());
   EXPECT_EQ(3U, model.GetCursorPosition());
   EXPECT_TRUE(model.Undo());
-  EXPECT_STR_EQ("", model.GetText());
+  EXPECT_STR_EQ("", model.text());
   EXPECT_FALSE(model.Undo());
   // Redo
   EXPECT_TRUE(model.Redo());
-  EXPECT_STR_EQ("12345", model.GetText());
+  EXPECT_STR_EQ("12345", model.text());
   EXPECT_EQ(5U, model.GetCursorPosition());
   EXPECT_TRUE(model.Redo());
-  EXPECT_STR_EQ("12345", model.GetText());  // For 1st paste
+  EXPECT_STR_EQ("12345", model.text());  // For 1st paste
   EXPECT_EQ(3U, model.GetCursorPosition());
   EXPECT_TRUE(model.Redo());
-  EXPECT_STR_EQ("1232345", model.GetText());
+  EXPECT_STR_EQ("1232345", model.text());
   EXPECT_EQ(5U, model.GetCursorPosition());
   EXPECT_FALSE(model.Redo());
-  EXPECT_STR_EQ("1232345", model.GetText());
+  EXPECT_STR_EQ("1232345", model.text());
 
   // Test using SelectRange
   model.SelectRange(gfx::Range(1, 3));
   model.Copy();
-  EXPECT_STR_EQ("1232345", model.GetText());
+  EXPECT_STR_EQ("1232345", model.text());
   model.MoveCursor(gfx::LINE_BREAK, gfx::CURSOR_RIGHT, false);
   EXPECT_TRUE(model.Paste());
-  EXPECT_STR_EQ("123234523", model.GetText());
+  EXPECT_STR_EQ("123234523", model.text());
   EXPECT_EQ(9U, model.GetCursorPosition());
   EXPECT_TRUE(model.Undo());
-  EXPECT_STR_EQ("1232345", model.GetText());
+  EXPECT_STR_EQ("1232345", model.text());
   EXPECT_EQ(7U, model.GetCursorPosition());
 }
 
 TEST_F(TextfieldViewsModelTest, UndoRedo_CursorTest) {
   TextfieldViewsModel model(NULL);
   model.InsertChar('a');
   model.MoveCursor(gfx::CHARACTER_BREAK, gfx::CURSOR_LEFT, false);
   model.MoveCursor(gfx::CHARACTER_BREAK, gfx::CURSOR_RIGHT, false);
   model.InsertChar('b');
   // Moving the cursor shouldn't create a new edit.
-  EXPECT_STR_EQ("ab", model.GetText());
+  EXPECT_STR_EQ("ab", model.text());
   EXPECT_FALSE(model.Redo());
   EXPECT_TRUE(model.Undo());
-  EXPECT_STR_EQ("", model.GetText());
+  EXPECT_STR_EQ("", model.text());
   EXPECT_FALSE(model.Undo());
-  EXPECT_STR_EQ("", model.GetText());
+  EXPECT_STR_EQ("", model.text());
   EXPECT_TRUE(model.Redo());
-  EXPECT_STR_EQ("ab", model.GetText());
+  EXPECT_STR_EQ("ab", model.text());
   EXPECT_EQ(2U, model.GetCursorPosition());
   EXPECT_FALSE(model.Redo());
 }
 
 void RunInsertReplaceTest(TextfieldViewsModel& model) {
   const bool reverse = model.render_text()->selection().is_reversed();
   model.InsertChar('1');
   model.InsertChar('2');
   model.InsertChar('3');
-  EXPECT_STR_EQ("a123d", model.GetText());
+  EXPECT_STR_EQ("a123d", model.text());
   EXPECT_EQ(4U, model.GetCursorPosition());
   EXPECT_TRUE(model.Undo());
-  EXPECT_STR_EQ("abcd", model.GetText());
+  EXPECT_STR_EQ("abcd", model.text());
   EXPECT_EQ(reverse ? 1U : 3U, model.GetCursorPosition());
   EXPECT_TRUE(model.Undo());
-  EXPECT_STR_EQ("", model.GetText());
+  EXPECT_STR_EQ("", model.text());
   EXPECT_EQ(0U, model.GetCursorPosition());
   EXPECT_FALSE(model.Undo());
   EXPECT_TRUE(model.Redo());
-  EXPECT_STR_EQ("abcd", model.GetText());
+  EXPECT_STR_EQ("abcd", model.text());
   EXPECT_EQ(4U, model.GetCursorPosition());  // By SetText
   EXPECT_TRUE(model.Redo());
-  EXPECT_STR_EQ("a123d", model.GetText());
+  EXPECT_STR_EQ("a123d", model.text());
   EXPECT_EQ(4U, model.GetCursorPosition());
   EXPECT_FALSE(model.Redo());
 }
 
 void RunOverwriteReplaceTest(TextfieldViewsModel& model) {
   const bool reverse = model.render_text()->selection().is_reversed();
   model.ReplaceChar('1');
   model.ReplaceChar('2');
   model.ReplaceChar('3');
   model.ReplaceChar('4');
-  EXPECT_STR_EQ("a1234", model.GetText());
+  EXPECT_STR_EQ("a1234", model.text());
   EXPECT_EQ(5U, model.GetCursorPosition());
   EXPECT_TRUE(model.Undo());
-  EXPECT_STR_EQ("abcd", model.GetText());
+  EXPECT_STR_EQ("abcd", model.text());
   EXPECT_EQ(reverse ? 1U : 3U, model.GetCursorPosition());
   EXPECT_TRUE(model.Undo());
-  EXPECT_STR_EQ("", model.GetText());
+  EXPECT_STR_EQ("", model.text());
   EXPECT_EQ(0U, model.GetCursorPosition());
   EXPECT_FALSE(model.Undo());
   EXPECT_TRUE(model.Redo());
-  EXPECT_STR_EQ("abcd", model.GetText());
+  EXPECT_STR_EQ("abcd", model.text());
   EXPECT_EQ(4U, model.GetCursorPosition());
   EXPECT_TRUE(model.Redo());
-  EXPECT_STR_EQ("a1234", model.GetText());
+  EXPECT_STR_EQ("a1234", model.text());
   EXPECT_EQ(5U, model.GetCursorPosition());
   EXPECT_FALSE(model.Redo());
 }
 
 TEST_F(TextfieldViewsModelTest, UndoRedo_ReplaceTest) {
   // By Cursor
   {
     SCOPED_TRACE("forward & insert by cursor");
     TextfieldViewsModel model(NULL);
     model.SetText(ASCIIToUTF16("abcd"));
@@ skipping 56 matching lines @@
   TextfieldViewsModel model(NULL);
 
   ui::CompositionText composition;
   composition.text = ASCIIToUTF16("abc");
   composition.underlines.push_back(ui::CompositionUnderline(0, 3, 0, false));
   composition.selection = gfx::Range(2, 3);
 
   model.SetText(ASCIIToUTF16("ABCDE"));
   model.MoveCursor(gfx::LINE_BREAK, gfx::CURSOR_RIGHT, false);
   model.InsertChar('x');
-  EXPECT_STR_EQ("ABCDEx", model.GetText());
+  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.GetText());
+  EXPECT_STR_EQ("ABCDEabc", model.text());
 
   // Accepting composition
   model.ConfirmCompositionText();
-  EXPECT_STR_EQ("ABCDEabc", model.GetText());
+  EXPECT_STR_EQ("ABCDEabc", model.text());
   EXPECT_TRUE(model.Undo());
-  EXPECT_STR_EQ("ABCDE", model.GetText());
+  EXPECT_STR_EQ("ABCDE", model.text());
   EXPECT_TRUE(model.Undo());
-  EXPECT_STR_EQ("", model.GetText());
+  EXPECT_STR_EQ("", model.text());
   EXPECT_TRUE(model.Redo());
-  EXPECT_STR_EQ("ABCDE", model.GetText());
+  EXPECT_STR_EQ("ABCDE", model.text());
   EXPECT_TRUE(model.Redo());
-  EXPECT_STR_EQ("ABCDEabc", model.GetText());
+  EXPECT_STR_EQ("ABCDEabc", model.text());
   EXPECT_FALSE(model.Redo());
 
   // Canceling composition
   model.MoveCursor(gfx::LINE_BREAK, gfx::CURSOR_LEFT, false);
   model.SetCompositionText(composition);
-  EXPECT_STR_EQ("abcABCDEabc", model.GetText());
+  EXPECT_STR_EQ("abcABCDEabc", model.text());
   model.CancelCompositionText();
-  EXPECT_STR_EQ("ABCDEabc", model.GetText());
+  EXPECT_STR_EQ("ABCDEabc", model.text());
   EXPECT_FALSE(model.Redo());
-  EXPECT_STR_EQ("ABCDEabc", model.GetText());
+  EXPECT_STR_EQ("ABCDEabc", model.text());
   EXPECT_TRUE(model.Undo());
-  EXPECT_STR_EQ("ABCDE", model.GetText());
+  EXPECT_STR_EQ("ABCDE", model.text());
   EXPECT_TRUE(model.Redo());
-  EXPECT_STR_EQ("ABCDEabc", model.GetText());
+  EXPECT_STR_EQ("ABCDEabc", model.text());
   EXPECT_FALSE(model.Redo());
 
   // SetText with the same text as the result.
   ResetModel(&model);
   model.SetText(ASCIIToUTF16("ABCDE"));
   model.MoveCursor(gfx::LINE_BREAK, gfx::CURSOR_RIGHT, false);
   model.SetCompositionText(composition);
-  EXPECT_STR_EQ("ABCDEabc", model.GetText());
+  EXPECT_STR_EQ("ABCDEabc", model.text());
   model.SetText(ASCIIToUTF16("ABCDEabc"));
-  EXPECT_STR_EQ("ABCDEabc", model.GetText());
+  EXPECT_STR_EQ("ABCDEabc", model.text());
   EXPECT_TRUE(model.Undo());
-  EXPECT_STR_EQ("ABCDE", model.GetText());
+  EXPECT_STR_EQ("ABCDE", model.text());
   EXPECT_TRUE(model.Redo());
-  EXPECT_STR_EQ("ABCDEabc", model.GetText());
+  EXPECT_STR_EQ("ABCDEabc", model.text());
   EXPECT_FALSE(model.Redo());
 
   // SetText with the different text than the result should not
   // remember composition text.
   ResetModel(&model);
   model.SetText(ASCIIToUTF16("ABCDE"));
   model.MoveCursor(gfx::LINE_BREAK, gfx::CURSOR_RIGHT, false);
   model.SetCompositionText(composition);
-  EXPECT_STR_EQ("ABCDEabc", model.GetText());
+  EXPECT_STR_EQ("ABCDEabc", model.text());
   model.SetText(ASCIIToUTF16("1234"));
-  EXPECT_STR_EQ("1234", model.GetText());
+  EXPECT_STR_EQ("1234", model.text());
   EXPECT_TRUE(model.Undo());
-  EXPECT_STR_EQ("ABCDE", model.GetText());
+  EXPECT_STR_EQ("ABCDE", model.text());
   EXPECT_TRUE(model.Redo());
-  EXPECT_STR_EQ("1234", model.GetText());
+  EXPECT_STR_EQ("1234", model.text());
   EXPECT_FALSE(model.Redo());
 
   // TODO(oshima): We need MockInputMethod to test the behavior with IME.
 }
 
 }  // namespace views