Refactoring for the InputMethod & InputMethodDelegate interfaces.

ui/base/ime/input_method_chromeos_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/base/ime/input_method_chromeos.h"
 
 #include <X11/Xlib.h>
 #undef Bool
 #undef FocusIn
 #undef FocusOut
@@ skipping 55 matching lines @@
         process_key_event_post_ime_call_count_(0) {
   }
 
   struct ProcessKeyEventPostIMEArgs {
     ProcessKeyEventPostIMEArgs() : event(NULL), handled(false) {}
     const ui::KeyEvent* event;
     bool handled;
   };
 
   // Overridden from InputMethodChromeOS:
-  void ProcessKeyEventPostIME(const ui::KeyEvent& key_event,
+  void ProcessKeyEventPostIME(ui::KeyEvent* key_event,
                               bool handled) override {
     InputMethodChromeOS::ProcessKeyEventPostIME(key_event, handled);
-    process_key_event_post_ime_args_.event = &key_event;
+    process_key_event_post_ime_args_.event = key_event;
     process_key_event_post_ime_args_.handled = handled;
     ++process_key_event_post_ime_call_count_;
   }
 
   void ResetCallCount() {
     process_key_event_post_ime_call_count_ = 0;
   }
 
   const ProcessKeyEventPostIMEArgs& process_key_event_post_ime_args() const {
     return process_key_event_post_ime_args_;
@@ skipping 139 matching lines @@
     chromeos::IMEBridge::Get()->SetCurrentEngineHandler(NULL);
     chromeos::IMEBridge::Get()->SetCandidateWindowHandler(NULL);
     mock_ime_engine_handler_.reset();
     mock_ime_candidate_window_handler_.reset();
     chromeos::IMEBridge::Shutdown();
 
     ResetFlags();
   }
 
   // Overridden from ui::internal::InputMethodDelegate:
-  bool DispatchKeyEventPostIME(const ui::KeyEvent& event) override {
-    dispatched_key_event_ = event;
-    return stop_propagation_post_ime_;
+  ui::EventDispatchDetails DispatchKeyEventPostIME(
+      ui::KeyEvent* event) override {
+    dispatched_key_event_ = *event;
+    if (stop_propagation_post_ime_)
+      event->StopPropagation();
+    return ui::EventDispatchDetails();
   }
 
   // Overridden from ui::TextInputClient:
   void SetCompositionText(const CompositionText& composition) override {
     composition_text_ = composition;
   }
   void ConfirmCompositionText() override {
     confirmed_text_ = composition_text_;
     composition_text_.Clear();
   }
@@ skipping 624 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(InputMethodChromeOSKeyEventTest);
 };
 
 TEST_F(InputMethodChromeOSKeyEventTest, KeyEventDelayResponseTest) {
   const int kFlags = ui::EF_SHIFT_DOWN;
   ui::KeyEvent event(ui::ET_KEY_PRESSED, ui::VKEY_A, kFlags);
 
   // Do key event.
   input_type_ = TEXT_INPUT_TYPE_TEXT;
   ime_->OnTextInputTypeChanged(this);
-  ime_->DispatchKeyEvent(event);
+  ime_->DispatchKeyEvent(&event);
 
   // Check before state.
   const ui::KeyEvent* key_event =
       mock_ime_engine_handler_->last_processed_key_event();
   EXPECT_EQ(1, mock_ime_engine_handler_->process_key_event_call_count());
   EXPECT_EQ(ui::VKEY_A, key_event->key_code());
   EXPECT_EQ(kFlags, key_event->flags());
   EXPECT_EQ(0, ime_->process_key_event_post_ime_call_count());
 
   (static_cast<chromeos::IMEInputContextHandlerInterface*>(ime_.get()))
@@ skipping 17 matching lines @@
 
 TEST_F(InputMethodChromeOSKeyEventTest, MultiKeyEventDelayResponseTest) {
   // Preparation
   input_type_ = TEXT_INPUT_TYPE_TEXT;
   ime_->OnTextInputTypeChanged(this);
 
   const int kFlags = ui::EF_SHIFT_DOWN;
   ui::KeyEvent event(ui::ET_KEY_PRESSED, ui::VKEY_B, kFlags);
 
   // Do key event.
-  ime_->DispatchKeyEvent(event);
+  ime_->DispatchKeyEvent(&event);
   const ui::KeyEvent* key_event =
       mock_ime_engine_handler_->last_processed_key_event();
   EXPECT_EQ(ui::VKEY_B, key_event->key_code());
   EXPECT_EQ(kFlags, key_event->flags());
 
   KeyEventCallback first_callback =
       mock_ime_engine_handler_->last_passed_callback();
 
   // Do key event again.
   ui::KeyEvent event2(ui::ET_KEY_PRESSED, ui::VKEY_C, kFlags);
 
-  ime_->DispatchKeyEvent(event2);
+  ime_->DispatchKeyEvent(&event2);
   const ui::KeyEvent* key_event2 =
       mock_ime_engine_handler_->last_processed_key_event();
   EXPECT_EQ(ui::VKEY_C, key_event2->key_code());
   EXPECT_EQ(kFlags, key_event2->flags());
 
   // Check before state.
   EXPECT_EQ(2,
             mock_ime_engine_handler_->process_key_event_call_count());
   EXPECT_EQ(0, ime_->process_key_event_post_ime_call_count());
 
@@ skipping 33 matching lines @@
 
 TEST_F(InputMethodChromeOSKeyEventTest, StopPropagationTest) {
   // Preparation
   input_type_ = TEXT_INPUT_TYPE_TEXT;
   ime_->OnTextInputTypeChanged(this);
 
   // Do key event with event being stopped propagation.
   stop_propagation_post_ime_ = true;
   ui::KeyEvent eventA(ui::ET_KEY_PRESSED, ui::VKEY_A, EF_NONE);
   eventA.set_character(L'A');
-  ime_->DispatchKeyEvent(eventA);
+  ime_->DispatchKeyEvent(&eventA);
   mock_ime_engine_handler_->last_passed_callback().Run(false);
 
   const ui::KeyEvent* key_event =
       mock_ime_engine_handler_->last_processed_key_event();
   EXPECT_EQ(ui::VKEY_A, key_event->key_code());
   EXPECT_EQ(0, inserted_char_);
 
   // Do key event with event not being stopped propagation.
   stop_propagation_post_ime_ = false;
-  ime_->DispatchKeyEvent(eventA);
+  ime_->DispatchKeyEvent(&eventA);
   mock_ime_engine_handler_->last_passed_callback().Run(false);
 
   key_event = mock_ime_engine_handler_->last_processed_key_event();
   EXPECT_EQ(ui::VKEY_A, key_event->key_code());
   EXPECT_EQ(L'A', inserted_char_);
 }
 
 }  // namespace ui