Remove the 2-level input method system & InputMethodBridge.

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>
 
 #include "base/command_line.h"
 #include "base/pickle.h"
 #include "base/strings/string16.h"
 #include "base/strings/utf_string_conversions.h"
 #include "ui/accessibility/ax_view_state.h"
 #include "ui/base/clipboard/clipboard.h"
 #include "ui/base/clipboard/scoped_clipboard_writer.h"
 #include "ui/base/dragdrop/drag_drop_types.h"
+#include "ui/base/ime/input_method_base.h"
+#include "ui/base/ime/input_method_delegate.h"
+#include "ui/base/ime/input_method_factory.h"
 #include "ui/base/ime/text_input_client.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/ui_base_switches.h"
 #include "ui/base/ui_base_switches_util.h"
 #include "ui/events/event.h"
+#include "ui/events/event_processor.h"
 #include "ui/events/event_utils.h"
 #include "ui/events/keycodes/keyboard_codes.h"
 #include "ui/events/test/event_generator.h"
 #include "ui/gfx/render_text.h"
 #include "ui/strings/grit/ui_strings.h"
 #include "ui/views/controls/textfield/textfield_controller.h"
 #include "ui/views/controls/textfield/textfield_model.h"
 #include "ui/views/controls/textfield/textfield_test_api.h"
 #include "ui/views/focus/focus_manager.h"
-#include "ui/views/ime/mock_input_method.h"
 #include "ui/views/test/test_views_delegate.h"
 #include "ui/views/test/views_test_base.h"
 #include "ui/views/test/widget_test.h"
 #include "ui/views/widget/widget.h"
 #include "url/gurl.h"
 
 #if defined(OS_WIN)
 #include "base/win/windows_version.h"
 #endif
 
 #if defined(OS_LINUX) && !defined(OS_CHROMEOS)
 #include "ui/events/linux/text_edit_key_bindings_delegate_auralinux.h"
 #endif
 
 #if defined(USE_X11)
 #include "ui/events/event_utils.h"
 #endif
 
 using base::ASCIIToUTF16;
 using base::UTF8ToUTF16;
 using base::WideToUTF16;
 
 #define EXPECT_STR_EQ(ascii, utf16) EXPECT_EQ(ASCIIToUTF16(ascii), utf16)
 
 namespace {
 
 const base::char16 kHebrewLetterSamekh = 0x05E1;
 
+class MockInputMethod : public ui::InputMethodBase {
+ public:
+  MockInputMethod();
+  ~MockInputMethod() override;
+
+  // Overridden from InputMethod:
+  bool OnUntranslatedIMEMessage(const base::NativeEvent& event,
+                                NativeEventResult* result) override;
+  bool DispatchKeyEvent(const ui::KeyEvent& key) override;
+  void OnTextInputTypeChanged(const ui::TextInputClient* client) override;
+  void OnCaretBoundsChanged(const ui::TextInputClient* client) override {}
+  void CancelComposition(const ui::TextInputClient* client) override;
+  void OnInputLocaleChanged() override {}
+  std::string GetInputLocale() override;
+  bool IsActive() override;
+  bool IsCandidatePopupOpen() const override;
+  void ShowImeIfNeeded() override {}
+
+  bool untranslated_ime_message_called() const {
+    return untranslated_ime_message_called_;
+  }
+  bool text_input_type_changed() const { return text_input_type_changed_; }
+  bool cancel_composition_called() const { return cancel_composition_called_; }
+
+  // Clears all internal states and result.
+  void Clear();
+
+  void SetCompositionTextForNextKey(const ui::CompositionText& composition);
+  void SetResultTextForNextKey(const base::string16& result);
+
+ private:
+  // Overridden from InputMethodBase.
+  void OnWillChangeFocusedClient(ui::TextInputClient* focused_before,
+                                 ui::TextInputClient* focused) override;
+
+  // Clears boolean states defined below.
+  void ClearStates();
+
+  // Whether a mock composition or result is scheduled for the next key event.
+  bool HasComposition();
+
+  // Clears only composition information and result text.
+  void ClearComposition();
+
+  // Composition information for the next key event. It'll be cleared
+  // automatically after dispatching the next key event.
+  ui::CompositionText composition_;
+
+  // Result text for the next key event. It'll be cleared automatically after
+  // dispatching the next key event.
+  base::string16 result_text_;
+
+  // Record call state of corresponding methods. They will be set to false
+  // automatically before dispatching a key event.
+  bool untranslated_ime_message_called_;
+  bool text_input_type_changed_;
+  bool cancel_composition_called_;
+
+  DISALLOW_COPY_AND_ASSIGN(MockInputMethod);
+};
+
+MockInputMethod::MockInputMethod()
+    : untranslated_ime_message_called_(false),
+      text_input_type_changed_(false),
+      cancel_composition_called_(false) {
+}
+
+MockInputMethod::~MockInputMethod() {
+}
+
+bool MockInputMethod::OnUntranslatedIMEMessage(const base::NativeEvent& event,
+                                               NativeEventResult* result) {
+  if (result)
+    *result = NativeEventResult();
+  return false;
+}
+
+bool MockInputMethod::DispatchKeyEvent(const ui::KeyEvent& key) {
+  // Checks whether the key event is from EventGenerator on Windows which will
+  // generate key event for WM_CHAR.
+  // The MockInputMethod will insert char on WM_KEYDOWN so ignore WM_CHAR here.
+  if (key.is_char() && key.HasNativeEvent())
+    return true;
+
+  bool handled = !IsTextInputTypeNone() && HasComposition();
+  ClearStates();
+  if (handled) {
+    DCHECK(!key.is_char());
+    ui::KeyEvent mock_key(ui::ET_KEY_PRESSED, ui::VKEY_PROCESSKEY, key.flags());
+    DispatchKeyEventPostIME(mock_key);
+  } else {
+    DispatchKeyEventPostIME(key);
+  }
+
+  ui::TextInputClient* client = GetTextInputClient();
+  if (client) {
+    if (handled) {
+      if (result_text_.length())
+        client->InsertText(result_text_);
+      if (composition_.text.length())
+        client->SetCompositionText(composition_);
+      else
+        client->ClearCompositionText();
+    } else if (key.type() == ui::ET_KEY_PRESSED) {
+      base::char16 ch = key.GetCharacter();
+      if (ch)
+        client->InsertChar(ch, key.flags());
+    }
+  }
+
+  ClearComposition();
+  return true;
+}
+
+void MockInputMethod::OnTextInputTypeChanged(
+    const ui::TextInputClient* client) {
+  if (IsTextInputClientFocused(client))
+    text_input_type_changed_ = true;
+  InputMethodBase::OnTextInputTypeChanged(client);
+}
+
+void MockInputMethod::CancelComposition(const ui::TextInputClient* client) {
+  if (IsTextInputClientFocused(client)) {
+    cancel_composition_called_ = true;
+    ClearComposition();
+  }
+}
+
+std::string MockInputMethod::GetInputLocale() {
+  return "en-US";
+}
+
+bool MockInputMethod::IsActive() {
+  return true;
+}
+
+bool MockInputMethod::IsCandidatePopupOpen() const {
+  return false;
+}
+
+void MockInputMethod::OnWillChangeFocusedClient(
+    ui::TextInputClient* focused_before,
+    ui::TextInputClient* focused) {
+  ui::TextInputClient* client = GetTextInputClient();
+  if (client && client->HasCompositionText())
+    client->ConfirmCompositionText();
+  ClearComposition();
+}
+
+void MockInputMethod::Clear() {
+  ClearStates();
+  ClearComposition();
+}
+
+void MockInputMethod::SetCompositionTextForNextKey(
+    const ui::CompositionText& composition) {
+  composition_ = composition;
+}
+
+void MockInputMethod::SetResultTextForNextKey(const base::string16& result) {
+  result_text_ = result;
+}
+
+void MockInputMethod::ClearStates() {
+  untranslated_ime_message_called_ = false;
+  text_input_type_changed_ = false;
+  cancel_composition_called_ = false;
+}
+
+bool MockInputMethod::HasComposition() {
+  return composition_.text.length() || result_text_.length();
+}
+
+void MockInputMethod::ClearComposition() {
+  composition_.Clear();
+  result_text_.clear();
+}
+
 // A Textfield wrapper to intercept OnKey[Pressed|Released]() ressults.
 class TestTextfield : public views::Textfield {
  public:
   TestTextfield()
      : Textfield(),
        key_handled_(false),
        key_received_(false),
        weak_ptr_factory_(this) {}
 
   bool OnKeyPressed(const ui::KeyEvent& e) override {
@@ skipping 60 matching lines @@
   explicit TextfieldDestroyerController(views::Textfield* target)
       : target_(target) {
     target_->set_controller(this);
   }
 
   views::Textfield* target() { return target_.get(); }
 
   // views::TextfieldController:
   bool HandleKeyEvent(views::Textfield* sender,
                       const ui::KeyEvent& key_event) override {
+    target_->OnBlur();
     target_.reset();
     return false;
   }
 
  private:
   scoped_ptr<views::Textfield> target_;
 };
 
 base::string16 GetClipboardText(ui::ClipboardType type) {
   base::string16 text;
@@ skipping 12 matching lines @@
 class TextfieldTest : public ViewsTestBase, public TextfieldController {
  public:
   TextfieldTest()
       : widget_(NULL),
         textfield_(NULL),
         model_(NULL),
         input_method_(NULL),
         on_before_user_action_(0),
         on_after_user_action_(0),
         copied_to_clipboard_(ui::CLIPBOARD_TYPE_LAST) {
+    input_method_ = new MockInputMethod();
+    ui::SetUpInputMethodForTesting(input_method_);
   }
 
   // ::testing::Test:
   void TearDown() override {
     if (widget_)
       widget_->Close();
     ViewsTestBase::TearDown();
   }
 
   ui::ClipboardType GetAndResetCopiedToClipboard() {
@@ skipping 33 matching lines @@
     textfield_->set_controller(this);
     widget_ = new Widget();
 
     // The widget type must be an activatable type, and we don't want to worry
     // about the non-client view, which leaves just TYPE_WINDOW_FRAMELESS.
     Widget::InitParams params =
         CreateParams(Widget::InitParams::TYPE_WINDOW_FRAMELESS);
 
     params.bounds = gfx::Rect(100, 100, 100, 100);
     widget_->Init(params);
+    input_method_->SetDelegate(
+        test::WidgetTest::GetInputMethodDelegateForWidget(widget_));
     View* container = new View();
     widget_->SetContentsView(container);
     container->AddChildView(textfield_);
     textfield_->SetBoundsRect(params.bounds);
     textfield_->set_id(1);
     test_api_.reset(new TextfieldTestApi(textfield_));
 
     for (int i = 1; i < count; i++) {
       Textfield* textfield = new Textfield();
       container->AddChildView(textfield);
       textfield->set_id(i + 1);
     }
 
     model_ = test_api_->model();
     model_->ClearEditHistory();
 
-    input_method_ = new MockInputMethod();
-    widget_->ReplaceInputMethod(input_method_);
-
     // Since the window type is activatable, showing the widget will also
     // activate it. Calling Activate directly is insufficient, since that does
     // not also _focus_ an aura::Window (i.e. using the FocusClient). Both the
     // widget and the textfield must have focus to properly handle input.
     widget_->Show();
     textfield_->RequestFocus();
 
     // On Mac, activation is asynchronous since desktop widgets are used. We
     // don't want parallel tests to steal active status either, so fake it.
 #if defined(OS_MACOSX) && !defined(USE_AURA)
@@ skipping 1020 matching lines @@
   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();
-  ui::TextInputClient* client = textfield_->GetTextInputClient();
+  ui::TextInputClient* client = textfield_;
   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());
 
   EXPECT_TRUE(client->SetSelectionRange(gfx::Range(1, 4)));
@@ skipping 76 matching lines @@
   textfield_->clear();
   textfield_->ClearSelection();
   textfield_->SelectAll(false);
   EXPECT_EQ(0, on_before_user_action_);
   EXPECT_EQ(0, on_after_user_action_);
 
   input_method_->Clear();
 
   // Changing the Textfield to readonly shouldn't change the input client, since
   // it's still required for selections and clipboard copy.
-  ui::TextInputClient* text_input_client = textfield_->GetTextInputClient();
+  ui::TextInputClient* text_input_client = textfield_;
   EXPECT_TRUE(text_input_client);
   EXPECT_NE(ui::TEXT_INPUT_TYPE_NONE, text_input_client->GetTextInputType());
   textfield_->SetReadOnly(true);
   EXPECT_TRUE(input_method_->text_input_type_changed());
-  EXPECT_EQ(text_input_client, textfield_->GetTextInputClient());
   EXPECT_EQ(ui::TEXT_INPUT_TYPE_NONE, text_input_client->GetTextInputType());
 
   input_method_->Clear();
   textfield_->SetReadOnly(false);
   EXPECT_TRUE(input_method_->text_input_type_changed());
-  EXPECT_EQ(text_input_client, textfield_->GetTextInputClient());
   EXPECT_NE(ui::TEXT_INPUT_TYPE_NONE, text_input_client->GetTextInputType());
 
   input_method_->Clear();
   textfield_->SetTextInputType(ui::TEXT_INPUT_TYPE_PASSWORD);
   EXPECT_TRUE(input_method_->text_input_type_changed());
-  EXPECT_TRUE(textfield_->GetTextInputClient());
 }
 
 TEST_F(TextfieldTest, UndoRedoTest) {
   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());
@@ skipping 490 matching lines @@
 
   // Reset locale.
   base::i18n::SetICUDefaultLocale(locale);
 }
 
 TEST_F(TextfieldTest, GetCompositionCharacterBoundsTest) {
   InitTextfield();
   ui::CompositionText composition;
   composition.text = UTF8ToUTF16("abc123");
   const uint32 char_count = static_cast<uint32>(composition.text.length());
-  ui::TextInputClient* client = textfield_->GetTextInputClient();
+  ui::TextInputClient* client = textfield_;
 
   // Compare the composition character bounds with surrounding cursor bounds.
   for (uint32 i = 0; i < char_count; ++i) {
     composition.selection = gfx::Range(i);
     client->SetCompositionText(composition);
     gfx::Point cursor_origin = GetCursorBounds().origin();
     views::View::ConvertPointToScreen(textfield_, &cursor_origin);
 
     composition.selection = gfx::Range(i + 1);
     client->SetCompositionText(composition);
@@ skipping 25 matching lines @@
     0x5642, 0xDB40, 0xDD00,
     // U+260E (BLACK TELEPHONE) as Emoji Variation Sequences
     0x260E, 0xFE0F,
     // U+0020 SPACE
     0x0020,
   };
   const size_t kUtf16CharsCount = arraysize(kUtf16Chars);
 
   ui::CompositionText composition;
   composition.text.assign(kUtf16Chars, kUtf16Chars + kUtf16CharsCount);
-  ui::TextInputClient* client = textfield_->GetTextInputClient();
+  ui::TextInputClient* client = textfield_;
   client->SetCompositionText(composition);
 
   // Make sure GetCompositionCharacterBounds never fails for index.
   gfx::Rect rects[kUtf16CharsCount];
   gfx::Rect prev_cursor = GetCursorBounds();
   for (uint32 i = 0; i < kUtf16CharsCount; ++i)
     EXPECT_TRUE(client->GetCompositionCharacterBounds(i, &rects[i]));
 
   // Here we might expect the following results but it actually depends on how
   // Uniscribe or HarfBuzz treats them with given font.
@@ skipping 390 matching lines @@
 
   textfield_->SetTextInputType(ui::TEXT_INPUT_TYPE_PASSWORD);
   ui::AXViewState state_protected;
   textfield_->GetAccessibleState(&state_protected);
   EXPECT_EQ(ui::AX_ROLE_TEXT_FIELD, state_protected.role);
   EXPECT_EQ(ASCIIToUTF16("********"), state_protected.value);
   EXPECT_TRUE(state_protected.HasStateFlag(ui::AX_STATE_PROTECTED));
 }
 
 }  // namespace views