Refactoring for the InputMethod & InputMethodDelegate interfaces.

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 55 matching lines @@
 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 DispatchKeyEvent(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 IsCandidatePopupOpen() const override;
   void ShowImeIfNeeded() override {}
 
   bool untranslated_ime_message_called() const {
     return untranslated_ime_message_called_;
@@ skipping 47 matching lines @@
 MockInputMethod::~MockInputMethod() {
 }
 
 bool MockInputMethod::OnUntranslatedIMEMessage(const base::NativeEvent& event,
                                                NativeEventResult* result) {
   if (result)
     *result = NativeEventResult();
   return false;
 }
 
-bool MockInputMethod::DispatchKeyEvent(const ui::KeyEvent& key) {
+void MockInputMethod::DispatchKeyEvent(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;
+  if (key->is_char() && key->HasNativeEvent())
+    return;
 
   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);
+    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();
+    } else if (key->type() == ui::ET_KEY_PRESSED) {
+      base::char16 ch = key->GetCharacter();
       if (ch)
-        client->InsertChar(ch, key.flags());
+        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) {
@@ skipping 288 matching lines @@
 
 #if defined(OS_MACOSX) && !defined(USE_AURA)
     // The Mac EventGenerator hooks in before IME. It sends events first to an
     // NSResponder, which is necessary to interpret keyboard events into
     // appropriate editing commands.
     event_generator_->PressKey(key_code, flags);
 #else
     // TODO(shuchen): making EventGenerator support input method and using
     // EventGenerator here. crbug.com/512315.
     ui::KeyEvent event(ui::ET_KEY_PRESSED, key_code, flags);
-    input_method_->DispatchKeyEvent(event);
+    input_method_->DispatchKeyEvent(&event);
 #endif
   }
 
   void SendKeyEvent(ui::KeyboardCode key_code,
                     bool shift,
                     bool control_or_command) {
     SendKeyEvent(key_code, false, shift, control_or_command, false);
   }
 
   void SendKeyEvent(ui::KeyboardCode key_code) {
     SendKeyEvent(key_code, false, false);
   }
 
   void SendKeyEvent(base::char16 ch) {
     if (ch < 0x80) {
       ui::KeyboardCode code =
           ch == ' ' ? ui::VKEY_SPACE :
           static_cast<ui::KeyboardCode>(ui::VKEY_A + ch - 'a');
       SendKeyEvent(code);
     } else {
       // For unicode characters, assume they come from IME rather than the
       // keyboard. So they are dispatched directly to the input method.
       ui::KeyEvent event(ch, ui::VKEY_UNKNOWN, ui::EF_NONE);
-      input_method_->DispatchKeyEvent(event);
+      input_method_->DispatchKeyEvent(&event);
     }
   }
 
   // Sends a platform-specific move (and select) to start of line.
   void SendHomeEvent(bool shift) {
     if (TestingNativeMac()) {
       // Use Cmd+Left on native Mac. An RTL-agnostic "end" doesn't have a
       // default key-binding on Mac.
       SendKeyEvent(ui::VKEY_LEFT, shift /* shift */, true /* command */);
       return;
@@ skipping 2028 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