Views Textfield fixes and cleanup.

ui/views/controls/textfield/textfield_unittest.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "ui/views/controls/textfield/textfield.h"
 
 #include <set>
 #include <string>
 #include <vector>
 
@@ skipping 38 matching lines @@
 
 #define EXPECT_STR_EQ(ascii, utf16) EXPECT_EQ(ASCIIToUTF16(ascii), utf16)
 
 namespace {
 
 const base::char16 kHebrewLetterSamekh = 0x05E1;
 
 // A Textfield wrapper to intercept OnKey[Pressed|Released]() ressults.
 class TestTextfield : public views::Textfield {
  public:
-  explicit TestTextfield(StyleFlags style)
-      : Textfield(style),
-        key_handled_(false),
-        key_received_(false) {
-  }
+  TestTextfield() : Textfield(), key_handled_(false), key_received_(false) {}
 
   virtual bool OnKeyPressed(const ui::KeyEvent& e) OVERRIDE {
     key_received_ = true;
     key_handled_ = views::Textfield::OnKeyPressed(e);
     return key_handled_;
   }
 
   virtual bool OnKeyReleased(const ui::KeyEvent& e) OVERRIDE {
     key_received_ = true;
     key_handled_ = views::Textfield::OnKeyReleased(e);
     return key_handled_;
   }
 
   bool key_handled() const { return key_handled_; }
   bool key_received() const { return key_received_; }
 
   void clear() { key_received_ = key_handled_ = false; }
 
-  bool focusable() const { return View::focusable(); }
-
  private:
   bool key_handled_;
   bool key_received_;
 
   DISALLOW_COPY_AND_ASSIGN(TestTextfield);
 };
 
 // A helper class for use with ui::TextInputClient::GetTextFromRange().
 class GetTextHelper {
  public:
@@ skipping 63 matching lines @@
   }
 
   virtual void OnBeforeUserAction(Textfield* sender) OVERRIDE {
     ++on_before_user_action_;
   }
 
   virtual void OnAfterUserAction(Textfield* sender) OVERRIDE {
     ++on_after_user_action_;
   }
 
-  void InitTextfield(Textfield::StyleFlags style) {
-    InitTextfields(style, 1);
+  void InitTextfield() {
+    InitTextfields(1);
   }
 
-  void InitTextfields(Textfield::StyleFlags style, int count) {
+  void InitTextfields(int count) {
     ASSERT_FALSE(textfield_);
-    textfield_ = new TestTextfield(style);
-    textfield_->SetController(this);
+    textfield_ = new TestTextfield();
+    textfield_->set_controller(this);
     widget_ = new Widget();
     Widget::InitParams params = CreateParams(Widget::InitParams::TYPE_POPUP);
     params.bounds = gfx::Rect(100, 100, 100, 100);
     widget_->Init(params);
     View* container = new View();
     widget_->SetContentsView(container);
     container->AddChildView(textfield_);
     textfield_->SetBoundsRect(params.bounds);
     textfield_->set_id(1);
 
     for (int i = 1; i < count; i++) {
-      Textfield* textfield = new Textfield(style);
+      Textfield* textfield = new Textfield();
       container->AddChildView(textfield);
       textfield->set_id(i + 1);
     }
 
     model_ = textfield_->model_.get();
     model_->ClearEditHistory();
 
     input_method_ = new MockInputMethod();
     widget_->ReplaceInputMethod(input_method_);
 
@@ skipping 141 matching lines @@
   int on_before_user_action_;
 
   // Indicates how many times OnAfterUserAction() is called.
   int on_after_user_action_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(TextfieldTest);
 };
 
 TEST_F(TextfieldTest, ModelChangesTest) {
-  InitTextfield(Textfield::STYLE_DEFAULT);
+  InitTextfield();
 
   // TextfieldController::ContentsChanged() shouldn't be called when changing
   // text programmatically.
   last_contents_.clear();
   textfield_->SetText(ASCIIToUTF16("this is"));
 
   EXPECT_STR_EQ("this is", model_->text());
   EXPECT_STR_EQ("this is", textfield_->text());
   EXPECT_TRUE(last_contents_.empty());
 
   textfield_->AppendText(ASCIIToUTF16(" a test"));
   EXPECT_STR_EQ("this is a test", model_->text());
   EXPECT_STR_EQ("this is a test", textfield_->text());
   EXPECT_TRUE(last_contents_.empty());
 
   EXPECT_EQ(base::string16(), textfield_->GetSelectedText());
   textfield_->SelectAll(false);
   EXPECT_STR_EQ("this is a test", textfield_->GetSelectedText());
   EXPECT_TRUE(last_contents_.empty());
 }
 
-TEST_F(TextfieldTest, ModelChangesTestLowerCase) {
-  // Check if |model_|'s text is properly lowercased for STYLE_LOWERCASE.
-  InitTextfield(Textfield::STYLE_LOWERCASE);
-  EXPECT_EQ(0U, textfield_->GetCursorPosition());
-
-  last_contents_.clear();
-  textfield_->SetText(ASCIIToUTF16("THIS IS"));
-  EXPECT_EQ(7U, textfield_->GetCursorPosition());
-
-  EXPECT_STR_EQ("this is", textfield_->text());
-  EXPECT_TRUE(last_contents_.empty());
-
-  textfield_->AppendText(ASCIIToUTF16(" A TEST"));
-  EXPECT_EQ(7U, textfield_->GetCursorPosition());
-  EXPECT_STR_EQ("this is a test", textfield_->text());
-
-  EXPECT_TRUE(last_contents_.empty());
-}
-
-TEST_F(TextfieldTest, ModelChangesTestLowerCaseI18n) {
-  // Check if lower case conversion works for non-ASCII characters.
-  InitTextfield(Textfield::STYLE_LOWERCASE);
-  EXPECT_EQ(0U, textfield_->GetCursorPosition());
-
-  last_contents_.clear();
-  // Zenkaku Japanese "ABCabc"
-  textfield_->SetText(WideToUTF16(L"\xFF21\xFF22\xFF23\xFF41\xFF42\xFF43"));
-  EXPECT_EQ(6U, textfield_->GetCursorPosition());
-  // Zenkaku Japanese "abcabc"
-  EXPECT_EQ(WideToUTF16(L"\xFF41\xFF42\xFF43\xFF41\xFF42\xFF43"),
-            textfield_->text());
-  EXPECT_TRUE(last_contents_.empty());
-
-  // Zenkaku Japanese "XYZxyz"
-  textfield_->AppendText(WideToUTF16(L"\xFF38\xFF39\xFF3A\xFF58\xFF59\xFF5A"));
-  EXPECT_EQ(6U, textfield_->GetCursorPosition());
-  // Zenkaku Japanese "abcabcxyzxyz"
-  EXPECT_EQ(WideToUTF16(L"\xFF41\xFF42\xFF43\xFF41\xFF42\xFF43"
-                        L"\xFF58\xFF59\xFF5A\xFF58\xFF59\xFF5A"),
-            textfield_->text());
-  EXPECT_TRUE(last_contents_.empty());
-}
-
-TEST_F(TextfieldTest, ModelChangesTestLowerCaseWithLocale) {
-  // Check if lower case conversion honors locale properly.
-  std::string locale = l10n_util::GetApplicationLocale("");
-  base::i18n::SetICUDefaultLocale("tr");
-
-  InitTextfield(Textfield::STYLE_LOWERCASE);
-  EXPECT_EQ(0U, textfield_->GetCursorPosition());
-
-  last_contents_.clear();
-  // Turkish 'I' should be converted to dotless 'i' (U+0131).
-  textfield_->SetText(WideToUTF16(L"I"));
-  EXPECT_EQ(1U, textfield_->GetCursorPosition());
-  EXPECT_EQ(WideToUTF16(L"\x0131"), textfield_->text());
-  EXPECT_TRUE(last_contents_.empty());
-
-  base::i18n::SetICUDefaultLocale(locale);
-
-  // On default (en) locale, 'I' should be converted to 'i'.
-  textfield_->SetText(WideToUTF16(L"I"));
-  EXPECT_EQ(1U, textfield_->GetCursorPosition());
-  EXPECT_EQ(WideToUTF16(L"i"), textfield_->text());
-  EXPECT_TRUE(last_contents_.empty());
-}
-
 TEST_F(TextfieldTest, KeyTest) {
-  InitTextfield(Textfield::STYLE_DEFAULT);
+  InitTextfield();
   // Event flags:  key,    alt,   shift, ctrl,  caps-lock.
   SendKeyEvent(ui::VKEY_T, false, true,  false, false);
   SendKeyEvent(ui::VKEY_E, false, false, false, false);
   SendKeyEvent(ui::VKEY_X, false, true,  false, true);
   SendKeyEvent(ui::VKEY_T, false, false, false, true);
   SendKeyEvent(ui::VKEY_1, false, true,  false, false);
   SendKeyEvent(ui::VKEY_1, false, false, false, false);
   SendKeyEvent(ui::VKEY_1, false, true,  false, true);
   SendKeyEvent(ui::VKEY_1, false, false, false, true);
   EXPECT_STR_EQ("TexT!1!1", textfield_->text());
 }
 
 TEST_F(TextfieldTest, ControlAndSelectTest) {
   // Insert a test string in a textfield.
-  InitTextfield(Textfield::STYLE_DEFAULT);
+  InitTextfield();
   textfield_->SetText(ASCIIToUTF16("one two three"));
   SendKeyEvent(ui::VKEY_HOME,  false /* shift */, false /* control */);
   SendKeyEvent(ui::VKEY_RIGHT, true, false);
   SendKeyEvent(ui::VKEY_RIGHT, true, false);
   SendKeyEvent(ui::VKEY_RIGHT, true, false);
 
   EXPECT_STR_EQ("one", textfield_->GetSelectedText());
 
   // Test word select.
   SendKeyEvent(ui::VKEY_RIGHT, true, true);
@@ skipping 14 matching lines @@
   EXPECT_STR_EQ("ZERO two three", textfield_->text());
 
   SendKeyEvent(ui::VKEY_END, true, false);
   EXPECT_STR_EQ("two three", textfield_->GetSelectedText());
   SendKeyEvent(ui::VKEY_HOME, true, false);
   EXPECT_STR_EQ("ZERO ", textfield_->GetSelectedText());
 }
 
 TEST_F(TextfieldTest, InsertionDeletionTest) {
   // Insert a test string in a textfield.
-  InitTextfield(Textfield::STYLE_DEFAULT);
+  InitTextfield();
   for (size_t i = 0; i < 10; i++)
     SendKeyEvent(static_cast<ui::KeyboardCode>(ui::VKEY_A + i));
   EXPECT_STR_EQ("abcdefghij", textfield_->text());
 
   // Test the delete and backspace keys.
   textfield_->SelectRange(gfx::Range(5));
   for (int i = 0; i < 3; i++)
     SendKeyEvent(ui::VKEY_BACK);
   EXPECT_STR_EQ("abfghij", textfield_->text());
   for (int i = 0; i < 3; i++)
@@ skipping 30 matching lines @@
   SendKeyEvent(ui::VKEY_RIGHT, false, false, true, false);
   SendKeyEvent(ui::VKEY_DELETE, false, true, true, false);
 #if defined(OS_LINUX)
   EXPECT_STR_EQ(" two", textfield_->text());
 #else
   EXPECT_STR_EQ(" two three four", textfield_->text());
 #endif
 }
 
 TEST_F(TextfieldTest, PasswordTest) {
-  InitTextfield(Textfield::STYLE_OBSCURED);
+  InitTextfield();
+  textfield_->SetTextInputType(ui::TEXT_INPUT_TYPE_PASSWORD);
   EXPECT_EQ(ui::TEXT_INPUT_TYPE_PASSWORD, GetTextInputType());
   EXPECT_TRUE(textfield_->enabled());
-  EXPECT_TRUE(textfield_->focusable());
+  EXPECT_TRUE(textfield_->IsFocusable());
 
   last_contents_.clear();
   textfield_->SetText(ASCIIToUTF16("password"));
   // Ensure text() and the callback returns the actual text instead of "*".
   EXPECT_STR_EQ("password", textfield_->text());
   EXPECT_TRUE(last_contents_.empty());
   model_->SelectAll(false);
   SetClipboardText("foo");
 
   // Cut and copy should be disabled.
@@ skipping 12 matching lines @@
 
   // Paste should work normally.
   EXPECT_TRUE(textfield_->IsCommandIdEnabled(IDS_APP_PASTE));
   textfield_->ExecuteCommand(IDS_APP_PASTE, 0);
   SendKeyEvent(ui::VKEY_V, false, true);
   SendKeyEvent(ui::VKEY_INSERT, true, false);
   EXPECT_STR_EQ("foo", base::string16(GetClipboardText()));
   EXPECT_STR_EQ("foofoofoo", textfield_->text());
 }
 
-TEST_F(TextfieldTest, InputTypeSetsObscured) {
-  InitTextfield(Textfield::STYLE_DEFAULT);
+TEST_F(TextfieldTest, TextInputType) {
+  InitTextfield();
 
   // Defaults to TEXT
   EXPECT_EQ(ui::TEXT_INPUT_TYPE_TEXT, GetTextInputType());
-
-  // Setting to TEXT_INPUT_TYPE_PASSWORD also sets obscured state of textfield.
-  textfield_->SetTextInputType(ui::TEXT_INPUT_TYPE_PASSWORD);
-  EXPECT_EQ(ui::TEXT_INPUT_TYPE_PASSWORD, GetTextInputType());
-  EXPECT_TRUE(textfield_->IsObscured());
-}
-
-TEST_F(TextfieldTest, ObscuredSetsInputType) {
-  InitTextfield(Textfield::STYLE_DEFAULT);
-
-  // Defaults to TEXT
-  EXPECT_EQ(ui::TEXT_INPUT_TYPE_TEXT, GetTextInputType());
-
-  textfield_->SetObscured(true);
-  EXPECT_EQ(ui::TEXT_INPUT_TYPE_PASSWORD, GetTextInputType());
-
-  textfield_->SetObscured(false);
-  EXPECT_EQ(ui::TEXT_INPUT_TYPE_TEXT, GetTextInputType());
-}
-
-TEST_F(TextfieldTest, TextInputType) {
-  InitTextfield(Textfield::STYLE_DEFAULT);
-
-  // Defaults to TEXT
-  EXPECT_EQ(ui::TEXT_INPUT_TYPE_TEXT, GetTextInputType());
 
   // And can be set.
   textfield_->SetTextInputType(ui::TEXT_INPUT_TYPE_URL);
   EXPECT_EQ(ui::TEXT_INPUT_TYPE_URL, GetTextInputType());
+  textfield_->SetTextInputType(ui::TEXT_INPUT_TYPE_PASSWORD);
+  EXPECT_EQ(ui::TEXT_INPUT_TYPE_PASSWORD, GetTextInputType());
 
   // Readonly textfields have type NONE
   textfield_->SetReadOnly(true);
   EXPECT_EQ(ui::TEXT_INPUT_TYPE_NONE, GetTextInputType());
 
   textfield_->SetReadOnly(false);
-  EXPECT_EQ(ui::TEXT_INPUT_TYPE_URL, GetTextInputType());
+  EXPECT_EQ(ui::TEXT_INPUT_TYPE_PASSWORD, GetTextInputType());
 
   // As do disabled textfields
   textfield_->SetEnabled(false);
   EXPECT_EQ(ui::TEXT_INPUT_TYPE_NONE, GetTextInputType());
+
+  textfield_->SetEnabled(true);
+  EXPECT_EQ(ui::TEXT_INPUT_TYPE_PASSWORD, GetTextInputType());
 }
 
 TEST_F(TextfieldTest, OnKeyPressReturnValueTest) {
-  InitTextfield(Textfield::STYLE_DEFAULT);
+  InitTextfield();
 
   // Character keys will be handled by input method.
   SendKeyEvent(ui::VKEY_A);
   EXPECT_TRUE(textfield_->key_received());
   EXPECT_FALSE(textfield_->key_handled());
   textfield_->clear();
 
   // Home will be handled.
   SendKeyEvent(ui::VKEY_HOME);
   EXPECT_TRUE(textfield_->key_received());
@@ skipping 42 matching lines @@
   textfield_->clear();
 
   // Now left key should not be handled.
   SendKeyEvent(ui::VKEY_LEFT);
   EXPECT_TRUE(textfield_->key_received());
   EXPECT_FALSE(textfield_->key_handled());
   textfield_->clear();
 }
 
 TEST_F(TextfieldTest, CursorMovement) {
-  InitTextfield(Textfield::STYLE_DEFAULT);
+  InitTextfield();
 
   // Test with trailing whitespace.
   textfield_->SetText(ASCIIToUTF16("one two hre "));
 
   // Send the cursor at the end.
   SendKeyEvent(ui::VKEY_END);
 
   // Ctrl+Left should move the cursor just before the last word.
   SendKeyEvent(ui::VKEY_LEFT, false, true);
   SendKeyEvent(ui::VKEY_T);
@@ skipping 29 matching lines @@
   // Ctrl+Left to move the cursor to the beginning of the first word.
   SendKeyEvent(ui::VKEY_LEFT, false, true);
   // Ctrl+Left again should move the cursor back to the very beginning.
   SendKeyEvent(ui::VKEY_LEFT, false, true);
   SendKeyEvent(ui::VKEY_DELETE);
   EXPECT_STR_EQ("one two", textfield_->text());
   EXPECT_STR_EQ("one two", last_contents_);
 }
 
 TEST_F(TextfieldTest, FocusTraversalTest) {
-  InitTextfields(Textfield::STYLE_DEFAULT, 3);
+  InitTextfields(3);
   textfield_->RequestFocus();
 
   EXPECT_EQ(1, GetFocusedView()->id());
   widget_->GetFocusManager()->AdvanceFocus(false);
   EXPECT_EQ(2, GetFocusedView()->id());
   widget_->GetFocusManager()->AdvanceFocus(false);
   EXPECT_EQ(3, GetFocusedView()->id());
   // Cycle back to the first textfield.
   widget_->GetFocusManager()->AdvanceFocus(false);
   EXPECT_EQ(1, GetFocusedView()->id());
@@ skipping 15 matching lines @@
   // Test if clicking on textfield view sets the focus to textfield_.
   widget_->GetFocusManager()->AdvanceFocus(true);
   EXPECT_EQ(3, GetFocusedView()->id());
   ui::MouseEvent click(ui::ET_MOUSE_PRESSED, gfx::Point(), gfx::Point(),
                        ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON);
   textfield_->OnMousePressed(click);
   EXPECT_EQ(1, GetFocusedView()->id());
 }
 
 TEST_F(TextfieldTest, ContextMenuDisplayTest) {
-  InitTextfield(Textfield::STYLE_DEFAULT);
+  InitTextfield();
   EXPECT_TRUE(textfield_->context_menu_controller());
   textfield_->SetText(ASCIIToUTF16("hello world"));
   ui::Clipboard::GetForCurrentThread()->Clear(ui::CLIPBOARD_TYPE_COPY_PASTE);
   textfield_->ClearEditHistory();
   EXPECT_TRUE(GetContextMenuModel());
   VerifyTextfieldContextMenuContents(false, false, GetContextMenuModel());
 
   textfield_->SelectAll(false);
   VerifyTextfieldContextMenuContents(true, false, GetContextMenuModel());
 
   SendKeyEvent(ui::VKEY_T);
   VerifyTextfieldContextMenuContents(false, true, GetContextMenuModel());
 
   textfield_->SelectAll(false);
   VerifyTextfieldContextMenuContents(true, true, GetContextMenuModel());
 
   // Exercise the "paste enabled?" check in the verifier.
   SetClipboardText("Test");
   VerifyTextfieldContextMenuContents(true, true, GetContextMenuModel());
 }
 
 TEST_F(TextfieldTest, DoubleAndTripleClickTest) {
-  InitTextfield(Textfield::STYLE_DEFAULT);
+  InitTextfield();
   textfield_->SetText(ASCIIToUTF16("hello world"));
   ui::MouseEvent click(ui::ET_MOUSE_PRESSED, gfx::Point(), gfx::Point(),
                        ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON);
   ui::MouseEvent release(ui::ET_MOUSE_RELEASED, gfx::Point(), gfx::Point(),
                          ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON);
   ui::MouseEvent double_click(
       ui::ET_MOUSE_PRESSED, gfx::Point(), gfx::Point(),
       ui::EF_LEFT_MOUSE_BUTTON | ui::EF_IS_DOUBLE_CLICK,
       ui::EF_LEFT_MOUSE_BUTTON);
 
@@ skipping 10 matching lines @@
   textfield_->OnMouseReleased(release);
   EXPECT_STR_EQ("hello world", textfield_->GetSelectedText());
 
   // Another click should reset back to double click.
   textfield_->OnMousePressed(click);
   textfield_->OnMouseReleased(release);
   EXPECT_STR_EQ("hello", textfield_->GetSelectedText());
 }
 
 TEST_F(TextfieldTest, DragToSelect) {
-  InitTextfield(Textfield::STYLE_DEFAULT);
+  InitTextfield();
   textfield_->SetText(ASCIIToUTF16("hello world"));
   const int kStart = GetCursorPositionX(5);
   const int kEnd = 500;
   gfx::Point start_point(kStart, 0);
   gfx::Point end_point(kEnd, 0);
   ui::MouseEvent click_a(ui::ET_MOUSE_PRESSED, start_point, start_point,
                          ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON);
   ui::MouseEvent click_b(ui::ET_MOUSE_PRESSED, end_point, end_point,
                          ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON);
   ui::MouseEvent drag_left(ui::ET_MOUSE_DRAGGED, gfx::Point(), gfx::Point(),
@@ skipping 17 matching lines @@
   EXPECT_EQ(text_right, textfield_->GetSelectedText());
   // Check that dragging from beyond the text length works too.
   textfield_->OnMousePressed(click_b);
   textfield_->OnMouseDragged(drag_left);
   textfield_->OnMouseReleased(release);
   EXPECT_EQ(textfield_->text(), textfield_->GetSelectedText());
 }
 
 #if defined(OS_WIN)
 TEST_F(TextfieldTest, DragAndDrop_AcceptDrop) {
-  InitTextfield(Textfield::STYLE_DEFAULT);
+  InitTextfield();
   textfield_->SetText(ASCIIToUTF16("hello world"));
 
   ui::OSExchangeData data;
   base::string16 string(ASCIIToUTF16("string "));
   data.SetString(string);
   int formats = 0;
   std::set<OSExchangeData::CustomFormat> custom_formats;
 
   // Ensure that disabled textfields do not accept drops.
   textfield_->SetEnabled(false);
@@ skipping 31 matching lines @@
   bad_data.SetPickledData(fmt, Pickle());
   bad_data.SetFileContents(base::FilePath(L"x"), "x");
   bad_data.SetHtml(base::string16(ASCIIToUTF16("x")), GURL("x.org"));
   ui::OSExchangeData::DownloadFileInfo download(base::FilePath(), NULL);
   bad_data.SetDownloadFileInfo(download);
   EXPECT_FALSE(textfield_->CanDrop(bad_data));
 }
 #endif
 
 TEST_F(TextfieldTest, DragAndDrop_InitiateDrag) {
-  InitTextfield(Textfield::STYLE_DEFAULT);
+  InitTextfield();
   textfield_->SetText(ASCIIToUTF16("hello string world"));
 
   // Ensure the textfield will provide selected text for drag data.
   base::string16 string;
   ui::OSExchangeData data;
   const gfx::Range kStringRange(6, 12);
   textfield_->SelectRange(kStringRange);
   const gfx::Point kStringPoint(GetCursorPositionX(9), 0);
   textfield_->WriteDragDataForView(NULL, kStringPoint, &data);
   EXPECT_TRUE(data.GetString(&string));
   EXPECT_EQ(textfield_->GetSelectedText(), string);
 
   // Ensure that disabled textfields do not support drag operations.
   textfield_->SetEnabled(false);
   EXPECT_EQ(ui::DragDropTypes::DRAG_NONE,
             textfield_->GetDragOperationsForView(NULL, kStringPoint));
   textfield_->SetEnabled(true);
   // Ensure that textfields without selections do not support drag operations.
   textfield_->ClearSelection();
   EXPECT_EQ(ui::DragDropTypes::DRAG_NONE,
             textfield_->GetDragOperationsForView(NULL, kStringPoint));
   textfield_->SelectRange(kStringRange);
   // Ensure that password textfields do not support drag operations.
-  textfield_->SetObscured(true);
+  textfield_->SetTextInputType(ui::TEXT_INPUT_TYPE_PASSWORD);
   EXPECT_EQ(ui::DragDropTypes::DRAG_NONE,
             textfield_->GetDragOperationsForView(NULL, kStringPoint));
-  textfield_->SetObscured(false);
+  textfield_->SetTextInputType(ui::TEXT_INPUT_TYPE_TEXT);
   // Ensure that textfields only initiate drag operations inside the selection.
   ui::MouseEvent press_event(ui::ET_MOUSE_PRESSED, kStringPoint, kStringPoint,
                              ui::EF_LEFT_MOUSE_BUTTON,
                              ui::EF_LEFT_MOUSE_BUTTON);
   textfield_->OnMousePressed(press_event);
   EXPECT_EQ(ui::DragDropTypes::DRAG_NONE,
             textfield_->GetDragOperationsForView(NULL, gfx::Point()));
   EXPECT_FALSE(textfield_->CanStartDragForView(NULL, gfx::Point(),
                                                gfx::Point()));
   EXPECT_EQ(ui::DragDropTypes::DRAG_COPY,
             textfield_->GetDragOperationsForView(NULL, kStringPoint));
   EXPECT_TRUE(textfield_->CanStartDragForView(NULL, kStringPoint,
                                               gfx::Point()));
   // Ensure that textfields support local moves.
   EXPECT_EQ(ui::DragDropTypes::DRAG_MOVE | ui::DragDropTypes::DRAG_COPY,
       textfield_->GetDragOperationsForView(textfield_, kStringPoint));
 }
 
 TEST_F(TextfieldTest, DragAndDrop_ToTheRight) {
-  InitTextfield(Textfield::STYLE_DEFAULT);
+  InitTextfield();
   textfield_->SetText(ASCIIToUTF16("hello world"));
 
   base::string16 string;
   ui::OSExchangeData data;
   int formats = 0;
   int operations = 0;
   std::set<OSExchangeData::CustomFormat> custom_formats;
 
   // Start dragging "ello".
   textfield_->SelectRange(gfx::Range(1, 5));
@@ skipping 32 matching lines @@
   EXPECT_STR_EQ("", textfield_->text());
   SendKeyEvent(ui::VKEY_Y, false, true);
   EXPECT_STR_EQ("hello world", textfield_->text());
   SendKeyEvent(ui::VKEY_Y, false, true);
   EXPECT_STR_EQ("h welloorld", textfield_->text());
   SendKeyEvent(ui::VKEY_Y, false, true);
   EXPECT_STR_EQ("h welloorld", textfield_->text());
 }
 
 TEST_F(TextfieldTest, DragAndDrop_ToTheLeft) {
-  InitTextfield(Textfield::STYLE_DEFAULT);
+  InitTextfield();
   textfield_->SetText(ASCIIToUTF16("hello world"));
 
   base::string16 string;
   ui::OSExchangeData data;
   int formats = 0;
   int operations = 0;
   std::set<OSExchangeData::CustomFormat> custom_formats;
 
   // Start dragging " worl".
   textfield_->SelectRange(gfx::Range(5, 10));
@@ skipping 32 matching lines @@
   EXPECT_STR_EQ("", textfield_->text());
   SendKeyEvent(ui::VKEY_Y, false, true);
   EXPECT_STR_EQ("hello world", textfield_->text());
   SendKeyEvent(ui::VKEY_Y, false, true);
   EXPECT_STR_EQ("h worlellod", textfield_->text());
   SendKeyEvent(ui::VKEY_Y, false, true);
   EXPECT_STR_EQ("h worlellod", textfield_->text());
 }
 
 TEST_F(TextfieldTest, DragAndDrop_Canceled) {
-  InitTextfield(Textfield::STYLE_DEFAULT);
+  InitTextfield();
   textfield_->SetText(ASCIIToUTF16("hello world"));
 
   // Start dragging "worl".
   textfield_->SelectRange(gfx::Range(6, 10));
   gfx::Point point(GetCursorPositionX(8), 0);
   ui::MouseEvent click(ui::ET_MOUSE_PRESSED, point, point,
                        ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON);
   textfield_->OnMousePressed(click);
   ui::OSExchangeData data;
   textfield_->WriteDragDataForView(NULL, click.location(), &data);
   EXPECT_TRUE(textfield_->CanDrop(data));
   // Drag the text over somewhere valid, outside the current selection.
   gfx::Point drop_point(GetCursorPositionX(2), 0);
   ui::DropTargetEvent drop(data, drop_point, drop_point,
                            ui::DragDropTypes::DRAG_MOVE);
   EXPECT_EQ(ui::DragDropTypes::DRAG_MOVE, textfield_->OnDragUpdated(drop));
   // "Cancel" the drag, via move and release over the selection, and OnDragDone.
   gfx::Point drag_point(GetCursorPositionX(9), 0);
   ui::MouseEvent drag(ui::ET_MOUSE_DRAGGED, drag_point, drag_point,
                       ui::EF_LEFT_MOUSE_BUTTON, 0);
   ui::MouseEvent release(ui::ET_MOUSE_RELEASED, drag_point, drag_point,
                          ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON);
   textfield_->OnMouseDragged(drag);
   textfield_->OnMouseReleased(release);
   textfield_->OnDragDone();
   EXPECT_EQ(ASCIIToUTF16("hello world"), textfield_->text());
 }
 
 TEST_F(TextfieldTest, ReadOnlyTest) {
-  InitTextfield(Textfield::STYLE_DEFAULT);
+  InitTextfield();
   textfield_->SetText(ASCIIToUTF16("read only"));
   textfield_->SetReadOnly(true);
   EXPECT_TRUE(textfield_->enabled());
-  EXPECT_TRUE(textfield_->focusable());
+  EXPECT_TRUE(textfield_->IsFocusable());
 
   SendKeyEvent(ui::VKEY_HOME);
   EXPECT_EQ(0U, textfield_->GetCursorPosition());
   SendKeyEvent(ui::VKEY_END);
   EXPECT_EQ(9U, textfield_->GetCursorPosition());
 
   SendKeyEvent(ui::VKEY_LEFT, false, false);
   EXPECT_EQ(8U, textfield_->GetCursorPosition());
   SendKeyEvent(ui::VKEY_LEFT, false, true);
   EXPECT_EQ(5U, textfield_->GetCursorPosition());
@@ skipping 41 matching lines @@
   // Text field is unmodifiable and selection shouldn't change.
   SendKeyEvent(ui::VKEY_DELETE);
   EXPECT_STR_EQ(" four five six ", textfield_->GetSelectedText());
   SendKeyEvent(ui::VKEY_BACK);
   EXPECT_STR_EQ(" four five six ", textfield_->GetSelectedText());
   SendKeyEvent(ui::VKEY_T);
   EXPECT_STR_EQ(" four five six ", textfield_->GetSelectedText());
 }
 
 TEST_F(TextfieldTest, TextInputClientTest) {
-  InitTextfield(Textfield::STYLE_DEFAULT);
+  InitTextfield();
   ui::TextInputClient* client = textfield_->GetTextInputClient();
   EXPECT_TRUE(client);
   EXPECT_EQ(ui::TEXT_INPUT_TYPE_TEXT, client->GetTextInputType());
 
   textfield_->SetText(ASCIIToUTF16("0123456789"));
   gfx::Range range;
   EXPECT_TRUE(client->GetTextRange(&range));
   EXPECT_EQ(0U, range.start());
   EXPECT_EQ(10U, range.end());
 
@@ skipping 78 matching lines @@
   EXPECT_EQ(0, on_before_user_action_);
   EXPECT_EQ(0, on_after_user_action_);
 
   input_method_->Clear();
   textfield_->SetReadOnly(true);
   EXPECT_TRUE(input_method_->text_input_type_changed());
   EXPECT_FALSE(textfield_->GetTextInputClient());
 
   textfield_->SetReadOnly(false);
   input_method_->Clear();
-  textfield_->SetObscured(true);
+  textfield_->SetTextInputType(ui::TEXT_INPUT_TYPE_PASSWORD);
   EXPECT_TRUE(input_method_->text_input_type_changed());
   EXPECT_TRUE(textfield_->GetTextInputClient());
 }
 
 TEST_F(TextfieldTest, UndoRedoTest) {
-  InitTextfield(Textfield::STYLE_DEFAULT);
+  InitTextfield();
   SendKeyEvent(ui::VKEY_A);
   EXPECT_STR_EQ("a", textfield_->text());
   SendKeyEvent(ui::VKEY_Z, false, true);
   EXPECT_STR_EQ("", textfield_->text());
   SendKeyEvent(ui::VKEY_Z, false, true);
   EXPECT_STR_EQ("", textfield_->text());
   SendKeyEvent(ui::VKEY_Y, false, true);
   EXPECT_STR_EQ("a", textfield_->text());
   SendKeyEvent(ui::VKEY_Y, false, true);
   EXPECT_STR_EQ("a", textfield_->text());
@@ skipping 73 matching lines @@
   EXPECT_STR_EQ("ab", textfield_->text());
   SendKeyEvent(ui::VKEY_Y, false, true);
   EXPECT_STR_EQ("b", textfield_->text());
   SendKeyEvent(ui::VKEY_Y, false, true);
   EXPECT_STR_EQ("", textfield_->text());
   SendKeyEvent(ui::VKEY_Y, false, true);
   EXPECT_STR_EQ("", textfield_->text());
 }
 
 TEST_F(TextfieldTest, CutCopyPaste) {
-  InitTextfield(Textfield::STYLE_DEFAULT);
+  InitTextfield();
 
   // Ensure IDS_APP_CUT cuts.
   textfield_->SetText(ASCIIToUTF16("123"));
   textfield_->SelectAll(false);
   EXPECT_TRUE(textfield_->IsCommandIdEnabled(IDS_APP_CUT));
   textfield_->ExecuteCommand(IDS_APP_CUT, 0);
   EXPECT_STR_EQ("123", base::string16(GetClipboardText()));
   EXPECT_STR_EQ("", textfield_->text());
 
   // Ensure [Ctrl]+[x] cuts and [Ctrl]+[Alt][x] does nothing.
@@ skipping 50 matching lines @@
   EXPECT_STR_EQ("abcabcabc", textfield_->text());
 
   // Ensure [Ctrl]+[Shift]+[Insert] is a no-op.
   textfield_->SelectAll(false);
   SendKeyEvent(ui::VKEY_INSERT, true, true);
   EXPECT_STR_EQ("abc", base::string16(GetClipboardText()));
   EXPECT_STR_EQ("abcabcabc", textfield_->text());
 }
 
 TEST_F(TextfieldTest, OvertypeMode) {
-  InitTextfield(Textfield::STYLE_DEFAULT);
+  InitTextfield();
   // Overtype mode should be disabled (no-op [Insert]).
   textfield_->SetText(ASCIIToUTF16("2"));
   SendKeyEvent(ui::VKEY_HOME);
   SendKeyEvent(ui::VKEY_INSERT);
   SendKeyEvent(ui::VKEY_1, false, false);
   EXPECT_STR_EQ("12", textfield_->text());
 }
 
 TEST_F(TextfieldTest, TextCursorDisplayTest) {
-  InitTextfield(Textfield::STYLE_DEFAULT);
+  InitTextfield();
   // LTR-RTL string in LTR context.
   SendKeyEvent('a');
   EXPECT_STR_EQ("a", textfield_->text());
   int x = GetCursorBounds().x();
   int prev_x = x;
 
   SendKeyEvent('b');
   EXPECT_STR_EQ("ab", textfield_->text());
   x = GetCursorBounds().x();
   EXPECT_LT(prev_x, x);
@@ skipping 34 matching lines @@
   SendKeyEvent('b');
   EXPECT_EQ(WideToUTF16(L"\x05E1\x5E2" L"ab"), textfield_->text());
   x = GetCursorBounds().x();
   EXPECT_LT(prev_x, x);
 }
 
 TEST_F(TextfieldTest, TextCursorDisplayInRTLTest) {
   std::string locale = l10n_util::GetApplicationLocale("");
   base::i18n::SetICUDefaultLocale("he");
 
-  InitTextfield(Textfield::STYLE_DEFAULT);
+  InitTextfield();
   // LTR-RTL string in RTL context.
   SendKeyEvent('a');
   EXPECT_STR_EQ("a", textfield_->text());
   int x = GetCursorBounds().x();
   EXPECT_EQ(GetDisplayRect().right() - 1, x);
   int prev_x = x;
 
   SendKeyEvent('b');
   EXPECT_STR_EQ("ab", textfield_->text());
   x = GetCursorBounds().x();
@@ skipping 34 matching lines @@
   SendKeyEvent('b');
   EXPECT_EQ(WideToUTF16(L"\x05E1\x5E2" L"ab"), textfield_->text());
   x = GetCursorBounds().x();
   EXPECT_EQ(prev_x, x);
 
   // Reset locale.
   base::i18n::SetICUDefaultLocale(locale);
 }
 
 TEST_F(TextfieldTest, HitInsideTextAreaTest) {
-  InitTextfield(Textfield::STYLE_DEFAULT);
+  InitTextfield();
   textfield_->SetText(WideToUTF16(L"ab\x05E1\x5E2"));
   std::vector<gfx::Rect> cursor_bounds;
 
   // Save each cursor bound.
   gfx::SelectionModel sel(0, gfx::CURSOR_FORWARD);
   cursor_bounds.push_back(GetCursorBounds(sel));
 
   sel = gfx::SelectionModel(1, gfx::CURSOR_BACKWARD);
   gfx::Rect bound = GetCursorBounds(sel);
   sel = gfx::SelectionModel(1, gfx::CURSOR_FORWARD);
@@ skipping 34 matching lines @@
     NonClientMouseClick();
 
     MouseClick(cursor_bounds[i + 1], - (half_width / 2));
     EXPECT_EQ(cursor_pos_expected[index++], textfield_->GetCursorPosition());
 
     NonClientMouseClick();
   }
 }
 
 TEST_F(TextfieldTest, HitOutsideTextAreaTest) {
-  InitTextfield(Textfield::STYLE_DEFAULT);
+  InitTextfield();
 
   // LTR-RTL string in LTR context.
   textfield_->SetText(WideToUTF16(L"ab\x05E1\x5E2"));
 
   SendKeyEvent(ui::VKEY_HOME);
   gfx::Rect bound = GetCursorBounds();
   MouseClick(bound, -10);
   EXPECT_EQ(bound, GetCursorBounds());
 
   SendKeyEvent(ui::VKEY_END);
@@ skipping 14 matching lines @@
   SendKeyEvent(ui::VKEY_END);
   bound = GetCursorBounds();
   MouseClick(bound, -10);
   EXPECT_EQ(bound, GetCursorBounds());
 }
 
 TEST_F(TextfieldTest, HitOutsideTextAreaInRTLTest) {
   std::string locale = l10n_util::GetApplicationLocale("");
   base::i18n::SetICUDefaultLocale("he");
 
-  InitTextfield(Textfield::STYLE_DEFAULT);
+  InitTextfield();
 
   // RTL-LTR string in RTL context.
   textfield_->SetText(WideToUTF16(L"\x05E1\x5E2" L"ab"));
   SendKeyEvent(ui::VKEY_HOME);
   gfx::Rect bound = GetCursorBounds();
   MouseClick(bound, 10);
   EXPECT_EQ(bound, GetCursorBounds());
 
   SendKeyEvent(ui::VKEY_END);
   bound = GetCursorBounds();
@@ skipping 12 matching lines @@
   SendKeyEvent(ui::VKEY_END);
   bound = GetCursorBounds();
   MouseClick(bound, 10);
   EXPECT_EQ(bound, GetCursorBounds());
 
   // Reset locale.
   base::i18n::SetICUDefaultLocale(locale);
 }
 
 TEST_F(TextfieldTest, OverflowTest) {
-  InitTextfield(Textfield::STYLE_DEFAULT);
+  InitTextfield();
 
   base::string16 str;
   for (int i = 0; i < 500; ++i)
     SendKeyEvent('a');
   SendKeyEvent(kHebrewLetterSamekh);
   EXPECT_TRUE(GetDisplayRect().Contains(GetCursorBounds()));
 
   // Test mouse pointing.
   MouseClick(GetCursorBounds(), -1);
   EXPECT_EQ(500U, textfield_->GetCursorPosition());
 
   // Clear text.
   SendKeyEvent(ui::VKEY_A, false, true);
   SendKeyEvent('\n');
 
   for (int i = 0; i < 500; ++i)
     SendKeyEvent(kHebrewLetterSamekh);
   SendKeyEvent('a');
   EXPECT_TRUE(GetDisplayRect().Contains(GetCursorBounds()));
 
   MouseClick(GetCursorBounds(), -1);
   EXPECT_EQ(501U, textfield_->GetCursorPosition());
 }
 
 TEST_F(TextfieldTest, OverflowInRTLTest) {
   std::string locale = l10n_util::GetApplicationLocale("");
   base::i18n::SetICUDefaultLocale("he");
 
-  InitTextfield(Textfield::STYLE_DEFAULT);
+  InitTextfield();
 
   base::string16 str;
   for (int i = 0; i < 500; ++i)
     SendKeyEvent('a');
   SendKeyEvent(kHebrewLetterSamekh);
   EXPECT_TRUE(GetDisplayRect().Contains(GetCursorBounds()));
 
   MouseClick(GetCursorBounds(), 1);
   EXPECT_EQ(501U, textfield_->GetCursorPosition());
 
   // Clear text.
   SendKeyEvent(ui::VKEY_A, false, true);
   SendKeyEvent('\n');
 
   for (int i = 0; i < 500; ++i)
     SendKeyEvent(kHebrewLetterSamekh);
   SendKeyEvent('a');
   EXPECT_TRUE(GetDisplayRect().Contains(GetCursorBounds()));
 
   MouseClick(GetCursorBounds(), 1);
   EXPECT_EQ(500U, textfield_->GetCursorPosition());
 
   // Reset locale.
   base::i18n::SetICUDefaultLocale(locale);
 }
 
 TEST_F(TextfieldTest, GetCompositionCharacterBoundsTest) {
-  InitTextfield(Textfield::STYLE_DEFAULT);
+  InitTextfield();
 
   base::string16 str;
   const uint32 char_count = 10UL;
   ui::CompositionText composition;
   composition.text = UTF8ToUTF16("0123456789");
   ui::TextInputClient* client = textfield_->GetTextInputClient();
 
   // Return false if there is no composition text.
   gfx::Rect rect;
   EXPECT_FALSE(client->GetCompositionCharacterBounds(0, &rect));
@@ skipping 23 matching lines @@
     EXPECT_EQ(char_rect_in_screen_coord[i], actual_rect) << " i=" << i;
   }
 
   // Return false if the index is out of range.
   EXPECT_FALSE(client->GetCompositionCharacterBounds(char_count, &rect));
   EXPECT_FALSE(client->GetCompositionCharacterBounds(char_count + 1, &rect));
   EXPECT_FALSE(client->GetCompositionCharacterBounds(char_count + 100, &rect));
 }
 
 TEST_F(TextfieldTest, GetCompositionCharacterBounds_ComplexText) {
-  InitTextfield(Textfield::STYLE_DEFAULT);
+  InitTextfield();
 
   const base::char16 kUtf16Chars[] = {
     // U+0020 SPACE
     0x0020,
     // U+1F408 (CAT) as surrogate pair
     0xd83d, 0xdc08,
     // U+5642 as Ideographic Variation Sequences
     0x5642, 0xDB40, 0xDD00,
     // U+260E (BLACK TELEPHONE) as Emoji Variation Sequences
     0x260E, 0xFE0F,
@@ skipping 16 matching lines @@
   // Here we might expect the following results but it actually depends on how
   // Uniscribe or HarfBuzz treats them with given font.
   // - rects[1] == rects[2]
   // - rects[3] == rects[4] == rects[5]
   // - rects[6] == rects[7]
 }
 
 // The word we select by double clicking should remain selected regardless of
 // where we drag the mouse afterwards without releasing the left button.
 TEST_F(TextfieldTest, KeepInitiallySelectedWord) {
-  InitTextfield(Textfield::STYLE_DEFAULT);
+  InitTextfield();
 
   textfield_->SetText(ASCIIToUTF16("abc def ghi"));
 
   textfield_->SelectRange(gfx::Range(5, 5));
   const gfx::Rect middle_cursor = GetCursorBounds();
   textfield_->SelectRange(gfx::Range(0, 0));
   const gfx::Point beginning = GetCursorBounds().origin();
 
   // Double click, but do not release the left button.
   MouseClick(middle_cursor, 0);
   const gfx::Point middle(middle_cursor.x(),
                           middle_cursor.y() + middle_cursor.height() / 2);
   ui::MouseEvent press_event(ui::ET_MOUSE_PRESSED, middle, middle,
                              ui::EF_LEFT_MOUSE_BUTTON,
                              ui::EF_LEFT_MOUSE_BUTTON);
   textfield_->OnMousePressed(press_event);
   EXPECT_EQ(gfx::Range(4, 7), textfield_->GetSelectedRange());
 
   // Drag the mouse to the beginning of the textfield.
   ui::MouseEvent drag_event(ui::ET_MOUSE_DRAGGED, beginning, beginning,
                             ui::EF_LEFT_MOUSE_BUTTON, 0);
   textfield_->OnMouseDragged(drag_event);
   EXPECT_EQ(gfx::Range(7, 0), textfield_->GetSelectedRange());
 }
 
 // Touch selection and dragging currently only works for chromeos.
 #if defined(OS_CHROMEOS)
 TEST_F(TextfieldTest, TouchSelectionAndDraggingTest) {
-  InitTextfield(Textfield::STYLE_DEFAULT);
+  InitTextfield();
   textfield_->SetText(ASCIIToUTF16("hello world"));
   EXPECT_FALSE(GetTouchSelectionController());
   const int x = GetCursorPositionX(2);
   GestureEventForTest tap(ui::ET_GESTURE_TAP, x, 0, 1.0f, 0.0f);
   GestureEventForTest tap_down(ui::ET_GESTURE_TAP_DOWN, x, 0, 0.0f, 0.0f);
   GestureEventForTest long_press(ui::ET_GESTURE_LONG_PRESS, x, 0, 0.0f, 0.0f);
   CommandLine::ForCurrentProcess()->AppendSwitch(switches::kEnableTouchEditing);
 
   // Tapping on the textfield should turn on the TouchSelectionController.
   textfield_->OnGestureEvent(&tap);
@@ skipping 24 matching lines @@
       switches::kDisableTouchDragDrop);
   ASSERT_FALSE(switches::IsTouchDragDropEnabled());
   textfield_->OnGestureEvent(&tap_down);
   textfield_->OnGestureEvent(&long_press);
   EXPECT_STR_EQ("hello", textfield_->GetSelectedText());
   EXPECT_TRUE(GetTouchSelectionController());
   EXPECT_TRUE(long_press.handled());
 }
 
 TEST_F(TextfieldTest, TouchScrubbingSelection) {
-  InitTextfield(Textfield::STYLE_DEFAULT);
+  InitTextfield();
   textfield_->SetText(ASCIIToUTF16("hello world"));
   EXPECT_FALSE(GetTouchSelectionController());
 
   CommandLine::ForCurrentProcess()->AppendSwitch(switches::kEnableTouchEditing);
 
   // Simulate touch-scrubbing.
   int scrubbing_start = GetCursorPositionX(1);
   int scrubbing_end = GetCursorPositionX(6);
 
   GestureEventForTest tap_down(ui::ET_GESTURE_TAP_DOWN, scrubbing_start, 0,
@@ skipping 21 matching lines @@
 
   // In the end, part of text should have been selected and handles should have
   // appeared.
   EXPECT_STR_EQ("ello ", textfield_->GetSelectedText());
   EXPECT_TRUE(GetTouchSelectionController());
 }
 #endif
 
 // Long_Press gesture in Textfield can initiate a drag and drop now.
 TEST_F(TextfieldTest, TestLongPressInitiatesDragDrop) {
-  InitTextfield(Textfield::STYLE_DEFAULT);
+  InitTextfield();
   textfield_->SetText(ASCIIToUTF16("Hello string world"));
 
   // Ensure the textfield will provide selected text for drag data.
   textfield_->SelectRange(gfx::Range(6, 12));
   const gfx::Point kStringPoint(GetCursorPositionX(9), 0);
 
   // Enable touch-drag-drop to make long press effective.
   CommandLine::ForCurrentProcess()->AppendSwitch(
       switches::kEnableTouchDragDrop);
 
   // Create a long press event in the selected region should start a drag.
   GestureEventForTest long_press(ui::ET_GESTURE_LONG_PRESS, kStringPoint.x(),
                                  kStringPoint.y(), 0.0f, 0.0f);
   textfield_->OnGestureEvent(&long_press);
   EXPECT_TRUE(textfield_->CanStartDragForView(NULL, kStringPoint,
                                               kStringPoint));
 }
 
 TEST_F(TextfieldTest, GetTextfieldBaseline_FontFallbackTest) {
-  InitTextfield(Textfield::STYLE_DEFAULT);
+  InitTextfield();
   textfield_->SetText(UTF8ToUTF16("abc"));
   const int old_baseline = textfield_->GetBaseline();
 
   // Set text which may fall back to a font which has taller baseline than
   // the default font.
   textfield_->SetText(UTF8ToUTF16("\xE0\xB9\x91"));
   const int new_baseline = textfield_->GetBaseline();
 
   // Regardless of the text, the baseline must be the same.
   EXPECT_EQ(new_baseline, old_baseline);
 }
 
 }  // namespace views