IME (input method editor) support for Aura, part 3 of 3: Use ui::InputMethod in ash.

ui/base/ime/mock_input_method.cc

 // Copyright (c) 2011 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/mock_input_method.h"
 
 #include "base/logging.h"
 #include "base/string16.h"
 #include "ui/base/events.h"
 #include "ui/base/glib/glib_integers.h"
@@ skipping 18 matching lines @@
       (flags & Mod1Mask ? ui::EF_ALT_DOWN : 0U);
 }
 #endif
 
 }  // namespace
 
 namespace ui {
 
 MockInputMethod::MockInputMethod(internal::InputMethodDelegate* delegate)
     : delegate_(NULL),
-      text_input_client_(NULL),
-      consume_next_key_(false) {
+      text_input_client_(NULL) {
   SetDelegate(delegate);
 }
 
 MockInputMethod::~MockInputMethod() {
 }
 
 void MockInputMethod::SetDelegate(internal::InputMethodDelegate* delegate) {
   delegate_ = delegate;
 }
 
 void MockInputMethod::SetFocusedTextInputClient(TextInputClient* client) {
   text_input_client_ = client;
 }
 
 TextInputClient* MockInputMethod::GetTextInputClient() const {
   return text_input_client_;
 }
 
 void MockInputMethod::DispatchKeyEvent(const base::NativeEvent& native_event) {
-#if defined(USE_X11)
+#if defined(OS_WIN)
+  if (native_event.message == WM_CHAR) {
+    if (text_input_client_) {
+      text_input_client_->InsertChar(ui::KeyboardCodeFromNative(native_event),
+                                     ui::EventFlagsFromNative(native_event));
+    }
+  } else {
+    delegate_->DispatchKeyEventPostIME(native_event);
+  }
+#elif defined(USE_X11)
   DCHECK(native_event);
   if (native_event->type == KeyRelease) {
     // On key release, just dispatch it.
     delegate_->DispatchKeyEventPostIME(native_event);
   } else {
     const uint32 state = EventFlagsFromXFlags(native_event->xkey.state);
-    if (consume_next_key_) {
-      // Send the VKEY_PROCESSKEY RawKeyDown event.
-      SendFakeProcessKeyEvent(true, state);
-    } else {
-      // Send a RawKeyDown event first,
-      delegate_->DispatchKeyEventPostIME(native_event);
-      if (text_input_client_) {
-        // then send a Char event via ui::TextInputClient.
-        const KeyboardCode key_code = ui::KeyboardCodeFromNative(native_event);
-        uint16 ch = 0;
-        if (!(state & ui::EF_CONTROL_DOWN))
-          ch = ui::GetCharacterFromXEvent(native_event);
-        if (!ch)
-          ch = ui::GetCharacterFromKeyCode(key_code, state);
-        if (ch)
-          text_input_client_->InsertChar(ch, state);
-      }
+    // Send a RawKeyDown event first,
+    delegate_->DispatchKeyEventPostIME(native_event);
+    if (text_input_client_) {
+      // then send a Char event via ui::TextInputClient.
+      const KeyboardCode key_code = ui::KeyboardCodeFromNative(native_event);
+      uint16 ch = 0;
+      if (!(state & ui::EF_CONTROL_DOWN))
+        ch = ui::GetCharacterFromXEvent(native_event);
+      if (!ch)
+        ch = ui::GetCharacterFromKeyCode(key_code, state);
+      if (ch)
+        text_input_client_->InsertChar(ch, state);
     }
   }
-  consume_next_key_ = false;
 #else
-  // TODO(yusukes): Support Windows.
+  // TODO(yusukes): Support other platforms. Call InsertChar() when necessary.
   delegate_->DispatchKeyEventPostIME(native_event);
 #endif
 }
 
 void MockInputMethod::Init(bool focused) {}
 void MockInputMethod::OnFocus() {}
 void MockInputMethod::OnBlur() {}
 void MockInputMethod::OnTextInputTypeChanged(const TextInputClient* client) {}
 void MockInputMethod::OnCaretBoundsChanged(const TextInputClient* client) {}
 void MockInputMethod::CancelComposition(const TextInputClient* client) {}
 
 std::string MockInputMethod::GetInputLocale() {
   return "";
 }
 
 base::i18n::TextDirection MockInputMethod::GetInputTextDirection() {
   return base::i18n::UNKNOWN_DIRECTION;
 }
 
 bool MockInputMethod::IsActive() {
   return true;
 }
 
 ui::TextInputType MockInputMethod::GetTextInputType() const {
   return ui::TEXT_INPUT_TYPE_NONE;
 }
 
-void MockInputMethod::ConsumeNextKey() {
-  consume_next_key_ = true;
-}
-
-void MockInputMethod::SendFakeProcessKeyEvent(bool pressed, int flags) const {
-  delegate_->DispatchFabricatedKeyEventPostIME(
-      pressed ? ET_KEY_PRESSED : ET_KEY_RELEASED, VKEY_PROCESSKEY, flags);
-}
-
 }  // namespace ui