Cleanup GtkIMContext related code by splitting it into separated source file.

This CL splits GtkIMContext related code into separated source files from render_widget_host_view_gtk.{h,cc}, making the code clearer to read. It also fixes issue 18061.
Focus moving issues related to AutocompleteEditViewGtk will be addressed in another CL, see issue 18393 for reference.

BUG=18061: pressing tab on form textfields goes directly to submit or login buttons
TEST=Starts scim's xim server with command "scim -d", then launches chrome with GTK_IM_MODULE=xim. Opens a web page with multiple input box, such as gmail.com, presses Tab and Shift-Tab multiple times to see if focus moves among focusable elements in the web page.

Review URL: http://codereview.chromium.org/160577

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@22996 0039d316-1c4b-4281-b951-d872f2087c98

5 files changed, 667 insertions, 569 deletions

diff --git a/chrome/browser/renderer_host/gtk_im_context_wrapper.cc b/chrome/browser/renderer_host/gtk_im_context_wrapper.cc
new file mode 100644
index 0000000..add0e16
--- /dev/null
+++ b/chrome/browser/renderer_host/gtk_im_context_wrapper.cc
@@ -0,0 +1,496 @@
+// 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>
+
+#include "base/gfx/rect.h"
+#include "base/logging.h"
+#include "base/string_util.h"
+#include "chrome/common/native_web_keyboard_event.h"
+#include "chrome/browser/renderer_host/render_widget_host.h"
+#include "chrome/browser/renderer_host/render_widget_host_view_gtk.h"
+
+GtkIMContextWrapper::GtkIMContextWrapper(RenderWidgetHostViewGtk* host_view)
+    : 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_cursor_position_(0),
+      is_preedit_changed_(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);
+  g_signal_connect(context_, "preedit_end",
+                   G_CALLBACK(HandlePreeditEndThunk), this);
+  g_signal_connect(context_, "preedit_changed",
+                   G_CALLBACK(HandlePreeditChangedThunk), this);
+  g_signal_connect(context_, "commit",
+                   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);
+}
+
+GtkIMContextWrapper::~GtkIMContextWrapper() {
+  if (context_)
+    g_object_unref(context_);
+  if (context_simple_)
+    g_object_unref(context_simple_);
+}
+
+void GtkIMContextWrapper::ProcessKeyEvent(GdkEventKey* event) {
+  // Indicates preedit-changed and commit signal handlers that we are
+  // processing a key event.
+  is_in_key_event_handler_ = true;
+  // Reset this flag so that we can know if preedit is changed after
+  // processing this key event.
+  is_preedit_changed_ = false;
+  // Clear it so that we can know if something needs committing after
+  // processing this key event.
+  commit_text_.clear();
+
+  // According to Document Object Model (DOM) Level 3 Events Specification
+  // Appendix A: Keyboard events and key identifiers
+  // http://www.w3.org/TR/DOM-Level-3-Events/keyset.html:
+  // The event sequence would be:
+  // 1. keydown
+  // 2. textInput
+  // 3. keyup
+  //
+  // So keydown must be sent to webkit before sending input method result,
+  // while keyup must be sent afterwards.
+  // However on Windows, if a keydown event has been processed by IME, its
+  // virtual keycode will be changed to VK_PROCESSKEY(0xE5) before being sent
+  // to application.
+  // To emulate the windows behavior as much as possible, we need to send the
+  // key event to the GtkIMContext object first, and decide whether or not to
+  // send the original key event to webkit according to the result from IME.
+  //
+  // If IME is enabled by WebKit, this event will be dispatched to context_
+  // to get full IME support. Otherwise it'll be dispatched to
+  // context_simple_, so that dead/compose keys can still work.
+  //
+  // 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.)
+  gboolean filtered = false;
+  if (is_enabled_) {
+    filtered = gtk_im_context_filter_keypress(context_, event);
+  } else {
+    filtered = gtk_im_context_filter_keypress(context_simple_, event);
+  }
+
+  NativeWebKeyboardEvent wke(event);
+
+  // Send filtered keydown event before sending IME result.
+  if (event->type == GDK_KEY_PRESS && filtered)
+    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);
+
+  // Send unfiltered keydown and keyup events after sending IME result.
+  if (event->type == GDK_KEY_PRESS && !filtered)
+    ProcessUnfilteredKeyPressEvent(&wke);
+  else if (event->type == GDK_KEY_RELEASE)
+    host_view_->GetRenderWidgetHost()->ForwardKeyboardEvent(wke);
+
+  // End of key event processing.
+  is_in_key_event_handler_ = false;
+}
+
+void GtkIMContextWrapper::UpdateStatus(int control,
+                                       const gfx::Rect& caret_rect) {
+  // The renderer has updated its IME status.
+  // Control the GtkIMContext object according to this status.
+  if (!context_ || !is_focused_)
+    return;
+
+  DCHECK(!is_in_key_event_handler_);
+
+  // TODO(james.su@gmail.com): Following code causes a side effect:
+  // When trying to move cursor from one text input box to another while
+  // composition text is still not confirmed, following CompleteComposition()
+  // calls will prevent the cursor from moving outside the first input box.
+  if (control == IME_DISABLE) {
+    if (is_enabled_) {
+      CompleteComposition();
+      gtk_im_context_reset(context_simple_);
+      gtk_im_context_focus_out(context_);
+      is_enabled_ = false;
+    }
+  } else {
+    // Enable the GtkIMContext object if it's not enabled yet.
+    if (!is_enabled_) {
+      // Reset context_simple_ to its initial state, in case it's currently
+      // in middle of a composition session inside a password box.
+      gtk_im_context_reset(context_simple_);
+      gtk_im_context_focus_in(context_);
+      // It might be true when switching from a password box in middle of a
+      // composition session.
+      is_composing_text_ = false;
+      is_enabled_ = true;
+    } else if (control == IME_COMPLETE_COMPOSITION) {
+      CompleteComposition();
+    }
+
+    // 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(context_, &cursor_rect);
+  }
+}
+
+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);
+}
+
+bool GtkIMContextWrapper::NeedCommitByForwardingCharEvent() {
+  // 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;
+}
+
+void GtkIMContextWrapper::ProcessFilteredKeyPressEvent(
+    NativeWebKeyboardEvent* wke) {
+  // Copied from third_party/WebKit/WebCore/page/EventHandler.cpp
+  //
+  // Match key code of composition keydown event on windows.
+  // IE sends VK_PROCESSKEY which has value 229;
+  //
+  // Please refer to following documents for detals:
+  // - Virtual-Key Codes
+  //   http://msdn.microsoft.com/en-us/library/ms645540(VS.85).aspx
+  // - How the IME System Works
+  //   http://msdn.microsoft.com/en-us/library/cc194848.aspx
+  // - ImmGetVirtualKey Function
+  //   http://msdn.microsoft.com/en-us/library/dd318570(VS.85).aspx
+  const int kCompositionEventKeyCode = 229;
+
+  // 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
+    // still be processed by webkit.
+    wke->setKeyIdentifierFromWindowsKeyCode();
+    // 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 (wke->os_event) {
+      wke->os_event->keyval = GDK_VoidSymbol;
+      wke->os_event->state = 0;
+    }
+  }
+  host_view_->GetRenderWidgetHost()->ForwardKeyboardEvent(*wke);
+}
+
+void GtkIMContextWrapper::ProcessUnfilteredKeyPressEvent(
+    NativeWebKeyboardEvent* wke) {
+  RenderWidgetHost* host = host_view_->GetRenderWidgetHost();
+
+  // Send keydown event as it, because it's not filtered by IME.
+  host->ForwardKeyboardEvent(*wke);
+
+  // IME is disabled by WebKit or the GtkIMContext object cannot handle
+  // this key event.
+  // This case is caused by two reasons:
+  // 1. The given key event is a control-key event, (e.g. return, page up,
+  //    page down, tab, arrows, etc.) or;
+  // 2. The given key event is not a control-key event but printable
+  //    characters aren't assigned to the event, (e.g. alt+d, etc.)
+  // Create a Char event manually from this key event and send it to the
+  // renderer when this Char event contains a printable character which
+  // should be processed by WebKit.
+  // isSystemKey will be set to true if this key event has Alt modifier,
+  // see WebInputEventFactory::keyboardEvent() for details.
+  if (wke->text[0]) {
+    wke->type = WebKit::WebInputEvent::Char;
+    host->ForwardKeyboardEvent(*wke);
+  }
+}
+
+void GtkIMContextWrapper::ProcessInputMethodResult(const GdkEventKey* event,
+                                                   bool filtered) {
+  RenderWidgetHost* host = host_view_->GetRenderWidgetHost();
+  bool committed = false;
+  // We do commit before preedit change, so that we can optimize some
+  // unnecessary preedit changes.
+  if (commit_text_.length()) {
+    if (filtered && NeedCommitByForwardingCharEvent()) {
+      // Send a Char event when we input a composed character without IMEs
+      // so that this event is to be dispatched to onkeypress() handlers,
+      // autofill, etc.
+      // Only commit text generated by a filtered key down event can be sent
+      // as a Char event, because a unfiltered key down event will probably
+      // generate another Char event.
+      // TODO(james.su@gmail.com): Is it necessary to support non BMP chars
+      // here?
+      NativeWebKeyboardEvent char_event(commit_text_[0],
+                                        event->state,
+                                        base::Time::Now().ToDoubleT());
+      host->ForwardKeyboardEvent(char_event);
+    } else {
+      committed = true;
+      // Send an IME event.
+      // Unlike a Char event, an IME event is NOT dispatched to onkeypress()
+      // handlers or autofill.
+      host->ImeConfirmComposition(commit_text_);
+      // Set this flag to false, as this composition session has been
+      // finished.
+      is_composing_text_ = false;
+    }
+  }
+
+  // Send preedit text only if it's changed.
+  // If a text has been committed, then we don't need to send the empty
+  // preedit text again.
+  if (is_preedit_changed_) {
+    if (preedit_text_.length()) {
+      host->ImeSetComposition(preedit_text_, preedit_cursor_position_,
+                              -1, -1);
+    } else if (!committed) {
+      host->ImeCancelComposition();
+    }
+  }
+}
+
+void GtkIMContextWrapper::CompleteComposition() {
+  if (!is_enabled_)
+    return;
+
+  // If WebKit requires to complete current composition, then we need commit
+  // existing preedit text and reset the GtkIMContext object.
+
+  // Backup existing preedit text to avoid it's being cleared when resetting
+  // the GtkIMContext object.
+  string16 old_preedit_text = preedit_text_;
+
+  // Clear it so that we can know if anything is committed by following
+  // line.
+  commit_text_.clear();
+
+  // Resetting the GtkIMContext. Input method may commit something at this
+  // point. In this case, we shall not commit the preedit text again.
+  gtk_im_context_reset(context_);
+
+  // If nothing was committed by above line, then commit stored preedit text
+  // to prevent data loss.
+  if (old_preedit_text.length() && commit_text_.length() == 0) {
+    host_view_->GetRenderWidgetHost()->ImeConfirmComposition(
+        old_preedit_text);
+  }
+
+  is_composing_text_ = false;
+  preedit_text_.clear();
+  preedit_cursor_position_ = 0;
+}
+
+void GtkIMContextWrapper::HandleCommit(const string16& text) {
+  // Append the text to the buffer, because commit signal might be fired
+  // multiple times when processing a key event.
+  commit_text_.append(text);
+  // Nothing needs to do, if it's currently in ProcessKeyEvent()
+  // handler, which will send commit text to webkit later. Otherwise,
+  // we need send it here.
+  // It's possible that commit signal is fired without a key event, for
+  // example when user input via a voice or handwriting recognition software.
+  // In this case, the text must be committed directly.
+  if (!is_in_key_event_handler_) {
+    host_view_->GetRenderWidgetHost()->ImeConfirmComposition(text);
+  }
+}
+
+void GtkIMContextWrapper::HandlePreeditStart() {
+  is_composing_text_ = true;
+}
+
+void GtkIMContextWrapper::HandlePreeditChanged(const string16& text,
+                                               int cursor_position) {
+  bool changed = false;
+  // If preedit text or cursor position is not changed since last time,
+  // then it's not necessary to update it again.
+  // Preedit text is always stored, so that we can commit it when webkit
+  // requires.
+  // Don't set is_preedit_changed_ to false if there is no change, because
+  // this handler might be called multiple times with the same data.
+  if (cursor_position != preedit_cursor_position_ || text != preedit_text_) {
+    preedit_text_ = text;
+    preedit_cursor_position_ = cursor_position;
+    is_preedit_changed_ = true;
+    changed = true;
+  }
+
+  // In case we are using a buggy input method which doesn't fire
+  // "preedit_start" signal.
+  if (text.length())
+    is_composing_text_ = true;
+
+  // Nothing needs to do, if it's currently in ProcessKeyEvent()
+  // handler, which will send preedit text to webkit later.
+  // Otherwise, we need send it here if it's been changed.
+  if (!is_in_key_event_handler_ && changed) {
+    if (text.length()) {
+      host_view_->GetRenderWidgetHost()->ImeSetComposition(
+          text, cursor_position, -1, -1);
+    } else {
+      host_view_->GetRenderWidgetHost()->ImeCancelComposition();
+    }
+  }
+}
+
+void GtkIMContextWrapper::HandlePreeditEnd() {
+  bool changed = false;
+  if (preedit_text_.length()) {
+    // The composition session has been finished.
+    preedit_text_.clear();
+    preedit_cursor_position_ = 0;
+    is_preedit_changed_ = true;
+    changed = true;
+  }
+
+  // If there is still a preedit text when firing "preedit-end" signal,
+  // 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::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();
+}
diff --git a/chrome/browser/renderer_host/gtk_im_context_wrapper.h b/chrome/browser/renderer_host/gtk_im_context_wrapper.h
new file mode 100644
index 0000000..a57286d
--- /dev/null
+++ b/chrome/browser/renderer_host/gtk_im_context_wrapper.h
@@ -0,0 +1,158 @@
+// 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.
+
+#ifndef CHROME_BROWSER_RENDERER_HOST_GTK_IM_CONTEXT_WRAPPER_H_
+#define CHROME_BROWSER_RENDERER_HOST_GTK_IM_CONTEXT_WRAPPER_H_
+
+#include <gdk/gdk.h>
+
+#include "base/basictypes.h"
+#include "base/string16.h"
+
+namespace gfx {
+class Rect;
+}
+
+class RenderWidgetHostViewGtk;
+class NativeWebKeyboardEvent;
+typedef struct _GtkIMContext GtkIMContext;
+
+// This class is a convenience wrapper for GtkIMContext.
+// It creates and manages two GtkIMContext instances, one is GtkIMMulticontext,
+// for plain text input box, another is GtkIMContextSimple, for password input
+// box.
+//
+// This class is in charge of dispatching key events to these two GtkIMContext
+// instances and handling signals emitted by them. Key events then will be
+// forwarded to renderer along with input method results via corresponding host
+// view.
+//
+// This class is used solely by RenderWidgetHostViewGtk.
+class GtkIMContextWrapper {
+ public:
+  explicit GtkIMContextWrapper(RenderWidgetHostViewGtk* host_view);
+  ~GtkIMContextWrapper();
+
+  // Processes a gdk key event received by |host_view|.
+  void ProcessKeyEvent(GdkEventKey* event);
+
+  // Updates IME status and caret position.
+  void UpdateStatus(int control, const gfx::Rect& caret_rect);
+  void OnFocusIn();
+  void OnFocusOut();
+
+ private:
+  // Check if a text needs commit by forwarding a char event instead of
+  // by confirming as a composition text.
+  bool NeedCommitByForwardingCharEvent();
+
+  void ProcessFilteredKeyPressEvent(NativeWebKeyboardEvent* wke);
+  void ProcessUnfilteredKeyPressEvent(NativeWebKeyboardEvent* wke);
+
+  // Processes result returned from input method after filtering a key event.
+  // |filtered| indicates if the key event was filtered by the input method.
+  void ProcessInputMethodResult(const GdkEventKey* event, bool filtered);
+
+  void CompleteComposition();
+
+  // Real code of "commit" signal handler.
+  void HandleCommit(const string16& text);
+
+  // Real code of "preedit-start" signal handler.
+  void HandlePreeditStart();
+
+  // Real code of "preedit-changed" signal handler.
+  void HandlePreeditChanged(const string16& text, int cursor_position);
+
+  // Real code of "preedit-end" signal handler.
+  void HandlePreeditEnd();
+
+  // Signal handlers of GtkIMContext object.
+  static void HandleCommitThunk(GtkIMContext* context, gchar* text,
+                                GtkIMContextWrapper* self);
+  static void HandlePreeditStartThunk(GtkIMContext* context,
+                                      GtkIMContextWrapper* self);
+  static void HandlePreeditChangedThunk(GtkIMContext* context,
+                                        GtkIMContextWrapper* self);
+  static void HandlePreeditEndThunk(GtkIMContext* context,
+                                    GtkIMContextWrapper* self);
+
+  // The parent object.
+  RenderWidgetHostViewGtk* host_view_;
+
+  // The GtkIMContext object.
+  // In terms of the DOM event specification Appendix A
+  //   <http://www.w3.org/TR/DOM-Level-3-Events/keyset.html>,
+  // GTK uses a GtkIMContext object for the following two purposes:
+  //  1. Composing Latin characters (A.1.2), and;
+  //  2. Composing CJK characters with an IME (A.1.3).
+  // Many JavaScript pages assume composed Latin characters are dispatched to
+  // their onkeypress() handlers but not dispatched CJK characters composed
+  // with an IME. To emulate this behavior, we should monitor the status of
+  // this GtkIMContext object and prevent sending Char events when a
+  // GtkIMContext object sends a "commit" signal with the CJK characters
+  // composed by an IME.
+  GtkIMContext* context_;
+
+  // A GtkIMContextSimple object, for supporting dead/compose keys when input
+  // method is disabled, eg. in password input box.
+  GtkIMContext* context_simple_;
+
+  // Whether or not this widget is focused.
+  bool is_focused_;
+
+  // Whether or not the above GtkIMContext is composing a text with an IME.
+  // This flag is used in "commit" signal handler of the GtkIMContext object,
+  // which determines how to submit the result text to WebKit according to this
+  // flag.
+  // If this flag is true or there are more than one characters in the result,
+  // then the result text will be committed to WebKit as a confirmed
+  // composition. Otherwise, it'll be forwarded as a key event.
+  //
+  // The GtkIMContext object sends a "preedit_start" before it starts composing
+  // a text and a "preedit_end" signal after it finishes composing it.
+  // "preedit_start" signal is monitored to turn it on.
+  // We don't monitor "preedit_end" signal to turn it off, because an input
+  // method may fire "preedit_end" signal before "commit" signal.
+  // A buggy input method may not fire "preedit_start" and/or "preedit_end"
+  // at all, so this flag will also be set to true when "preedit_changed" signal
+  // is fired with non-empty preedit text.
+  bool is_composing_text_;
+
+  // Whether or not the IME is enabled.
+  // This flag is actually controlled by RenderWidget.
+  // It shall be set to false when an ImeUpdateStatus message with control ==
+  // IME_DISABLE is received, and shall be set to true if control ==
+  // IME_COMPLETE_COMPOSITION or IME_MOVE_WINDOWS.
+  // When this flag is false, keyboard events shall be dispatched directly
+  // instead of sending to context_.
+  bool is_enabled_;
+
+  // Whether or not it's currently running inside key event handler.
+  // If it's true, then preedit-changed and commit handler will backup the
+  // preedit or commit text instead of sending them down to webkit.
+  // key event handler will send them later.
+  bool is_in_key_event_handler_;
+
+  // Stores a copy of the most recent preedit text retrieved from context_.
+  // When an ImeUpdateStatus message with control == IME_COMPLETE_COMPOSITION
+  // is received, this stored preedit text (if not empty) shall be committed,
+  // and context_ shall be reset.
+  string16 preedit_text_;
+
+  // Stores the cursor position in the stored preedit text.
+  int preedit_cursor_position_;
+
+  // Whether or not the preedit has been changed since last key event.
+  bool is_preedit_changed_;
+
+  // Stores a copy of the most recent commit text received by commit signal
+  // handler.
+  string16 commit_text_;
+
+  DISALLOW_COPY_AND_ASSIGN(GtkIMContextWrapper);
+};
+
+
+#endif  // CHROME_BROWSER_RENDERER_HOST_GTK_IM_CONTEXT_WRAPPER_H_
diff --git a/chrome/browser/renderer_host/render_widget_host_view_gtk.cc b/chrome/browser/renderer_host/render_widget_host_view_gtk.cc
index eddcf59..a04e5b5 100644
--- a/chrome/browser/renderer_host/render_widget_host_view_gtk.cc
+++ b/chrome/browser/renderer_host/render_widget_host_view_gtk.cc
@@ -10,6 +10,9 @@
 #include <gdk/gdkx.h>
 #include <cairo/cairo.h>
 
+#include <algorithm>
+#include <string>
+
 #include "base/gfx/gtk_util.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
@@ -21,6 +24,7 @@
 #include "chrome/common/render_messages.h"
 #include "chrome/common/x11_util.h"
 #include "chrome/browser/renderer_host/backing_store.h"
+#include "chrome/browser/renderer_host/gtk_im_context_wrapper.h"
 #include "chrome/browser/renderer_host/render_widget_host.h"
 #include "webkit/api/public/gtk/WebInputEventFactory.h"
 #include "webkit/glue/webcursor_gtk_data.h"
@@ -30,569 +34,6 @@ static const int kMaxWindowHeight = 4000;
 
 using WebKit::WebInputEventFactory;
 
-// This class is a conveience wrapper for GtkIMContext.
-class RenderWidgetHostViewGtkIMContext {
- public:
-  explicit RenderWidgetHostViewGtkIMContext(RenderWidgetHostViewGtk* host_view)
-      : 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_cursor_position_(0),
-        is_preedit_changed_(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);
-    g_signal_connect(context_, "preedit_end",
-                     G_CALLBACK(HandlePreeditEndThunk), this);
-    g_signal_connect(context_, "preedit_changed",
-                     G_CALLBACK(HandlePreeditChangedThunk), this);
-    g_signal_connect(context_, "commit",
-                     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);
-  }
-
-  ~RenderWidgetHostViewGtkIMContext() {
-    if (context_)
-      g_object_unref(context_);
-    if (context_simple_)
-      g_object_unref(context_simple_);
-  }
-
-  void ProcessKeyEvent(GdkEventKey* event) {
-    // Indicates preedit-changed and commit signal handlers that we are
-    // processing a key event.
-    is_in_key_event_handler_ = true;
-    // Reset this flag so that we can know if preedit is changed after
-    // processing this key event.
-    is_preedit_changed_ = false;
-    // Clear it so that we can know if something needs committing after
-    // processing this key event.
-    commit_text_.clear();
-
-    // According to Document Object Model (DOM) Level 3 Events Specification
-    // Appendix A: Keyboard events and key identifiers
-    // http://www.w3.org/TR/DOM-Level-3-Events/keyset.html:
-    // The event sequence would be:
-    // 1. keydown
-    // 2. textInput
-    // 3. keyup
-    //
-    // So keydown must be sent to webkit before sending input method result,
-    // while keyup must be sent afterwards.
-    // However on Windows, if a keydown event has been processed by IME, its
-    // virtual keycode will be changed to VK_PROCESSKEY(0xE5) before being sent
-    // to application.
-    // To emulate the windows behavior as much as possible, we need to send the
-    // key event to the GtkIMContext object first, and decide whether or not to
-    // send the original key event to webkit according to the result from IME.
-    //
-    // If IME is enabled by WebKit, this event will be dispatched to context_
-    // to get full IME support. Otherwise it'll be dispatched to
-    // context_simple_, so that dead/compose keys can still work.
-    //
-    // 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.)
-    gboolean filtered = false;
-    if (is_enabled_) {
-      filtered = gtk_im_context_filter_keypress(context_, event);
-    } else {
-      filtered = gtk_im_context_filter_keypress(context_simple_, event);
-    }
-
-    NativeWebKeyboardEvent wke(event);
-
-    // Send filtered keydown event before sending IME result.
-    if (event->type == GDK_KEY_PRESS && filtered)
-      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);
-
-    // Send unfiltered keydown and keyup events after sending IME result.
-    if (event->type == GDK_KEY_PRESS && !filtered)
-      ProcessUnfilteredKeyPressEvent(&wke);
-    else if (event->type == GDK_KEY_RELEASE)
-      host_view_->GetRenderWidgetHost()->ForwardKeyboardEvent(wke);
-
-    // End of key event processing.
-    is_in_key_event_handler_ = false;
-  }
-
-  void UpdateStatus(int control, const gfx::Rect& caret_rect) {
-    // The renderer has updated its IME status.
-    // Control the GtkIMContext object according to this status.
-    if (!context_ || !is_focused_)
-      return;
-
-    DCHECK(!is_in_key_event_handler_);
-
-    // TODO(james.su@gmail.com): Following code causes a side effect:
-    // When trying to move cursor from one text input box to another while
-    // composition text is still not confirmed, following CompleteComposition()
-    // calls will prevent the cursor from moving outside the first input box.
-    if (control == IME_DISABLE) {
-      if (is_enabled_) {
-        CompleteComposition();
-        gtk_im_context_reset(context_simple_);
-        gtk_im_context_focus_out(context_);
-        is_enabled_ = false;
-      }
-    } else {
-      // Enable the GtkIMContext object if it's not enabled yet.
-      if (!is_enabled_) {
-        // Reset context_simple_ to its initial state, in case it's currently
-        // in middle of a composition session inside a password box.
-        gtk_im_context_reset(context_simple_);
-        gtk_im_context_focus_in(context_);
-        // It might be true when switching from a password box in middle of a
-        // composition session.
-        is_composing_text_ = false;
-        is_enabled_ = true;
-      } else if (control == IME_COMPLETE_COMPOSITION) {
-        CompleteComposition();
-      }
-
-      // 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(context_, &cursor_rect);
-    }
-  }
-
-  void 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 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);
-  }
-
- private:
-  // Check if a text needs commit by forwarding a char event instead of
-  // by confirming as a composition text.
-  bool NeedCommitByForwardingCharEvent() {
-    // 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;
-  }
-
-  void ProcessFilteredKeyPressEvent(NativeWebKeyboardEvent* wke) {
-    // Copied from third_party/WebKit/WebCore/page/EventHandler.cpp
-    //
-    // Match key code of composition keydown event on windows.
-    // IE sends VK_PROCESSKEY which has value 229;
-    //
-    // Please refer to following documents for detals:
-    // - Virtual-Key Codes
-    //   http://msdn.microsoft.com/en-us/library/ms645540(VS.85).aspx
-    // - How the IME System Works
-    //   http://msdn.microsoft.com/en-us/library/cc194848.aspx
-    // - ImmGetVirtualKey Function
-    //   http://msdn.microsoft.com/en-us/library/dd318570(VS.85).aspx
-    const int kCompositionEventKeyCode = 229;
-
-    // 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;
-      // 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 (wke->os_event) {
-        wke->os_event->keyval = GDK_VoidSymbol;
-        wke->os_event->state = 0;
-      }
-    }
-    host_view_->GetRenderWidgetHost()->ForwardKeyboardEvent(*wke);
-  }
-
-  void ProcessUnfilteredKeyPressEvent(NativeWebKeyboardEvent* wke) {
-    RenderWidgetHost* host = host_view_->GetRenderWidgetHost();
-
-    // Send keydown event as it, because it's not filtered by IME.
-    host->ForwardKeyboardEvent(*wke);
-
-    // IME is disabled by WebKit or the GtkIMContext object cannot handle
-    // this key event.
-    // This case is caused by two reasons:
-    // 1. The given key event is a control-key event, (e.g. return, page up,
-    //    page down, tab, arrows, etc.) or;
-    // 2. The given key event is not a control-key event but printable
-    //    characters aren't assigned to the event, (e.g. alt+d, etc.)
-    // Create a Char event manually from this key event and send it to the
-    // renderer when this Char event contains a printable character which
-    // should be processed by WebKit.
-    // isSystemKey will be set to true if this key event has Alt modifier,
-    // see WebInputEventFactory::keyboardEvent() for details.
-    if (wke->text[0]) {
-      wke->type = WebKit::WebInputEvent::Char;
-      host->ForwardKeyboardEvent(*wke);
-    }
-  }
-
-  // Processes result returned from input method after filtering a key event.
-  // |filtered| indicates if the key event was filtered by the input method.
-  void ProcessInputMethodResult(const GdkEventKey* event, bool filtered) {
-    RenderWidgetHost* host = host_view_->GetRenderWidgetHost();
-    bool committed = false;
-    // We do commit before preedit change, so that we can optimize some
-    // unnecessary preedit changes.
-    if (commit_text_.length()) {
-      if (filtered && NeedCommitByForwardingCharEvent()) {
-        // Send a Char event when we input a composed character without IMEs
-        // so that this event is to be dispatched to onkeypress() handlers,
-        // autofill, etc.
-        // Only commit text generated by a filtered key down event can be sent
-        // as a Char event, because a unfiltered key down event will probably
-        // generate another Char event.
-        // TODO(james.su@gmail.com): Is it necessary to support non BMP chars
-        // here?
-        NativeWebKeyboardEvent char_event(commit_text_[0],
-                                          event->state,
-                                          base::Time::Now().ToDoubleT());
-        host->ForwardKeyboardEvent(char_event);
-      } else {
-        committed = true;
-        // Send an IME event.
-        // Unlike a Char event, an IME event is NOT dispatched to onkeypress()
-        // handlers or autofill.
-        host->ImeConfirmComposition(commit_text_);
-        // Set this flag to false, as this composition session has been
-        // finished.
-        is_composing_text_ = false;
-      }
-    }
-
-    // Send preedit text only if it's changed.
-    // If a text has been committed, then we don't need to send the empty
-    // preedit text again.
-    if (is_preedit_changed_) {
-      if (preedit_text_.length()) {
-        host->ImeSetComposition(preedit_text_, preedit_cursor_position_,
-                                -1, -1);
-      } else if (!committed) {
-        host->ImeCancelComposition();
-      }
-    }
-  }
-
-  void CompleteComposition() {
-    if (!is_enabled_)
-      return;
-
-    // If WebKit requires to complete current composition, then we need commit
-    // existing preedit text and reset the GtkIMContext object.
-
-    // Backup existing preedit text to avoid it's being cleared when resetting
-    // the GtkIMContext object.
-    string16 old_preedit_text = preedit_text_;
-
-    // Clear it so that we can know if anything is committed by following
-    // line.
-    commit_text_.clear();
-
-    // Resetting the GtkIMContext. Input method may commit something at this
-    // point. In this case, we shall not commit the preedit text again.
-    gtk_im_context_reset(context_);
-
-    // If nothing was committed by above line, then commit stored preedit text
-    // to prevent data loss.
-    if (old_preedit_text.length() && commit_text_.length() == 0) {
-      host_view_->GetRenderWidgetHost()->ImeConfirmComposition(
-          old_preedit_text);
-    }
-
-    is_composing_text_ = false;
-    preedit_text_.clear();
-    preedit_cursor_position_ = 0;
-  }
-
-  // Real code of "commit" signal handler.
-  void HandleCommit(const string16& text) {
-    // Append the text to the buffer, because commit signal might be fired
-    // multiple times when processing a key event.
-    commit_text_.append(text);
-    // Nothing needs to do, if it's currently in ProcessKeyEvent()
-    // handler, which will send commit text to webkit later. Otherwise,
-    // we need send it here.
-    // It's possible that commit signal is fired without a key event, for
-    // example when user input via a voice or handwriting recognition software.
-    // In this case, the text must be committed directly.
-    if (!is_in_key_event_handler_) {
-      host_view_->GetRenderWidgetHost()->ImeConfirmComposition(text);
-    }
-  }
-
-  // Real code of "preedit-start" signal handler.
-  void HandlePreeditStart() {
-    is_composing_text_ = true;
-  }
-
-  // Real code of "preedit-changed" signal handler.
-  void HandlePreeditChanged(const string16& text, int cursor_position) {
-    bool changed = false;
-    // If preedit text or cursor position is not changed since last time,
-    // then it's not necessary to update it again.
-    // Preedit text is always stored, so that we can commit it when webkit
-    // requires.
-    // Don't set is_preedit_changed_ to false if there is no change, because
-    // this handler might be called multiple times with the same data.
-    if (cursor_position != preedit_cursor_position_ || text != preedit_text_) {
-      preedit_text_ = text;
-      preedit_cursor_position_ = cursor_position;
-      is_preedit_changed_ = true;
-      changed = true;
-    }
-
-    // In case we are using a buggy input method which doesn't fire
-    // "preedit_start" signal.
-    if (text.length())
-      is_composing_text_ = true;
-
-    // Nothing needs to do, if it's currently in ProcessKeyEvent()
-    // handler, which will send preedit text to webkit later.
-    // Otherwise, we need send it here if it's been changed.
-    if (!is_in_key_event_handler_ && changed) {
-      if (text.length()) {
-        host_view_->GetRenderWidgetHost()->ImeSetComposition(
-            text, cursor_position, -1, -1);
-      } else {
-        host_view_->GetRenderWidgetHost()->ImeCancelComposition();
-      }
-    }
-  }
-
-  // Real code of "preedit-end" signal handler.
-  void HandlePreeditEnd() {
-    bool changed = false;
-    if (preedit_text_.length()) {
-      // The composition session has been finished.
-      preedit_text_.clear();
-      preedit_cursor_position_ = 0;
-      is_preedit_changed_ = true;
-      changed = true;
-    }
-
-    // If there is still a preedit text when firing "preedit-end" signal,
-    // 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.
-  }
-
- private:
-  // Signal handlers of GtkIMContext object.
-  static void HandleCommitThunk(GtkIMContext* context, gchar* text,
-                                RenderWidgetHostViewGtkIMContext* self) {
-    self->HandleCommit(UTF8ToUTF16(text));
-  }
-
-  static void HandlePreeditStartThunk(GtkIMContext* context,
-                                      RenderWidgetHostViewGtkIMContext* self) {
-    self->HandlePreeditStart();
-  }
-
-  static void HandlePreeditChangedThunk(
-      GtkIMContext* context, RenderWidgetHostViewGtkIMContext* 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);
-  }
-
-  static void HandlePreeditEndThunk(GtkIMContext* context,
-                                    RenderWidgetHostViewGtkIMContext* self) {
-    self->HandlePreeditEnd();
-  }
-
- private:
-  // The parent object.
-  RenderWidgetHostViewGtk* host_view_;
-
-  // The GtkIMContext object.
-  // In terms of the DOM event specification Appendix A
-  //   <http://www.w3.org/TR/DOM-Level-3-Events/keyset.html>,
-  // GTK uses a GtkIMContext object for the following two purposes:
-  //  1. Composing Latin characters (A.1.2), and;
-  //  2. Composing CJK characters with an IME (A.1.3).
-  // Many JavaScript pages assume composed Latin characters are dispatched to
-  // their onkeypress() handlers but not dispatched CJK characters composed
-  // with an IME. To emulate this behavior, we should monitor the status of
-  // this GtkIMContext object and prevent sending Char events when a
-  // GtkIMContext object sends a "commit" signal with the CJK characters
-  // composed by an IME.
-  GtkIMContext* context_;
-
-  // A GtkIMContextSimple object, for supporting dead/compose keys when input
-  // method is disabled, eg. in password input box.
-  GtkIMContext* context_simple_;
-
-  // Whether or not this widget is focused.
-  bool is_focused_;
-
-  // Whether or not the above GtkIMContext is composing a text with an IME.
-  // This flag is used in "commit" signal handler of the GtkIMContext object,
-  // which determines how to submit the result text to WebKit according to this
-  // flag.
-  // If this flag is true or there are more than one characters in the result,
-  // then the result text will be committed to WebKit as a confirmed
-  // composition. Otherwise, it'll be forwarded as a key event.
-  //
-  // The GtkIMContext object sends a "preedit_start" before it starts composing
-  // a text and a "preedit_end" signal after it finishes composing it.
-  // "preedit_start" signal is monitored to turn it on.
-  // We don't monitor "preedit_end" signal to turn it off, because an input
-  // method may fire "preedit_end" signal before "commit" signal.
-  // A buggy input method may not fire "preedit_start" and/or "preedit_end"
-  // at all, so this flag will also be set to true when "preedit_changed" signal
-  // is fired with non-empty preedit text.
-  bool is_composing_text_;
-
-  // Whether or not the IME is enabled.
-  // This flag is actually controlled by RenderWidget.
-  // It shall be set to false when an ImeUpdateStatus message with control ==
-  // IME_DISABLE is received, and shall be set to true if control ==
-  // IME_COMPLETE_COMPOSITION or IME_MOVE_WINDOWS.
-  // When this flag is false, keyboard events shall be dispatched directly
-  // instead of sending to context_.
-  bool is_enabled_;
-
-  // Whether or not it's currently running inside key event handler.
-  // If it's true, then preedit-changed and commit handler will backup the
-  // preedit or commit text instead of sending them down to webkit.
-  // key event handler will send them later.
-  bool is_in_key_event_handler_;
-
-  // Stores a copy of the most recent preedit text retrieved from context_.
-  // When an ImeUpdateStatus message with control == IME_COMPLETE_COMPOSITION
-  // is received, this stored preedit text (if not empty) shall be committed,
-  // and context_ shall be reset.
-  string16 preedit_text_;
-
-  // Stores the cursor position in the stored preedit text.
-  int preedit_cursor_position_;
-
-  // Whether or not the preedit has been changed since last key event.
-  bool is_preedit_changed_;
-
-  // Stores a copy of the most recent commit text received by commit signal
-  // handler.
-  string16 commit_text_;
-
-  DISALLOW_COPY_AND_ASSIGN(RenderWidgetHostViewGtkIMContext);
-};
-
 // This class is a simple convenience wrapper for Gtk functions. It has only
 // static methods.
 class RenderWidgetHostViewGtkWidget {
@@ -642,8 +83,7 @@ class RenderWidgetHostViewGtkWidget {
                            G_CALLBACK(MouseScrollEvent), host_view);
 
     // Create GtkIMContext wrapper object.
-    host_view->im_context_.reset(
-        new RenderWidgetHostViewGtkIMContext(host_view));
+    host_view->im_context_.reset(new GtkIMContextWrapper(host_view));
 
     return widget;
   }
diff --git a/chrome/browser/renderer_host/render_widget_host_view_gtk.h b/chrome/browser/renderer_host/render_widget_host_view_gtk.h
index eccea4a..41e7e1d 100644
--- a/chrome/browser/renderer_host/render_widget_host_view_gtk.h
+++ b/chrome/browser/renderer_host/render_widget_host_view_gtk.h
@@ -6,7 +6,10 @@
 #define CHROME_BROWSER_RENDERER_HOST_RENDER_WIDGET_HOST_VIEW_GTK_H_
 
 #include <gdk/gdk.h>
+
+#include <map>
 #include <vector>
+#include <string>
 
 #include "base/gfx/native_widget_types.h"
 #include "base/scoped_ptr.h"
@@ -18,18 +21,17 @@
 
 class RenderWidgetHost;
 // A conveience wrapper class for GtkIMContext;
-class RenderWidgetHostViewGtkIMContext;
+class GtkIMContextWrapper;
 
 typedef struct _GtkClipboard GtkClipboard;
 typedef struct _GtkSelectionData GtkSelectionData;
-typedef struct _GtkIMContext GtkIMContext;
 
 // -----------------------------------------------------------------------------
 // See comments in render_widget_host_view.h about this class and its members.
 // -----------------------------------------------------------------------------
 class RenderWidgetHostViewGtk : public RenderWidgetHostView {
  public:
-  RenderWidgetHostViewGtk(RenderWidgetHost* widget);
+  explicit RenderWidgetHostViewGtk(RenderWidgetHost* widget);
   ~RenderWidgetHostViewGtk();
 
   // Initialize this object for use as a drawing area.
@@ -124,7 +126,7 @@ class RenderWidgetHostViewGtk : public RenderWidgetHostView {
   bool was_focused_before_grab_;
 
   // A conveience wrapper object for GtkIMContext;
-  scoped_ptr<RenderWidgetHostViewGtkIMContext> im_context_;
+  scoped_ptr<GtkIMContextWrapper> im_context_;
 
   // Helper class that lets us allocate plugin containers and move them.
   GtkPluginContainerManager plugin_container_manager_;
diff --git a/chrome/chrome.gyp b/chrome/chrome.gyp
index ab3333d..ad2b82b 100644
--- a/chrome/chrome.gyp
+++ b/chrome/chrome.gyp
@@ -1481,6 +1481,8 @@
         'browser/renderer_host/download_throttling_resource_handler.h',
         'browser/renderer_host/file_system_accessor.cc',
         'browser/renderer_host/file_system_accessor.h',
+        'browser/renderer_host/gtk_im_context_wrapper.cc',
+        'browser/renderer_host/gtk_im_context_wrapper.h',
         'browser/renderer_host/render_process_host.cc',
         'browser/renderer_host/render_process_host.h',
         'browser/renderer_host/render_sandbox_host_linux.h',