Combine the WM_CHAR with WM_KEY* for key event flow.

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 "base/auto_reset.h"
 #include "base/basictypes.h"
+#include "base/command_line.h"
 #include "base/profiler/scoped_tracker.h"
 #include "ui/base/ime/text_input_client.h"
 #include "ui/base/ime/win/tsf_input_scope.h"
+#include "ui/base/ui_base_switches.h"
 #include "ui/events/event.h"
 #include "ui/events/event_constants.h"
 #include "ui/events/event_utils.h"
 #include "ui/events/keycodes/keyboard_codes.h"
 #include "ui/gfx/win/dpi.h"
 #include "ui/gfx/win/hwnd_util.h"
 
 namespace ui {
 namespace {
 
 // Extra number of chars before and after selection (or composition) range which
 // is returned to IME for improving conversion accuracy.
 static const size_t kExtraNumberOfChars = 20;
 
 }  // namespace
 
 InputMethodWin::InputMethodWin(internal::InputMethodDelegate* delegate,
                                HWND toplevel_window_handle)
     : toplevel_window_handle_(toplevel_window_handle),
       pending_requested_direction_(base::i18n::UNKNOWN_DIRECTION),
       accept_carriage_return_(false),
       enabled_(false),
       is_candidate_popup_open_(false),
-      composing_window_handle_(NULL),
-      suppress_next_char_(false) {
+      composing_window_handle_(NULL) {
   SetDelegate(delegate);
 }
 
 void InputMethodWin::OnFocus() {
   InputMethodBase::OnFocus();
   if (GetTextInputClient())
     UpdateIMEState();
 }
 
 void InputMethodWin::OnBlur() {
@@ skipping 51 matching lines @@
   return !!handled;
 }
 
 void InputMethodWin::DispatchKeyEvent(ui::KeyEvent* event) {
   if (!event->HasNativeEvent()) {
     DispatchFabricatedKeyEvent(event);
     return;
   }
 
   const base::NativeEvent& native_key_event = event->native_event();
+  BOOL handled = FALSE;
   if (native_key_event.message == WM_CHAR) {
-    BOOL handled;
     OnChar(native_key_event.hwnd, native_key_event.message,
            native_key_event.wParam, native_key_event.lParam, &handled);
     if (handled)
       event->StopPropagation();
     return;
   }
+
+  std::vector<MSG> char_msgs;
+  if (base::CommandLine::ForCurrentProcess()->HasSwitch(
+      switches::kEnableMergeKeyCharEvents)) {
+    // 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;
     }
   }
 
+  // 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));

[ananta, 2015/09/22 19:27:30]

Is this code correct?. The wParams in WM_KEYDOWN and WM_CHAR messages are
different things I think. They are virtual key codes in keydown and character
codes in wm_char. 

Wondering if it would be better to disassemble the TranslateMessage function to
see which WM_KEYDOWN messages translate into WM_CHARs' and use the same logic in
the extension

[Shu Chen, 2015/09/23 05:21:09]

This code is correct. WM_CHAR's wParam carries the UTF16 code of the character.
This code makes sure the ui::KeyEvent carries the correct UTF16 code instead of
hard-coded one.
For the hard-coded point, please refer to
https://code.google.com/p/chromium/codesearch#chromium/src/ui/events/event.cc...
That has been discussed. TranslateMessage internally uses ToUnicode() or
ToUnicodeEx() to get the i18n character for the key code. It also maintains an
internal state machine to deal with dead keys.
Those logics cannot be copied into extension, and also the code of
InputMethodWin cannot use ToUnicodeEx() directly.

+
   ui::EventDispatchDetails details = DispatchKeyEventPostIME(event);
-  if (!details.dispatcher_destroyed)
-    suppress_next_char_ = event->stopped_propagation();
+  if (details.dispatcher_destroyed || details.target_destroyed ||
+      event->stopped_propagation()) {
+    return;
+  }
+
+  for (size_t i = 0; i < char_msgs.size(); ++i) {
+    MSG msg = char_msgs[i];
+    OnChar(msg.hwnd, msg.message, msg.wParam, msg.lParam, &handled);
+  }
 }
 
 void InputMethodWin::OnTextInputTypeChanged(const TextInputClient* client) {
   if (!IsTextInputClientFocused(client) || !IsWindowFocused(client))
     return;
   imm32_manager_.CancelIME(toplevel_window_handle_);
   UpdateIMEState();
 }
 
 void InputMethodWin::OnCaretBoundsChanged(const TextInputClient* client) {
@@ skipping 65 matching lines @@
                                UINT message,
                                WPARAM wparam,
                                LPARAM lparam,
                                BOOL* handled) {
   // TODO(vadimt): Remove ScopedTracker below once crbug.com/440919 is fixed.
   tracked_objects::ScopedTracker tracking_profile(
       FROM_HERE_WITH_EXPLICIT_FUNCTION("440919 InputMethodWin::OnChar"));
 
   *handled = TRUE;
 
-  if (suppress_next_char_) {
-    suppress_next_char_ = false;
-    return 0;
-  }
-
   // We need to send character events to the focused text input client event if
   // its text input type is ui::TEXT_INPUT_TYPE_NONE.
   if (GetTextInputClient()) {
     const base::char16 kCarriageReturn = L'\r';
     const base::char16 ch = static_cast<base::char16>(wparam);
     // A mask to determine the previous key state from |lparam|. The value is 1
     // if the key is down before the message is sent, or it is 0 if the key is
     // up.
     const uint32 kPrevKeyDownBit = 0x40000000;
     if (ch == kCarriageReturn && !(lparam & kPrevKeyDownBit))
@@ skipping 338 matching lines @@
   // 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 (suppress_next_char_) {
-      suppress_next_char_ = false;
-      return;
-    }
     if (GetTextInputClient()) {
       GetTextInputClient()->InsertChar(
           static_cast<base::char16>(event->key_code()),
           ui::GetModifiersFromKeyState());
       return;
     }
   }
   ignore_result(DispatchKeyEventPostIME(event));
 }
 
@@ skipping 27 matching lines @@
       enabled_ = true;
       break;
   }
 
   imm32_manager_.SetTextInputMode(window_handle, text_input_mode);
   tsf_inputscope::SetInputScopeForTsfUnawareWindow(
       window_handle, text_input_type, text_input_mode);
 }
 
 }  // namespace ui