Fix issue 19081: Linux: Not able to switch input method correctly in web page...

chrome/browser/renderer_host/gtk_im_context_wrapper.cc

 // Copyright (c) 2009 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>
 
@@ skipping 33 matching lines @@
                    G_CALLBACK(HandleCommitThunk), this);
 
   g_signal_connect(context_simple_, "preedit_start",
                    G_CALLBACK(HandlePreeditStartThunk), this);
   g_signal_connect(context_simple_, "preedit_end",
                    G_CALLBACK(HandlePreeditEndThunk), this);
   g_signal_connect(context_simple_, "preedit_changed",
                    G_CALLBACK(HandlePreeditChangedThunk), this);
   g_signal_connect(context_simple_, "commit",
                    G_CALLBACK(HandleCommitThunk), this);
+
+  GtkWidget* widget = host_view->native_view();
+  DCHECK(widget);
+
+  g_signal_connect(widget, "realize",
+                   G_CALLBACK(HandleHostViewRealizeThunk), this);
+  g_signal_connect(widget, "unrealize",
+                   G_CALLBACK(HandleHostViewUnrealizeThunk), this);
+
+  // Set client window if the widget is already realized.
+  HandleHostViewRealize(widget);
 }
 
 GtkIMContextWrapper::~GtkIMContextWrapper() {
   if (context_)
     g_object_unref(context_);
   if (context_simple_)
     g_object_unref(context_simple_);
 }
 
 void GtkIMContextWrapper::ProcessKeyEvent(GdkEventKey* event) {
@@ skipping 122 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;
 
-  // 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_set_client_window(context_,
-                                   host_view_->native_view()->window);
-
   // 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_);
 
-  // Actually current GtkIMContextSimple implementation doesn't care about
-  // client window. This line is just for safe.
-  gtk_im_context_set_client_window(context_simple_,
-                                   host_view_->native_view()->window);
-
   // 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
   // when WebKit wants to enable or disable IME.
   host_view_->GetRenderWidgetHost()->ImeSetInputMode(true);
 }
 
 void GtkIMContextWrapper::OnFocusOut() {
   if (!is_focused_)
     return;
 
   // Tracks the focused state so that we won't give focus to the
   // GtkIMContext object unexpectly.
   is_focused_ = false;
 
   // Notify the GtkIMContext object of this focus-out event only if IME is
   // enabled by WebKit.
   if (is_enabled_) {
     // To reset the GtkIMContext object and prevent data loss.
     CompleteComposition();
     gtk_im_context_focus_out(context_);
   }
 
-  // Detach this GtkIMContext object from this window.
-  gtk_im_context_set_client_window(context_, NULL);
-
   // To make sure it'll be in correct state when focused in again.
   gtk_im_context_reset(context_simple_);
   gtk_im_context_focus_out(context_simple_);
-  gtk_im_context_set_client_window(context_simple_, NULL);
 
   // Reset stored IME status.
   is_composing_text_ = false;
   preedit_text_.clear();
   preedit_cursor_position_ = 0;
 
   // Disable RenderWidget's IME related events to save bandwidth.
   host_view_->GetRenderWidgetHost()->ImeSetInputMode(false);
 }
 
@@ skipping 211 matching lines @@
   // we need inform webkit to clear it.
   // It's only necessary when it's not in ProcessKeyEvent ().
   if (!is_in_key_event_handler_ && changed) {
     host_view_->GetRenderWidgetHost()->ImeCancelComposition();
   }
 
   // Don't set is_composing_text_ to false here, because "preedit_end"
   // signal may be fired before "commit" signal.
 }
 
+void GtkIMContextWrapper::HandleHostViewRealize(GtkWidget* widget) {
+  // We should only set im context's client window once, because when setting
+  // client window.im context may destroy and recreate its internal states and
+  // objects.
+  if (widget->window) {
+    gtk_im_context_set_client_window(context_, widget->window);
+    gtk_im_context_set_client_window(context_simple_, widget->window);
+  }
+}
+
+void GtkIMContextWrapper::HandleHostViewUnrealize() {
+  gtk_im_context_set_client_window(context_, NULL);
+  gtk_im_context_set_client_window(context_simple_, NULL);
+}
+
 void GtkIMContextWrapper::HandleCommitThunk(
     GtkIMContext* context, gchar* text, GtkIMContextWrapper* self) {
   self->HandleCommit(UTF8ToUTF16(text));
 }
 
 void GtkIMContextWrapper::HandlePreeditStartThunk(
     GtkIMContext* context, GtkIMContextWrapper* self) {
   self->HandlePreeditStart();
 }
 
 void GtkIMContextWrapper::HandlePreeditChangedThunk(
     GtkIMContext* context, GtkIMContextWrapper* self) {
   gchar* text = NULL;
   gint cursor_position = 0;
   gtk_im_context_get_preedit_string(context, &text, NULL, &cursor_position);
   self->HandlePreeditChanged(UTF8ToUTF16(text), cursor_position);
   g_free(text);
 }
 
 void GtkIMContextWrapper::HandlePreeditEndThunk(
     GtkIMContext* context, GtkIMContextWrapper* self) {
   self->HandlePreeditEnd();
 }
+
+void GtkIMContextWrapper::HandleHostViewRealizeThunk(
+    GtkWidget* widget, GtkIMContextWrapper* self) {
+  self->HandleHostViewRealize(widget);
+}
+
+void GtkIMContextWrapper::HandleHostViewUnrealizeThunk(
+    GtkWidget* widget, GtkIMContextWrapper* self) {
+  self->HandleHostViewUnrealize();
+}