Integrate the new input method API for Views into Chromium.

views/controls/textfield/native_textfield_views_unittest.cc

Index: views/controls/textfield/native_textfield_views_unittest.cc
diff --git a/views/controls/textfield/native_textfield_views_unittest.cc b/views/controls/textfield/native_textfield_views_unittest.cc
index 417a4b975ca712a226bc1a620b17c2f8b3889b54..299f2aee6a3fb1c68b8d69973ac6619a2407d166 100644
--- a/views/controls/textfield/native_textfield_views_unittest.cc
+++ b/views/controls/textfield/native_textfield_views_unittest.cc
@@ -3,6 +3,9 @@
 // found in the LICENSE file.
 
 #include "base/auto_reset.h"
+#include "base/bind.h"
+#include "base/bind_helpers.h"
+#include "base/callback.h"
 #include "base/message_loop.h"
 #include "base/utf_string_conversions.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ -16,11 +19,70 @@
 #include "views/controls/textfield/textfield_views_model.h"
 #include "views/events/event.h"
 #include "views/focus/focus_manager.h"
+#include "views/ime/mock_input_method.h"
+#include "views/ime/text_input_client.h"
 #include "views/test/test_views_delegate.h"
 #include "views/test/views_test_base.h"
 #include "views/views_delegate.h"
+#include "views/widget/native_widget.h"
 #include "views/widget/widget.h"
 
+namespace {
+
+// A wrapper of Textfield to intercept the result of OnKeyPressed() and
+// OnKeyReleased() methods.
+class TestTextfield : public views::Textfield {
+ public:
+  TestTextfield()
+      : key_handled_(false),
+        key_received_(false) {
+  }
+
+  explicit TestTextfield(StyleFlags style)
+      : Textfield(style),
+        key_handled_(false),
+        key_received_(false) {
+  }
+
+  virtual bool OnKeyPressed(const views::KeyEvent& e) OVERRIDE {
+    key_received_ = true;
+    key_handled_ = views::Textfield::OnKeyPressed(e);
+    return key_handled_;
+  }
+
+  virtual bool OnKeyReleased(const views::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;
+  }
+
+ private:
+  bool key_handled_;
+  bool key_received_;
+};
+
+// A helper class for use with TextInputClient::GetTextFromRange().
+class GetTextHelper {
+ public:
+  GetTextHelper() {
+  }
+
+  void set_text(const string16& text) { text_ = text; }
+  const string16& text() const { return text_; }
+
+ private:
+  string16 text_;
+};
+
+}  // namespace
+
 namespace views {
 
 // Convert to Wide so that the printed string will be readable when
@@ -40,7 +102,10 @@ class NativeTextfieldViewsTest : public ViewsTestBase,
       : widget_(NULL),
         textfield_(NULL),
         textfield_view_(NULL),
-        model_(NULL) {
+        model_(NULL),
+        input_method_(NULL),
+        on_before_user_action_(0),
+        on_after_user_action_(0) {
   }
 
   // ::testing::Test:
@@ -57,7 +122,8 @@ class NativeTextfieldViewsTest : public ViewsTestBase,
 
   // TextfieldController:
   virtual void ContentsChanged(Textfield* sender,
-                               const string16& new_contents){
+                               const string16& new_contents) {
+    ASSERT_NE(last_contents_, new_contents);
     last_contents_ = new_contents;
   }
 
@@ -68,13 +134,21 @@ class NativeTextfieldViewsTest : public ViewsTestBase,
     return false;
   }
 
+  virtual void OnBeforeUserAction(Textfield* sender) {
+    ++on_before_user_action_;
+  }
+
+  virtual void OnAfterUserAction(Textfield* sender) {
+    ++on_after_user_action_;
+  }
+
   void InitTextfield(Textfield::StyleFlags style) {
     InitTextfields(style, 1);
   }
 
   void InitTextfields(Textfield::StyleFlags style, int count) {
     ASSERT_FALSE(textfield_);
-    textfield_ = new Textfield(style);
+    textfield_ = new TestTextfield(style);
     textfield_->SetController(this);
     Widget::CreateParams params(Widget::CreateParams::TYPE_POPUP);
     params.mirror_origin_in_rtl = false;
@@ -96,6 +170,11 @@ class NativeTextfieldViewsTest : public ViewsTestBase,
 
     DCHECK(textfield_view_);
     model_ = textfield_view_->model_.get();
+
+    input_method_ = new MockInputMethod();
+    widget_->native_widget()->ReplaceInputMethod(input_method_);
+
+    textfield_->RequestFocus();
   }
 
   views::Menu2* GetContextMenu() {
@@ -108,25 +187,23 @@ class NativeTextfieldViewsTest : public ViewsTestBase,
   }
 
  protected:
-  bool SendKeyEventToTextfieldViews(ui::KeyboardCode key_code,
-                                    bool shift,
-                                    bool control,
-                                    bool capslock) {
+  void SendKeyEvent(ui::KeyboardCode key_code,
+                    bool shift,
+                    bool control,
+                    bool capslock) {
     int flags = (shift ? ui::EF_SHIFT_DOWN : 0) |
         (control ? ui::EF_CONTROL_DOWN : 0) |
         (capslock ? ui::EF_CAPS_LOCK_DOWN : 0);
     KeyEvent event(ui::ET_KEY_PRESSED, key_code, flags);
-    return textfield_->OnKeyPressed(event);
+    input_method_->DispatchKeyEvent(event);
   }
 
-  bool SendKeyEventToTextfieldViews(ui::KeyboardCode key_code,
-                                    bool shift,
-                                    bool control) {
-    return SendKeyEventToTextfieldViews(key_code, shift, control, false);
+  void SendKeyEvent(ui::KeyboardCode key_code, bool shift, bool control) {
+    SendKeyEvent(key_code, shift, control, false);
   }
 
-  bool SendKeyEventToTextfieldViews(ui::KeyboardCode key_code) {
-    return SendKeyEventToTextfieldViews(key_code, false, false);
+  void SendKeyEvent(ui::KeyboardCode key_code) {
+    SendKeyEvent(key_code, false, false);
   }
 
   View* GetFocusedView() {
@@ -136,37 +213,41 @@ class NativeTextfieldViewsTest : public ViewsTestBase,
   // We need widget to populate wrapper class.
   Widget* widget_;
 
-  Textfield* textfield_;
+  TestTextfield* textfield_;
   NativeTextfieldViews* textfield_view_;
   TextfieldViewsModel* model_;
 
   // The string from Controller::ContentsChanged callback.
   string16 last_contents_;
 
+  // For testing input method related behaviors.
+  MockInputMethod* input_method_;
+
+  // Indicates how many times OnBeforeUserAction() is called.
+  int on_before_user_action_;
+
+  // Indicates how many times OnAfterUserAction() is called.
+  int on_after_user_action_;
+
  private:
   DISALLOW_COPY_AND_ASSIGN(NativeTextfieldViewsTest);
 };
 
-TEST_F(NativeTextfieldViewsTest, ModelChangesTeset) {
+TEST_F(NativeTextfieldViewsTest, ModelChangesTest) {
   InitTextfield(Textfield::STYLE_DEFAULT);
-  textfield_->SetText(ASCIIToUTF16("this is"));
-
-  EXPECT_STR_EQ("this is", model_->text());
-  EXPECT_STR_EQ("this is", last_contents_);
-  last_contents_.clear();
 
-  textfield_->AppendText(ASCIIToUTF16(" a test"));
-  EXPECT_STR_EQ("this is a test", model_->text());
-  EXPECT_STR_EQ("this is a test", last_contents_);
+  // TextfieldController::ContentsChanged() shouldn't be called when changing
+  // text programmatically.
   last_contents_.clear();
+  textfield_->SetText(ASCIIToUTF16("this is"));
 
-  // Cases where the callback should not be called.
-  textfield_->SetText(ASCIIToUTF16("this is a test"));
-  EXPECT_STR_EQ("this is a test", model_->text());
+  EXPECT_STR_EQ("this is", model_->text());
+  EXPECT_STR_EQ("this is", textfield_->text());
   EXPECT_EQ(string16(), last_contents_);

[oshima, 2011/03/22 01:50:39]

Why this is empty string now?

[James Su, 2011/03/22 08:41:14]

Because TextfieldController::ContentsChanged() won't be called when the textt is
changed by calling Textfield::SetText().

[oshima, 2011/03/28 19:56:49]

EXPECT_TRUE(last_contents_.empty())

[James Su, 2011/03/28 21:25:34]

Done.

 
-  textfield_->AppendText(string16());
+  textfield_->AppendText(ASCIIToUTF16(" a test"));
   EXPECT_STR_EQ("this is a test", model_->text());
+  EXPECT_STR_EQ("this is a test", textfield_->text());
   EXPECT_EQ(string16(), last_contents_);
 
   EXPECT_EQ(string16(), textfield_->GetSelectedText());
@@ -177,21 +258,21 @@ TEST_F(NativeTextfieldViewsTest, ModelChangesTeset) {
 
 TEST_F(NativeTextfieldViewsTest, KeyTest) {
   InitTextfield(Textfield::STYLE_DEFAULT);
-  SendKeyEventToTextfieldViews(ui::VKEY_C, true, false);
+  SendKeyEvent(ui::VKEY_C, true, false);
   EXPECT_STR_EQ("C", textfield_->text());
   EXPECT_STR_EQ("C", last_contents_);
   last_contents_.clear();
 
-  SendKeyEventToTextfieldViews(ui::VKEY_R, false, false);
+  SendKeyEvent(ui::VKEY_R, false, false);
   EXPECT_STR_EQ("Cr", textfield_->text());
   EXPECT_STR_EQ("Cr", last_contents_);
 
   textfield_->SetText(ASCIIToUTF16(""));
-  SendKeyEventToTextfieldViews(ui::VKEY_C, true, false, true);
-  SendKeyEventToTextfieldViews(ui::VKEY_C, false, false, true);
-  SendKeyEventToTextfieldViews(ui::VKEY_1, false, false, true);
-  SendKeyEventToTextfieldViews(ui::VKEY_1, true, false, true);
-  SendKeyEventToTextfieldViews(ui::VKEY_1, true, false, false);
+  SendKeyEvent(ui::VKEY_C, true, false, true);
+  SendKeyEvent(ui::VKEY_C, false, false, true);
+  SendKeyEvent(ui::VKEY_1, false, false, true);
+  SendKeyEvent(ui::VKEY_1, true, false, true);
+  SendKeyEvent(ui::VKEY_1, true, false, false);
   EXPECT_STR_EQ("cC1!!", textfield_->text());
   EXPECT_STR_EQ("cC1!!", last_contents_);
 }
@@ -200,34 +281,34 @@ TEST_F(NativeTextfieldViewsTest, ControlAndSelectTest) {
   // Insert a test string in a textfield.
   InitTextfield(Textfield::STYLE_DEFAULT);
   textfield_->SetText(ASCIIToUTF16("one two three"));
-  SendKeyEventToTextfieldViews(ui::VKEY_RIGHT,
+  SendKeyEvent(ui::VKEY_RIGHT,
                               true /* shift */, false /* control */);
-  SendKeyEventToTextfieldViews(ui::VKEY_RIGHT, true, false);
-  SendKeyEventToTextfieldViews(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.
-  SendKeyEventToTextfieldViews(ui::VKEY_RIGHT, true, true);
+  SendKeyEvent(ui::VKEY_RIGHT, true, true);
   EXPECT_STR_EQ("one two", textfield_->GetSelectedText());
-  SendKeyEventToTextfieldViews(ui::VKEY_RIGHT, true, true);
+  SendKeyEvent(ui::VKEY_RIGHT, true, true);
   EXPECT_STR_EQ("one two three", textfield_->GetSelectedText());
-  SendKeyEventToTextfieldViews(ui::VKEY_LEFT, true, true);
+  SendKeyEvent(ui::VKEY_LEFT, true, true);
   EXPECT_STR_EQ("one two ", textfield_->GetSelectedText());
-  SendKeyEventToTextfieldViews(ui::VKEY_LEFT, true, true);
+  SendKeyEvent(ui::VKEY_LEFT, true, true);
   EXPECT_STR_EQ("one ", textfield_->GetSelectedText());
 
   // Replace the selected text.
-  SendKeyEventToTextfieldViews(ui::VKEY_Z, true, false);
-  SendKeyEventToTextfieldViews(ui::VKEY_E, true, false);
-  SendKeyEventToTextfieldViews(ui::VKEY_R, true, false);
-  SendKeyEventToTextfieldViews(ui::VKEY_O, true, false);
-  SendKeyEventToTextfieldViews(ui::VKEY_SPACE, false, false);
+  SendKeyEvent(ui::VKEY_Z, true, false);
+  SendKeyEvent(ui::VKEY_E, true, false);
+  SendKeyEvent(ui::VKEY_R, true, false);
+  SendKeyEvent(ui::VKEY_O, true, false);
+  SendKeyEvent(ui::VKEY_SPACE, false, false);
   EXPECT_STR_EQ("ZERO two three", textfield_->text());
 
-  SendKeyEventToTextfieldViews(ui::VKEY_END, true, false);
+  SendKeyEvent(ui::VKEY_END, true, false);
   EXPECT_STR_EQ("two three", textfield_->GetSelectedText());
-  SendKeyEventToTextfieldViews(ui::VKEY_HOME, true, false);
+  SendKeyEvent(ui::VKEY_HOME, true, false);
   EXPECT_STR_EQ("ZERO ", textfield_->GetSelectedText());
 }
 
@@ -242,41 +323,41 @@ TEST_F(NativeTextfieldViewsTest, InsertionDeletionTest) {
     ui::KeyboardCode code =
         c == ' ' ? ui::VKEY_SPACE :
         static_cast<ui::KeyboardCode>(ui::VKEY_A + c - 'a');
-    SendKeyEventToTextfieldViews(code);
+    SendKeyEvent(code);
   }
   EXPECT_STR_EQ(test_str, textfield_->text());
 
   // Move the cursor around.
   for (int i = 0; i < 6; i++) {
-    SendKeyEventToTextfieldViews(ui::VKEY_LEFT);
+    SendKeyEvent(ui::VKEY_LEFT);
   }
-  SendKeyEventToTextfieldViews(ui::VKEY_RIGHT);
+  SendKeyEvent(ui::VKEY_RIGHT);
 
   // Delete using backspace and check resulting string.
-  SendKeyEventToTextfieldViews(ui::VKEY_BACK);
+  SendKeyEvent(ui::VKEY_BACK);
   EXPECT_STR_EQ("this is  test", textfield_->text());
 
   // Delete using delete key and check resulting string.
   for (int i = 0; i < 5; i++) {
-    SendKeyEventToTextfieldViews(ui::VKEY_DELETE);
+    SendKeyEvent(ui::VKEY_DELETE);
   }
   EXPECT_STR_EQ("this is ", textfield_->text());
 
   // Select all and replace with "k".
   textfield_->SelectAll();
-  SendKeyEventToTextfieldViews(ui::VKEY_K);
+  SendKeyEvent(ui::VKEY_K);
   EXPECT_STR_EQ("k", textfield_->text());
 
   // Delete the previous word from cursor.
   textfield_->SetText(ASCIIToUTF16("one two three four"));
-  SendKeyEventToTextfieldViews(ui::VKEY_END);
-  SendKeyEventToTextfieldViews(ui::VKEY_BACK, false, true, false);
+  SendKeyEvent(ui::VKEY_END);
+  SendKeyEvent(ui::VKEY_BACK, false, true, false);
   EXPECT_STR_EQ("one two three ", textfield_->text());
 
   // Delete upto the beginning of the buffer from cursor in chromeos, do nothing
   // in windows.
-  SendKeyEventToTextfieldViews(ui::VKEY_LEFT, false, true, false);
-  SendKeyEventToTextfieldViews(ui::VKEY_BACK, true, true, false);
+  SendKeyEvent(ui::VKEY_LEFT, false, true, false);
+  SendKeyEvent(ui::VKEY_BACK, true, true, false);
 #if defined(OS_WIN)
   EXPECT_STR_EQ("one two three ", textfield_->text());
 #else
@@ -285,14 +366,14 @@ TEST_F(NativeTextfieldViewsTest, InsertionDeletionTest) {
 
   // Delete the next word from cursor.
   textfield_->SetText(ASCIIToUTF16("one two three four"));
-  SendKeyEventToTextfieldViews(ui::VKEY_HOME);
-  SendKeyEventToTextfieldViews(ui::VKEY_DELETE, false, true, false);
+  SendKeyEvent(ui::VKEY_HOME);
+  SendKeyEvent(ui::VKEY_DELETE, false, true, false);
   EXPECT_STR_EQ(" two three four", textfield_->text());
 
   // Delete upto the end of the buffer from cursor in chromeos, do nothing
   // in windows.
-  SendKeyEventToTextfieldViews(ui::VKEY_RIGHT, false, true, false);
-  SendKeyEventToTextfieldViews(ui::VKEY_DELETE, true, true, false);
+  SendKeyEvent(ui::VKEY_RIGHT, false, true, false);
+  SendKeyEvent(ui::VKEY_DELETE, true, true, false);
 #if defined(OS_WIN)
   EXPECT_STR_EQ(" two three four", textfield_->text());
 #else
@@ -306,16 +387,37 @@ TEST_F(NativeTextfieldViewsTest, PasswordTest) {
   // Just to make sure the text() and callback returns
   // the actual text instead of "*".
   EXPECT_STR_EQ("my password", textfield_->text());
-  EXPECT_STR_EQ("my password", last_contents_);

[oshima, 2011/03/22 01:50:39]

is this no longer valid?

[James Su, 2011/03/22 08:41:14]

With this CL, TextfieldController::ContentsChanged() will never be called when
the text is changed programmatically.
Because in such case, the controller should already know the change, so it makes
no sense to inform the controller again.

[oshima, 2011/03/25 17:31:25]

Above argument is not necessarily true because the code who sets the text and
the code that is interested in the change may be different (in general). I
understand that this is good enough for our use case, but in that case,
can you test if ContentChanged is NOT called?

[James Su, 2011/03/25 20:53:59]

If I understand correctly, according to the old code and comment, this should be
the intended behavior when this API was designed, but somehow we had broken
implementation. That's why the |ignore_contents_changed_| hack was introduced in
chrome/browser/ui/views/find_bar_view.cc. But please correct me if I'm wrong.

This behavior is tested in ModelChangesTest.

[oshima, 2011/03/25 21:41:58]

ContentsChanges predates my chrome era and I was trying to replicate existing
gtk behavior. I agree that your change simplifies findbar code, and I'm all for
it unless it breaks other stuff.

Since ChangeContented has been moved to Textfield class, testing model isn't
enough and we need to test it here.

[James Su, 2011/03/25 21:48:20]

Yes. The ModelChangesTest is in this file, see above around line 236.

[oshima, 2011/03/28 19:56:49]

Please add the same test, as this is for password.

[James Su, 2011/03/28 21:25:34]

Done.

 }
 
 TEST_F(NativeTextfieldViewsTest, OnKeyPressReturnValueTest) {
   InitTextfield(Textfield::STYLE_DEFAULT);
-  EXPECT_TRUE(SendKeyEventToTextfieldViews(ui::VKEY_A));
+
+  // 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());
+  EXPECT_TRUE(textfield_->key_handled());
+  textfield_->clear();
+
   // F24, up/down key won't be handled.
-  EXPECT_FALSE(SendKeyEventToTextfieldViews(ui::VKEY_F24));
-  EXPECT_FALSE(SendKeyEventToTextfieldViews(ui::VKEY_UP));
-  EXPECT_FALSE(SendKeyEventToTextfieldViews(ui::VKEY_DOWN));
+  SendKeyEvent(ui::VKEY_F24);
+  EXPECT_TRUE(textfield_->key_received());
+  EXPECT_FALSE(textfield_->key_handled());
+  textfield_->clear();
+
+  SendKeyEvent(ui::VKEY_UP);
+  EXPECT_TRUE(textfield_->key_received());
+  EXPECT_FALSE(textfield_->key_handled());
+  textfield_->clear();
+
+  SendKeyEvent(ui::VKEY_DOWN);
+  EXPECT_TRUE(textfield_->key_received());
+  EXPECT_FALSE(textfield_->key_handled());
 }
 
 TEST_F(NativeTextfieldViewsTest, CursorMovement) {
@@ -325,23 +427,23 @@ TEST_F(NativeTextfieldViewsTest, CursorMovement) {
   textfield_->SetText(ASCIIToUTF16("one two hre "));
 
   // Send the cursor at the end.
-  SendKeyEventToTextfieldViews(ui::VKEY_END);
+  SendKeyEvent(ui::VKEY_END);
 
   // Ctrl+Left should move the cursor just before the last word.
-  SendKeyEventToTextfieldViews(ui::VKEY_LEFT, false, true);
-  SendKeyEventToTextfieldViews(ui::VKEY_T);
+  SendKeyEvent(ui::VKEY_LEFT, false, true);
+  SendKeyEvent(ui::VKEY_T);
   EXPECT_STR_EQ("one two thre ", textfield_->text());
   EXPECT_STR_EQ("one two thre ", last_contents_);
 
   // Ctrl+Right should move the cursor to the end of the last word.
-  SendKeyEventToTextfieldViews(ui::VKEY_RIGHT, false, true);
-  SendKeyEventToTextfieldViews(ui::VKEY_E);
+  SendKeyEvent(ui::VKEY_RIGHT, false, true);
+  SendKeyEvent(ui::VKEY_E);
   EXPECT_STR_EQ("one two three ", textfield_->text());
   EXPECT_STR_EQ("one two three ", last_contents_);
 
   // Ctrl+Right again should move the cursor to the end.
-  SendKeyEventToTextfieldViews(ui::VKEY_RIGHT, false, true);
-  SendKeyEventToTextfieldViews(ui::VKEY_BACK);
+  SendKeyEvent(ui::VKEY_RIGHT, false, true);
+  SendKeyEvent(ui::VKEY_BACK);
   EXPECT_STR_EQ("one two three", textfield_->text());
   EXPECT_STR_EQ("one two three", last_contents_);
 
@@ -349,34 +451,26 @@ TEST_F(NativeTextfieldViewsTest, CursorMovement) {
   textfield_->SetText(ASCIIToUTF16(" ne two"));
 
   // Send the cursor at the beginning.
-  SendKeyEventToTextfieldViews(ui::VKEY_HOME);
+  SendKeyEvent(ui::VKEY_HOME);
 
   // Ctrl+Right, then Ctrl+Left should move the cursor to the beginning of the
   // first word.
-  SendKeyEventToTextfieldViews(ui::VKEY_RIGHT, false, true);
-  SendKeyEventToTextfieldViews(ui::VKEY_LEFT, false, true);
-  SendKeyEventToTextfieldViews(ui::VKEY_O);
+  SendKeyEvent(ui::VKEY_RIGHT, false, true);
+  SendKeyEvent(ui::VKEY_LEFT, false, true);
+  SendKeyEvent(ui::VKEY_O);
   EXPECT_STR_EQ(" one two", textfield_->text());
   EXPECT_STR_EQ(" one two", last_contents_);
 
   // Ctrl+Left to move the cursor to the beginning of the first word.
-  SendKeyEventToTextfieldViews(ui::VKEY_LEFT, false, true);
+  SendKeyEvent(ui::VKEY_LEFT, false, true);
   // Ctrl+Left again should move the cursor back to the very beginning.
-  SendKeyEventToTextfieldViews(ui::VKEY_LEFT, false, true);
-  SendKeyEventToTextfieldViews(ui::VKEY_DELETE);
+  SendKeyEvent(ui::VKEY_LEFT, false, true);
+  SendKeyEvent(ui::VKEY_DELETE);
   EXPECT_STR_EQ("one two", textfield_->text());
   EXPECT_STR_EQ("one two", last_contents_);
 }
 
-#if defined(OS_WIN)
-// TODO(oshima): Windows' FocusManager::ClearNativeFocus() resets the
-// focused view to NULL, which causes crash in this test.  Figure out
-// why and fix this.
-#define MAYBE_FocusTraversalTest DISABLED_FocusTraversalTest
-#else
-#define MAYBE_FocusTraversalTest FocusTraversalTest
-#endif
-TEST_F(NativeTextfieldViewsTest, MAYBE_FocusTraversalTest) {
+TEST_F(NativeTextfieldViewsTest, FocusTraversalTest) {
   InitTextfields(Textfield::STYLE_DEFAULT, 3);
   textfield_->RequestFocus();
 
@@ -464,19 +558,19 @@ TEST_F(NativeTextfieldViewsTest, ReadOnlyTest) {
   InitTextfield(Textfield::STYLE_DEFAULT);
   textfield_->SetText(ASCIIToUTF16(" one two three "));
   textfield_->SetReadOnly(true);
-  SendKeyEventToTextfieldViews(ui::VKEY_HOME);
+  SendKeyEvent(ui::VKEY_HOME);
   EXPECT_EQ(0U, textfield_->GetCursorPosition());
 
-  SendKeyEventToTextfieldViews(ui::VKEY_END);
+  SendKeyEvent(ui::VKEY_END);
   EXPECT_EQ(15U, textfield_->GetCursorPosition());
 
-  SendKeyEventToTextfieldViews(ui::VKEY_LEFT, false, false);
+  SendKeyEvent(ui::VKEY_LEFT, false, false);
   EXPECT_EQ(14U, textfield_->GetCursorPosition());
 
-  SendKeyEventToTextfieldViews(ui::VKEY_LEFT, false, true);
+  SendKeyEvent(ui::VKEY_LEFT, false, true);
   EXPECT_EQ(9U, textfield_->GetCursorPosition());
 
-  SendKeyEventToTextfieldViews(ui::VKEY_LEFT, true, true);
+  SendKeyEvent(ui::VKEY_LEFT, true, true);
   EXPECT_EQ(5U, textfield_->GetCursorPosition());
   EXPECT_STR_EQ("two ", textfield_->GetSelectedText());
 
@@ -484,14 +578,14 @@ TEST_F(NativeTextfieldViewsTest, ReadOnlyTest) {
   EXPECT_STR_EQ(" one two three ", textfield_->GetSelectedText());
 
   // CUT&PASTE does not work, but COPY works
-  SendKeyEventToTextfieldViews(ui::VKEY_X, false, true);
+  SendKeyEvent(ui::VKEY_X, false, true);
   EXPECT_STR_EQ(" one two three ", textfield_->GetSelectedText());
   string16 str;
   views::ViewsDelegate::views_delegate->GetClipboard()->
       ReadText(ui::Clipboard::BUFFER_STANDARD, &str);
   EXPECT_STR_NE(" one two three ", str);
 
-  SendKeyEventToTextfieldViews(ui::VKEY_C, false, true);
+  SendKeyEvent(ui::VKEY_C, false, true);
   views::ViewsDelegate::views_delegate->GetClipboard()->
       ReadText(ui::Clipboard::BUFFER_STANDARD, &str);
   EXPECT_STR_EQ(" one two three ", str);
@@ -501,7 +595,7 @@ TEST_F(NativeTextfieldViewsTest, ReadOnlyTest) {
   EXPECT_STR_EQ(" four five six ", textfield_->text());
 
   // Paste shouldn't work.
-  SendKeyEventToTextfieldViews(ui::VKEY_V, false, true);
+  SendKeyEvent(ui::VKEY_V, false, true);
   EXPECT_STR_EQ(" four five six ", textfield_->text());
   EXPECT_TRUE(textfield_->GetSelectedText().empty());
 
@@ -509,12 +603,103 @@ TEST_F(NativeTextfieldViewsTest, ReadOnlyTest) {
   EXPECT_STR_EQ(" four five six ", textfield_->GetSelectedText());
 
   // Text field is unmodifiable and selection shouldn't change.
-  SendKeyEventToTextfieldViews(ui::VKEY_DELETE);
+  SendKeyEvent(ui::VKEY_DELETE);
   EXPECT_STR_EQ(" four five six ", textfield_->GetSelectedText());
-  SendKeyEventToTextfieldViews(ui::VKEY_BACK);
+  SendKeyEvent(ui::VKEY_BACK);
   EXPECT_STR_EQ(" four five six ", textfield_->GetSelectedText());
-  SendKeyEventToTextfieldViews(ui::VKEY_T);
+  SendKeyEvent(ui::VKEY_T);
   EXPECT_STR_EQ(" four five six ", textfield_->GetSelectedText());
 }
 
+TEST_F(NativeTextfieldViewsTest, TextInputClientTest) {
+  InitTextfield(Textfield::STYLE_DEFAULT);
+  TextInputClient* client = textfield_->GetTextInputClient();
+  EXPECT_TRUE(client);
+  EXPECT_EQ(ui::TEXT_INPUT_TYPE_TEXT, client->GetTextInputType());
+
+  textfield_->SetText(ASCIIToUTF16("0123456789"));
+  ui::Range range;
+  EXPECT_TRUE(client->GetTextRange(&range));
+  EXPECT_EQ(0U, range.start());
+  EXPECT_EQ(10U, range.end());
+
+  EXPECT_TRUE(client->SetSelectionRange(ui::Range(1, 4)));
+  EXPECT_TRUE(client->GetSelectionRange(&range));
+  EXPECT_EQ(ui::Range(1,4), range);
+
+  // This piece of code failed to compile on trybot.

[oshima, 2011/03/22 01:50:39]

do we know why? If not, can you file a bug so that we can enable when fixed?

[James Su, 2011/03/22 08:41:14]

ajwong already uploaded a CL to fix it: http://codereview.chromium.org/6718021/.

+#if 0
+  GetTextHelper helper;
+  base::Callback<void(string16)> callback =
+      base::Bind(&GetTextHelper::set_text, base::Unretained(&helper));
+
+  EXPECT_TRUE(client->GetTextFromRange(range, callback));
+  EXPECT_STR_EQ("123", helper.text());
+#endif
+
+  EXPECT_TRUE(client->DeleteRange(range));
+  EXPECT_STR_EQ("0456789", textfield_->text());
+
+  ui::Composition composition;
+  composition.text = UTF8ToUTF16("321");
+  // Set composition through input method.
+  input_method_->Clear();
+  input_method_->SetCompositionForNextKey(composition);
+  textfield_->clear();
+
+  on_before_user_action_ = on_after_user_action_ = 0;
+  SendKeyEvent(ui::VKEY_A);
+  EXPECT_TRUE(textfield_->key_received());
+  EXPECT_FALSE(textfield_->key_handled());
+  EXPECT_TRUE(client->HasComposition());
+  EXPECT_TRUE(client->GetCompositionRange(&range));
+  EXPECT_STR_EQ("0321456789", textfield_->text());
+  EXPECT_EQ(ui::Range(1,4), range);
+  EXPECT_EQ(2, on_before_user_action_);
+  EXPECT_EQ(2, on_after_user_action_);
+
+  input_method_->SetResultForNextKey(UTF8ToUTF16("123"));
+  on_before_user_action_ = on_after_user_action_ = 0;
+  textfield_->clear();
+  SendKeyEvent(ui::VKEY_A);
+  EXPECT_TRUE(textfield_->key_received());
+  EXPECT_FALSE(textfield_->key_handled());
+  EXPECT_FALSE(client->HasComposition());
+  EXPECT_FALSE(input_method_->cancel_composition_called());
+  EXPECT_STR_EQ("0123456789", textfield_->text());
+  EXPECT_EQ(2, on_before_user_action_);
+  EXPECT_EQ(2, on_after_user_action_);
+
+  input_method_->Clear();
+  input_method_->SetCompositionForNextKey(composition);
+  textfield_->clear();
+  SendKeyEvent(ui::VKEY_A);
+  EXPECT_TRUE(client->HasComposition());
+  EXPECT_STR_EQ("0123321456789", textfield_->text());
+
+  on_before_user_action_ = on_after_user_action_ = 0;
+  textfield_->clear();
+  SendKeyEvent(ui::VKEY_RIGHT);
+  EXPECT_FALSE(client->HasComposition());
+  EXPECT_TRUE(input_method_->cancel_composition_called());
+  EXPECT_TRUE(textfield_->key_received());
+  EXPECT_TRUE(textfield_->key_handled());
+  EXPECT_STR_EQ("0123321456789", textfield_->text());
+  EXPECT_EQ(8U, textfield_->GetCursorPosition());
+  EXPECT_EQ(1, on_before_user_action_);
+  EXPECT_EQ(1, 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_->SetPassword(true);
+  EXPECT_TRUE(input_method_->text_input_type_changed());
+  EXPECT_TRUE(textfield_->GetTextInputClient());
+}
+
+
 }  // namespace views