Implement input.ime.sendKeyEvents API.

ui/base/ime/input_method_win.cc

 // Copyright (c) 2012 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_win.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include "base/auto_reset.h"
@@ skipping 82 matching lines @@
     default:
       NOTREACHED() << "Unknown IME message:" << event.message;
       break;
   }
   if (result)
     *result = original_result;
   return !!handled;
 }
 
 void InputMethodWin::DispatchKeyEvent(ui::KeyEvent* event) {
-  if (!event->HasNativeEvent()) {
-    DispatchFabricatedKeyEvent(event);
-    return;
-  }
+  std::vector<MSG> char_msgs;
+  if (event->HasNativeEvent()) {
+    const base::NativeEvent& native_key_event = event->native_event();
+    BOOL handled = FALSE;
+    if (native_key_event.message == WM_CHAR) {
+      OnChar(native_key_event.hwnd, native_key_event.message,
+             native_key_event.wParam, native_key_event.lParam, native_key_event,
+             &handled);
+      if (handled)
+        event->StopPropagation();
+      return;
+    }
 
-  const base::NativeEvent& native_key_event = event->native_event();
-  BOOL handled = FALSE;
-  if (native_key_event.message == WM_CHAR) {
-    OnChar(native_key_event.hwnd, native_key_event.message,
-           native_key_event.wParam, native_key_event.lParam, native_key_event,
-           &handled);
-    if (handled)
-      event->StopPropagation();
-    return;
-  }
+    if (!base::CommandLine::ForCurrentProcess()->HasSwitch(
+            switches::kDisableMergeKeyCharEvents)) {
+      // Combines the WM_KEY* and WM_CHAR messages in the event processing flow
+      // which is necessary to let Chrome IME extension to process the key event
+      // and perform corresponding IME actions.
+      // Chrome IME extension may wants to consume certain key events based on
+      // the character information of WM_CHAR messages. Holding WM_KEY* messages
+      // until WM_CHAR is processed by the IME extension is not feasible because
+      // there is no way to know wether there will or not be a WM_CHAR following
+      // the WM_KEY*.
+      // Chrome never handles dead chars so it is safe to remove/ignore
+      // WM_*DEADCHAR messages.
+      MSG msg;
+      while (::PeekMessage(&msg, native_key_event.hwnd, WM_CHAR, WM_DEADCHAR,
+                           PM_REMOVE)) {
+        if (msg.message == WM_CHAR)
+          char_msgs.push_back(msg);
+      }
+      while (::PeekMessage(&msg, native_key_event.hwnd, WM_SYSCHAR,
+                           WM_SYSDEADCHAR, PM_REMOVE)) {
+        if (msg.message == WM_SYSCHAR)
+          char_msgs.push_back(msg);
+      }
+    }
 
-  std::vector<MSG> char_msgs;
-  if (!base::CommandLine::ForCurrentProcess()->HasSwitch(
-      switches::kDisableMergeKeyCharEvents)) {
-    // Combines the WM_KEY* and WM_CHAR messages in the event processing flow
-    // which is necessary to let Chrome IME extension to process the key event
-    // and perform corresponding IME actions.
-    // Chrome IME extension may wants to consume certain key events based on
-    // the character information of WM_CHAR messages. Holding WM_KEY* messages
-    // until WM_CHAR is processed by the IME extension is not feasible because
-    // there is no way to know wether there will or not be a WM_CHAR following
-    // the WM_KEY*.
-    // Chrome never handles dead chars so it is safe to remove/ignore
-    // WM_*DEADCHAR messages.
-    MSG msg;
-    while (::PeekMessage(&msg, native_key_event.hwnd, WM_CHAR, WM_DEADCHAR,
-                         PM_REMOVE)) {
-      if (msg.message == WM_CHAR)
-        char_msgs.push_back(msg);
-    }
-    while (::PeekMessage(&msg, native_key_event.hwnd, WM_SYSCHAR,
-                         WM_SYSDEADCHAR, PM_REMOVE)) {
-      if (msg.message == WM_SYSCHAR)
-        char_msgs.push_back(msg);
+    // Handles ctrl-shift key to change text direction and layout alignment.
+    if (ui::IMM32Manager::IsRTLKeyboardLayoutInstalled() &&
+        !IsTextInputTypeNone()) {
+      // TODO: shouldn't need to generate a KeyEvent here.
+      const ui::KeyEvent key(native_key_event);
+      ui::KeyboardCode code = key.key_code();
+      if (key.type() == ui::ET_KEY_PRESSED) {
+        if (code == ui::VKEY_SHIFT) {
+          base::i18n::TextDirection dir;
+          if (ui::IMM32Manager::IsCtrlShiftPressed(&dir))
+            pending_requested_direction_ = dir;
+        } else if (code != ui::VKEY_CONTROL) {
+          pending_requested_direction_ = base::i18n::UNKNOWN_DIRECTION;
+        }
+      } else if (key.type() == ui::ET_KEY_RELEASED &&
+                 (code == ui::VKEY_SHIFT || code == ui::VKEY_CONTROL) &&
+                 pending_requested_direction_ !=
+                     base::i18n::UNKNOWN_DIRECTION) {
+        GetTextInputClient()->ChangeTextDirectionAndLayoutAlignment(
+            pending_requested_direction_);
+        pending_requested_direction_ = base::i18n::UNKNOWN_DIRECTION;
+      }
     }
   }
 
-  // Handles ctrl-shift key to change text direction and layout alignment.
-  if (ui::IMM32Manager::IsRTLKeyboardLayoutInstalled() &&
-      !IsTextInputTypeNone()) {
-    // TODO: shouldn't need to generate a KeyEvent here.
-    const ui::KeyEvent key(native_key_event);
-    ui::KeyboardCode code = key.key_code();
-    if (key.type() == ui::ET_KEY_PRESSED) {
-      if (code == ui::VKEY_SHIFT) {
-        base::i18n::TextDirection dir;
-        if (ui::IMM32Manager::IsCtrlShiftPressed(&dir))
-          pending_requested_direction_ = dir;
-      } else if (code != ui::VKEY_CONTROL) {
-        pending_requested_direction_ = base::i18n::UNKNOWN_DIRECTION;
-      }
-    } else if (key.type() == ui::ET_KEY_RELEASED &&
-               (code == ui::VKEY_SHIFT || code == ui::VKEY_CONTROL) &&
-               pending_requested_direction_ != base::i18n::UNKNOWN_DIRECTION) {
-      GetTextInputClient()->ChangeTextDirectionAndLayoutAlignment(
-          pending_requested_direction_);
-      pending_requested_direction_ = base::i18n::UNKNOWN_DIRECTION;
-    }
-  }
-
   // If only 1 WM_CHAR per the key event, set it as the character of it.
   if (char_msgs.size() == 1)
     event->set_character(static_cast<base::char16>(char_msgs[0].wParam));
 
   // Dispatches the key events to the Chrome IME extension which is listening to
   // key events on the following two situations:
   // 1) |char_msgs| is empty when the event is non-character key.
   // 2) |char_msgs|.size() == 1 when the event is character key and the WM_CHAR
   // messages have been combined in the event processing flow.
   if (!base::CommandLine::ForCurrentProcess()->HasSwitch(
@@ skipping 16 matching lines @@
   DCHECK(event);
   if (is_handled)
     return;
 
   ui::EventDispatchDetails details = DispatchKeyEventPostIME(event);
   if (details.dispatcher_destroyed || details.target_destroyed ||
       event->stopped_propagation()) {
     return;
   }
 
+  if (char_msgs->empty() &&

[Shu Chen, 2016/03/09 05:50:50]

Replaces the condition char_msgs->empty() with event->HasNativeEvent().

+      (event->is_char() || event->GetDomKey().IsCharacter()) &&
+      event->type() == ui::ET_KEY_PRESSED && GetTextInputClient()) {
+    // The key event if from calling input.ime.sendKeyEvent or test.
+    GetTextInputClient()->InsertChar(*event);
+    return;
+  }
+
   BOOL handled;
   for (const auto& msg : (*char_msgs))
     OnChar(msg.hwnd, msg.message, msg.wParam, msg.lParam, msg, &handled);
 }
 
 void InputMethodWin::OnTextInputTypeChanged(const TextInputClient* client) {
   if (!IsTextInputClientFocused(client) || !IsWindowFocused(client))
     return;
   imm32_manager_.CancelIME(toplevel_window_handle_);
   UpdateIMEState();
@@ skipping 397 matching lines @@
     return false;
   // When Aura is enabled, |attached_window_handle| should always be a top-level
   // window. So we can safely assume that |attached_window_handle| is ready for
   // receiving keyboard input as long as it is an active window. This works well
   // even when the |attached_window_handle| becomes active but has not received
   // WM_FOCUS yet.
   return toplevel_window_handle_ &&
       GetActiveWindow() == toplevel_window_handle_;
 }
 
-void InputMethodWin::DispatchFabricatedKeyEvent(ui::KeyEvent* event) {
-  if (event->is_char()) {
-    if (GetTextInputClient()) {
-      ui::KeyEvent ch_event(*event);
-      ch_event.set_character(static_cast<base::char16>(event->key_code()));
-      GetTextInputClient()->InsertChar(ch_event);
-      return;
-    }
-  }
-  ignore_result(DispatchKeyEventPostIME(event));
-}
-
 void InputMethodWin::ConfirmCompositionText() {
   if (composing_window_handle_)
     imm32_manager_.CleanupComposition(composing_window_handle_);
 
   // Though above line should confirm the client's composition text by sending a
   // result text to us, in case the input method and the client are in
   // inconsistent states, we check the client's composition state again.
   if (!IsTextInputTypeNone() && GetTextInputClient()->HasCompositionText()) {
     GetTextInputClient()->ConfirmCompositionText();
 
@@ skipping 36 matching lines @@
   ui::IMEEngineHandlerInterface* engine = GetEngine();
   if (engine) {
     if (old_text_input_type != ui::TEXT_INPUT_TYPE_NONE)
       engine->FocusOut();
     if (text_input_type != ui::TEXT_INPUT_TYPE_NONE)
       engine->FocusIn(context);
   }
 }
 
 }  // namespace ui