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 "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));
+
   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 61 matching lines @@
     accept_carriage_return_ = false;
 }
 
 LRESULT InputMethodWin::OnChar(HWND window_handle,
                                UINT message,
                                WPARAM wparam,
                                LPARAM lparam,
                                BOOL* handled) {
   *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 310 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