Refactors ui::internal::InputMethodDelegate.

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
 #undef None
 
 #include <cstring>
 
 #include "base/i18n/char_iterator.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chromeos/ime/ibus_keymap.h"
 #include "chromeos/ime/ibus_text.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/base/ime/chromeos/ime_bridge.h"
 #include "ui/base/ime/chromeos/mock_ime_candidate_window_handler.h"
 #include "ui/base/ime/chromeos/mock_ime_engine_handler.h"
-#include "ui/base/ime/input_method_chromeos.h"
 #include "ui/base/ime/input_method_delegate.h"
 #include "ui/base/ime/text_input_client.h"
 #include "ui/events/event.h"
 #include "ui/events/test/events_test_utils_x11.h"
-#include "ui/gfx/rect.h"
+#include "ui/gfx/geometry/rect.h"
 
 using base::UTF8ToUTF16;
 using base::UTF16ToUTF8;
 
 namespace ui {
 namespace {
 typedef chromeos::IMEEngineHandlerInterface::KeyEventDoneCallback
     KeyEventCallback;
 
 uint32 GetOffsetInUTF16(const std::string& utf8_string, uint32 utf8_offset) {
@@ skipping 27 matching lines @@
       : InputMethodChromeOS(delegate),
         process_key_event_post_ime_call_count_(0) {
   }
 
   struct ProcessKeyEventPostIMEArgs {
     ProcessKeyEventPostIMEArgs() : event(NULL), handled(false) {}
     const ui::KeyEvent* event;
     bool handled;
   };
 
-  // InputMethodChromeOS override.
+  // Overridden from InputMethodChromeOS:
   virtual void ProcessKeyEventPostIME(const ui::KeyEvent& key_event,
                                       bool handled) OVERRIDE {
     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;
   }
@@ skipping 100 matching lines @@
 
  private:
   const std::string expected_surrounding_text_;
   const uint32 expected_cursor_position_;
   const uint32 expected_anchor_position_;
 
   DISALLOW_COPY_AND_ASSIGN(SetSurroundingTextVerifier);
 };
 
 class InputMethodChromeOSTest : public internal::InputMethodDelegate,
-                            public testing::Test,
-                            public TextInputClient {
+                                public testing::Test,
+                                public TextInputClient {
  public:
-  InputMethodChromeOSTest() {
+  InputMethodChromeOSTest()
+      : dispatched_key_event_(ui::ET_UNKNOWN, ui::VKEY_UNKNOWN, 0, false) {
     ResetFlags();
   }
 
   virtual ~InputMethodChromeOSTest() {
   }
 
-  // testing::Test overrides:
   virtual void SetUp() OVERRIDE {
     chromeos::IMEBridge::Initialize();
 
     mock_ime_engine_handler_.reset(
         new chromeos::MockIMEEngineHandler());
     chromeos::IMEBridge::Get()->SetCurrentEngineHandler(
         mock_ime_engine_handler_.get());
 
     mock_ime_candidate_window_handler_.reset(
         new chromeos::MockIMECandidateWindowHandler());
     chromeos::IMEBridge::Get()->SetCandidateWindowHandler(
         mock_ime_candidate_window_handler_.get());
 
     ime_.reset(new TestableInputMethodChromeOS(this));
     ime_->SetFocusedTextInputClient(this);
   }
 
   virtual void TearDown() OVERRIDE {
     if (ime_.get())
       ime_->SetFocusedTextInputClient(NULL);
     ime_.reset();
     chromeos::IMEBridge::Get()->SetCurrentEngineHandler(NULL);
     chromeos::IMEBridge::Get()->SetCandidateWindowHandler(NULL);
     mock_ime_engine_handler_.reset();
     mock_ime_candidate_window_handler_.reset();
     chromeos::IMEBridge::Shutdown();
   }
 
-  // ui::internal::InputMethodDelegate overrides:
-  virtual bool DispatchKeyEventPostIME(
-      const base::NativeEvent& native_key_event) OVERRIDE {
-    dispatched_native_event_ = native_key_event;
-    return false;
-  }
-  virtual bool DispatchFabricatedKeyEventPostIME(ui::EventType type,
-                                                 ui::KeyboardCode key_code,
-                                                 int flags) OVERRIDE {
-    dispatched_fabricated_event_type_ = type;
-    dispatched_fabricated_event_key_code_ = key_code;
-    dispatched_fabricated_event_flags_ = flags;
+  // Overridden from ui::internal::InputMethodDelegate:
+  virtual bool DispatchKeyEventPostIME(const ui::KeyEvent& event) OVERRIDE {
+    dispatched_key_event_ = event;
     return false;
   }
 
-  // ui::TextInputClient overrides:
+  // Overridden from ui::TextInputClient:
   virtual void SetCompositionText(
       const CompositionText& composition) OVERRIDE {
     composition_text_ = composition;
   }
   virtual void ConfirmCompositionText() OVERRIDE {
     confirmed_text_ = composition_text_;
     composition_text_.Clear();
   }
   virtual void ClearCompositionText() OVERRIDE {
     composition_text_.Clear();
@@ skipping 48 matching lines @@
                                 base::string16* text) const OVERRIDE {
     *text = surrounding_text_.substr(range.GetMin(), range.length());
     return true;
   }
   virtual void OnInputMethodChanged() OVERRIDE {
     ++on_input_method_changed_call_count_;
   }
   virtual bool ChangeTextDirectionAndLayoutAlignment(
       base::i18n::TextDirection direction) OVERRIDE { return false; }
   virtual void ExtendSelectionAndDelete(size_t before,
-                                        size_t after) OVERRIDE { }
-  virtual void EnsureCaretInRect(const gfx::Rect& rect) OVERRIDE { }
-  virtual void OnCandidateWindowShown() OVERRIDE { }
-  virtual void OnCandidateWindowUpdated() OVERRIDE { }
-  virtual void OnCandidateWindowHidden() OVERRIDE { }
+                                        size_t after) OVERRIDE {}
+  virtual void EnsureCaretInRect(const gfx::Rect& rect) OVERRIDE {}
+  virtual void OnCandidateWindowShown() OVERRIDE {}
+  virtual void OnCandidateWindowUpdated() OVERRIDE {}
+  virtual void OnCandidateWindowHidden() OVERRIDE {}
 
   bool HasNativeEvent() const {
-    base::NativeEvent empty;
-    std::memset(&empty, 0, sizeof(empty));
-    return !!std::memcmp(&dispatched_native_event_,
-                         &empty,
-                         sizeof(dispatched_native_event_));
+    return dispatched_key_event_.HasNativeEvent();
   }
 
   void ResetFlags() {
-    std::memset(&dispatched_native_event_, 0, sizeof(dispatched_native_event_));
-    DCHECK(!HasNativeEvent());
-    dispatched_fabricated_event_type_ = ET_UNKNOWN;
-    dispatched_fabricated_event_key_code_ = VKEY_UNKNOWN;
-    dispatched_fabricated_event_flags_ = 0;
+    dispatched_key_event_ = ui::KeyEvent(ui::ET_UNKNOWN, ui::VKEY_UNKNOWN, 0,
+                                         false);
 
     composition_text_.Clear();
     confirmed_text_.Clear();
     inserted_text_.clear();
     inserted_char_ = 0;
     inserted_char_flags_ = 0;
     on_input_method_changed_call_count_ = 0;
 
     input_type_ = TEXT_INPUT_TYPE_NONE;
     input_mode_ = TEXT_INPUT_MODE_DEFAULT;
     can_compose_inline_ = true;
     caret_bounds_ = gfx::Rect();
   }
 
   scoped_ptr<TestableInputMethodChromeOS> ime_;
 
-  // Variables for remembering the parameters that are passed to
-  // ui::internal::InputMethodDelegate functions.
-  base::NativeEvent dispatched_native_event_;
-  ui::EventType dispatched_fabricated_event_type_;
-  ui::KeyboardCode dispatched_fabricated_event_key_code_;
-  int dispatched_fabricated_event_flags_;
+  // Copy of the dispatched key event.
+  ui::KeyEvent dispatched_key_event_;
 
   // Variables for remembering the parameters that are passed to
   // ui::TextInputClient functions.
   CompositionText composition_text_;
   CompositionText confirmed_text_;
   base::string16 inserted_text_;
   base::char16 inserted_char_;
   unsigned int on_input_method_changed_call_count_;
   int inserted_char_flags_;
 
@@ skipping 646 matching lines @@
   ime_->ResetContext();
 
   // Do callback.
   mock_ime_engine_handler_->last_passed_callback().Run(true);
 
   EXPECT_EQ(0, ime_->process_key_event_post_ime_call_count());
 }
 // TODO(nona): Introduce ProcessKeyEventPostIME tests(crbug.com/156593).
 
 }  // namespace ui