A quick fix for Issue 15531 and 10953...

chrome/browser/renderer_host/render_widget_host_view_gtk.cc

 // Copyright (c) 2006-2008 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/render_widget_host_view_gtk.h"
 
 #include <gtk/gtk.h>
 #include <gdk/gdk.h>
 #include <gdk/gdkkeysyms.h>
 #include <gdk/gdkx.h>
@@ skipping 103 matching lines @@
     if (host_view->parent_ && host_view->activatable() &&
         GDK_Escape == event->keyval) {
       // Force popups to close on Esc just in case the renderer is hung.  This
       // allows us to release our keyboard grab.
       host_view->host_->Shutdown();
     } else {
       NativeWebKeyboardEvent wke(event);
       host_view->GetRenderWidgetHost()->ForwardKeyboardEvent(wke);
     }
 
+    // Save the current modifier-key state before dispatching this event to the
+    // GtkIMContext object so its event handlers can use this state to create
+    // Char events.
+    host_view->im_modifier_state_ = event->state;
+
     // Dispatch this event to the GtkIMContext object.
     // It sends a "commit" signal when it has a character to be inserted
     // even when we use a US keyboard so that we can send a Char event
     // (or an IME event) to the renderer in our "commit"-signal handler.
     // We should send a KeyDown (or a KeyUp) event before dispatching this
     // event to the GtkIMContext object (and send a Char event) so that WebKit
     // can dispatch the JavaScript events in the following order: onkeydown(),
     // onkeypress(), and onkeyup(). (Many JavaScript pages assume this.)
     // TODO(hbono): we should not dispatch a key event when the input focus
     // is in a password input?
@@ skipping 41 matching lines @@
       gdk_window_get_origin(widget->window, &x, &y);
       fake_event.globalX = fake_event.x + x;
       fake_event.globalY = fake_event.y + y;
       fake_event.type = WebKit::WebInputEvent::MouseMove;
       fake_event.button = WebKit::WebMouseEvent::ButtonNone;
       host_view->GetRenderWidgetHost()->ForwardMouseEvent(fake_event);
     }
 
     host_view->ShowCurrentCursor();
     host_view->GetRenderWidgetHost()->Focus();
+
+    // Notify the GtkIMContext object of this focus-in event and
+    // attach this GtkIMContext object to this window.
+    // We should call gtk_im_context_set_client_window() only when this window
+    // gain (or release) the window focus because an immodule may reset its
+    // internal status when processing this function.
+    gtk_im_context_focus_in(host_view->im_context_);
+    gtk_im_context_set_client_window(host_view->im_context_,
+                                     host_view->native_view()->window);
     return FALSE;
   }
 
   static gboolean OnFocusOut(GtkWidget* widget, GdkEventFocus* focus,
                              RenderWidgetHostViewGtk* host_view) {
     // Whenever we lose focus, set the cursor back to that of our parent window,
     // which should be the default arrow.
     gdk_window_set_cursor(widget->window, NULL);
     // If we are showing a context menu, maintain the illusion that webkit has
     // focus.
     if (!host_view->is_showing_context_menu_)
       host_view->GetRenderWidgetHost()->Blur();
+
+    // Notify the GtkIMContext object of this focus-in event and
+    // detach this GtkIMContext object from this window.
+    gtk_im_context_focus_out(host_view->im_context_);
+    gtk_im_context_set_client_window(host_view->im_context_, NULL);
     return FALSE;
   }
 
   static gboolean ButtonPressReleaseEvent(
       GtkWidget* widget, GdkEventButton* event,
       RenderWidgetHostViewGtk* host_view) {
     // We want to translate the coordinates of events that do not originate
     // from this widget to be relative to the top left of the widget.
     GtkWidget* event_widget = gtk_get_event_widget(
         reinterpret_cast<GdkEvent*>(event));
@@ skipping 105 matching lines @@
         UTF8ToWide(preedit_text), cursor_position, -1, -1);
     g_free(preedit_text);
   }
 
   static void ForwardCharEvent(RenderWidgetHostViewGtk* host_view,
                                wchar_t im_character) {
     if (!im_character)
       return;
 
     NativeWebKeyboardEvent char_event(im_character,
+                                      host_view->im_modifier_state_,
                                       base::Time::Now().ToDoubleT());
     host_view->GetRenderWidgetHost()->ForwardKeyboardEvent(char_event);
   }
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(RenderWidgetHostViewGtkWidget);
 };
 
 // static
 RenderWidgetHostView* RenderWidgetHostView::CreateViewForWidget(
     RenderWidgetHost* widget) {
   return new RenderWidgetHostViewGtk(widget);
 }
 
 RenderWidgetHostViewGtk::RenderWidgetHostViewGtk(RenderWidgetHost* widget_host)
     : host_(widget_host),
       about_to_validate_and_paint_(false),
       is_hidden_(false),
       is_loading_(false),
       is_showing_context_menu_(false),
       parent_host_view_(NULL),
       parent_(NULL),
       is_popup_first_mouse_release_(true),
       im_context_(NULL),
-      im_is_composing_cjk_text_(false) {
+      im_is_composing_cjk_text_(false),
+      im_modifier_state_(0) {
   host_->set_view(this);
 }
 
 RenderWidgetHostViewGtk::~RenderWidgetHostViewGtk() {
   if (im_context_)
     g_object_unref(im_context_);
   view_.Destroy();
 }
 
 void RenderWidgetHostViewGtk::InitAsChild() {
@@ skipping 151 matching lines @@
 }
 
 void RenderWidgetHostViewGtk::IMEUpdateStatus(int control,
                                               const gfx::Rect& caret_rect) {
   // The renderer has updated its IME status.
   // Control the GtkIMContext object according to this status.
   if (!im_context_)
     return;
 
   if (control == IME_DISABLE) {
-    // TODO(hbono): this code just resets the GtkIMContext object and
-    // detaches it from this window. Should we prevent sending key events to
-    // the GtkIMContext object (or unref it) when we disable IMEs?
+    // TODO(hbono): this code just resets the GtkIMContext object.
+    // Should we prevent sending key events to the GtkIMContext object
+    // (or unref it) when we disable IMEs?
     gtk_im_context_reset(im_context_);
-    gtk_im_context_set_client_window(im_context_, NULL);
     gtk_im_context_set_cursor_location(im_context_, NULL);
   } else {
     // TODO(hbono): we should finish (not reset) an ongoing composition
     // when |control| is IME_COMPLETE_COMPOSITION.
 
-    // Attach the GtkIMContext object to this window.
-    gtk_im_context_set_client_window(im_context_, view_.get()->window);
-
     // Updates the position of the IME candidate window.
     // The position sent from the renderer is a relative one, so we need to
     // attach the GtkIMContext object to this window before changing the
     // position.
     GdkRectangle cursor_rect(caret_rect.ToGdkRectangle());
     gtk_im_context_set_cursor_location(im_context_, &cursor_rect);
   }
 }
 
 void RenderWidgetHostViewGtk::DidPaintRect(const gfx::Rect& rect) {
@@ skipping 143 matching lines @@
 void RenderWidgetHostViewGtk::ReceivedSelectionText(GtkClipboard* clipboard,
     const gchar* text, gpointer userdata) {
   // If there's nothing to paste (|text| is NULL), do nothing.
   if (!text)
     return;
   RenderWidgetHostViewGtk* host_view =
       reinterpret_cast<RenderWidgetHostViewGtk*>(userdata);
   host_view->host_->Send(new ViewMsg_InsertText(host_view->host_->routing_id(),
                                                 UTF8ToUTF16(text)));
 }