Workaround a nasty ibus issue.

chrome/browser/renderer_host/gtk_im_context_wrapper.cc

 // Copyright (c) 2010 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 "chrome/browser/renderer_host/gtk_im_context_wrapper.h"
 
 #include <gdk/gdk.h>
 #include <gdk/gdkkeysyms.h>
 #include <gtk/gtk.h>
 #include <algorithm>
@@ skipping 37 matching lines @@
     : host_view_(host_view),
       context_(gtk_im_multicontext_new()),
       context_simple_(gtk_im_context_simple_new()),
       is_focused_(false),
       is_composing_text_(false),
       is_enabled_(false),
       is_in_key_event_handler_(false),
       preedit_selection_start_(0),
       preedit_selection_end_(0),
       is_preedit_changed_(false),
-      suppress_next_commit_(false) {
+      suppress_next_commit_(false),
+      last_key_code_(0),
+      last_key_was_up_(false),
+      last_key_filtered_no_result_(false) {
   DCHECK(context_);
   DCHECK(context_simple_);
 
   // context_ and context_simple_ share the same callback handlers.
   // All data come from them are treated equally.
   // context_ is for full input method support.
   // context_simple_ is for supporting dead/compose keys when input method is
   // disabled by webkit, eg. in password input box.
   g_signal_connect(context_, "preedit_start",
                    G_CALLBACK(HandlePreeditStartThunk), this);
@@ skipping 82 matching lines @@
 
   // Reset this flag here, as it's only used in input method callbacks.
   is_in_key_event_handler_ = false;
 
   NativeWebKeyboardEvent wke(event);
 
   // If the key event was handled by the input method, then we need to prevent
   // RenderView::UnhandledKeyboardEvent() from processing it.
   // Otherwise unexpected result may occur. For example if it's a
   // Backspace key event, the browser may go back to previous page.
-  if (filtered)
+  // We just send all keyup events to the browser to avoid breaking the
+  // browser's MENU key function, which is actually the only keyup event
+  // handled in the browser.
+  if (filtered && event->type == GDK_KEY_PRESS)
     wke.skip_in_browser = true;
 
+  const int key_code = wke.windowsKeyCode;
+  const bool has_result = HasInputMethodResult();
+
   // Send filtered keydown event before sending IME result.
-  if (event->type == GDK_KEY_PRESS && filtered)
+  // In order to workaround http://crosbug.com/6582, we only send a filtered
+  // keydown event if it generated any input method result.
+  if (event->type == GDK_KEY_PRESS && filtered && has_result)
     ProcessFilteredKeyPressEvent(&wke);
 
   // Send IME results. In most cases, it's only available if the key event
   // is filtered by IME. But in rare cases, an unfiltered key event may also
   // generate IME results.
   // Any IME results generated by a unfiltered key down event must be sent
   // before the key down event, to avoid some tricky issues. For example,
   // when using latin-post input method, pressing 'a' then Backspace, may
   // generate following events in sequence:
   //  1. keydown 'a' (filtered)
   //  2. preedit changed to "a"
   //  3. keyup 'a' (unfiltered)
   //  4. keydown Backspace (unfiltered)
   //  5. commit "a"
   //  6. preedit end
   //  7. keyup Backspace (unfiltered)
   //
   // In this case, the input box will be in a strange state if keydown
   // Backspace is sent to webkit before commit "a" and preedit end.
-  ProcessInputMethodResult(event, filtered);
+  if (has_result)
+    ProcessInputMethodResult(event, filtered);
 
   // Send unfiltered keydown and keyup events after sending IME result.
-  if (event->type == GDK_KEY_PRESS && !filtered)
+  if (event->type == GDK_KEY_PRESS && !filtered) {
     ProcessUnfilteredKeyPressEvent(&wke);
-  else if (event->type == GDK_KEY_RELEASE)
-    host_view_->ForwardKeyboardEvent(wke);
+  } else if (event->type == GDK_KEY_RELEASE) {
+    // In order to workaround http://crosbug.com/6582, we need to suppress
+    // the keyup event if corresponding keydown event was suppressed, or
+    // the last key event was a keyup event with the same keycode.
+    const bool suppress = (last_key_code_ == key_code) &&
+        (last_key_was_up_ || last_key_filtered_no_result_);
+
+    if (!suppress)
+      host_view_->ForwardKeyboardEvent(wke);
+  }
+
+  last_key_code_ = key_code;
+  last_key_was_up_ = (event->type == GDK_KEY_RELEASE);
+  last_key_filtered_no_result_ = (filtered && !has_result);
 }
 
 void GtkIMContextWrapper::UpdateInputMethodState(WebKit::WebTextInputType type,
                                                  const gfx::Rect& caret_rect) {
   suppress_next_commit_ = false;
 
   // The renderer has updated its IME status.
   // Control the GtkIMContext object according to this status.
   if (!context_ || !is_focused_)
     return;
@@ skipping 20 matching lines @@
 }
 
 void GtkIMContextWrapper::OnFocusIn() {
   if (is_focused_)
     return;
 
   // Tracks the focused state so that we can give focus to the
   // GtkIMContext object correctly later when IME is enabled by WebKit.
   is_focused_ = true;
 
+  last_key_code_ = 0;
+  last_key_was_up_ = false;
+  last_key_filtered_no_result_ = false;
+
   // Notify the GtkIMContext object of this focus-in event only if IME is
   // enabled by WebKit.
   if (is_enabled_)
     gtk_im_context_focus_in(context_);
 
   // context_simple_ is always enabled.
   // Actually it doesn't care focus state at all.
   gtk_im_context_focus_in(context_simple_);
 
   // Enables RenderWidget's IME related events, so that we can be notified
@@ skipping 73 matching lines @@
   }
 
   is_composing_text_ = false;
   preedit_text_.clear();
   preedit_underlines_.clear();
   commit_text_.clear();
 
   is_in_key_event_handler_ = false;
 }
 
-bool GtkIMContextWrapper::NeedCommitByForwardingCharEvent() {
+bool GtkIMContextWrapper::NeedCommitByForwardingCharEvent() const {
   // If there is no composition text and has only one character to be
   // committed, then the character will be send to webkit as a Char event
   // instead of a confirmed composition text.
   // It should be fine to handle BMP character only, as non-BMP characters
   // can always be committed as confirmed composition text.
   return !is_composing_text_ && commit_text_.length() == 1;
 }
 
+bool GtkIMContextWrapper::HasInputMethodResult() const {
+  return commit_text_.length() || is_preedit_changed_;
+}
+
 void GtkIMContextWrapper::ProcessFilteredKeyPressEvent(
     NativeWebKeyboardEvent* wke) {
   // If IME has filtered this event, then replace virtual key code with
   // VK_PROCESSKEY. See comment in ProcessKeyEvent() for details.
   // It's only required for keydown events.
   // To emulate windows behavior, when input method is enabled, if the commit
   // text can be emulated by a Char event, then don't do this replacement.
   if (!NeedCommitByForwardingCharEvent()) {
     wke->windowsKeyCode = kCompositionEventKeyCode;
     // keyidentifier must be updated accordingly, otherwise this key event may
@@ skipping 325 matching lines @@
     } while (pango_attr_iterator_next(iter));
     pango_attr_iterator_destroy(iter);
   }
 
   // Use a black thin underline by default.
   if (underlines->empty()) {
     underlines->push_back(
         WebKit::WebCompositionUnderline(0, length, SK_ColorBLACK, false));
   }
 }