The first step for enabling off-the-spot IME on Pepper on ChromeOS/Linux.

chrome/browser/renderer_host/gtk_im_context_wrapper.cc

 // Copyright (c) 2011 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 43 matching lines @@
 // ui::CompositionUnderline.
 COMPILE_ASSERT(sizeof(ui::CompositionUnderline) ==
                sizeof(WebKit::WebCompositionUnderline),
                ui_CompositionUnderline__WebKit_WebCompositionUnderline_diff);
 
 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_ppapi_plugin_focused_(false),
       is_composing_text_(false),
       is_enabled_(false),
       is_in_key_event_handler_(false),
       is_composition_changed_(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_);
@@ skipping 146 matching lines @@
       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) {
+  text_input_type_ =  type;
+  caret_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;
 
   DCHECK(!is_in_key_event_handler_);
 
-  bool is_enabled = (type == WebKit::WebTextInputTypeText);
+  // If the focus is on a editable text, or on a PPAPI plugin, turn IME on.
+  bool is_enabled = (type == WebKit::WebTextInputTypeText)
+                    || is_ppapi_plugin_focused_;

[kochi, 2011/05/25 06:19:44]

Put || in the end of the previous line, rather than this line.

See
http://dev.chromium.org/developers/coding-style
"Code formatting"

[kinaba, 2011/05/25 22:23:53]

The whole change here is removed from the patch set 2.
Thank you for the pointer. I'll read it carefully.

   if (is_enabled_ != is_enabled) {
     is_enabled_ = is_enabled;
     if (is_enabled)
       gtk_im_context_focus_in(context_);
     else
       gtk_im_context_focus_out(context_);
   }
 
   if (is_enabled) {
     // Updates the position of the IME candidate window.
@@ skipping 52 matching lines @@
   gtk_im_context_reset(context_simple_);
   gtk_im_context_focus_out(context_simple_);
 
   is_composing_text_ = false;
 
   // Disable RenderWidget's IME related events to save bandwidth.
   if (host_view_->GetRenderWidgetHost())
     host_view_->GetRenderWidgetHost()->SetInputMethodActive(false);
 }
 
+void GtkIMContextWrapper::OnPpapiPluginFocusChanged(bool focused) {
+  if (focused != is_ppapi_plugin_focused_) {
+    is_ppapi_plugin_focused_ = focused;
+    UpdateInputMethodState(text_input_type_, caret_rect_);
+  }
+}
+
+
 #if !defined(TOOLKIT_VIEWS)
 // Not defined for views because the views context menu doesn't
 // implement input methods yet.
 void GtkIMContextWrapper::AppendInputMethodsContextMenu(MenuGtk* menu) {
   gboolean show_input_method_menu = TRUE;
 
   g_object_get(gtk_widget_get_settings(GTK_WIDGET(host_view_->native_view())),
                "gtk-show-input-method-menu", &show_input_method_menu, NULL);
   if (!show_input_method_menu)
     return;
@@ skipping 128 matching lines @@
 
   // 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_composition_changed_) {
     if (composition_.text.length()) {
       // Another composition session has been started.
       is_composing_text_ = true;
       // TODO(suzhe): convert both renderer_host and renderer to use
       // ui::CompositionText.
-      const std::vector<WebKit::WebCompositionUnderline>& underlines =
-          reinterpret_cast<const std::vector<WebKit::WebCompositionUnderline>&>(
-              composition_.underlines);
-      host->ImeSetComposition(composition_.text, underlines,
-                              composition_.selection.start(),
-                              composition_.selection.end());
+
+      // For now, if a PPAPI plugin is focused, we don't send ImeSetCompostion.

[kochi, 2011/05/25 06:19:44]

"For now" sounds ambiguous for any future reference on this
comment.

TODO(kinaba): (what you want to do in the future)

is preferred.

That said, as the similar comments appear in the following lines, how about one
TODO() comment on line 243 to cover why we want to special case PPAPI only?

For this instance, "if a PPAPI plugin is focused, we don't send
ImeSetComposition" says exactly what code does and adds not much information
than the code itself.  Please describe why we have to exclude PPAPI here.

[kinaba, 2011/05/25 22:23:53]

Done (the code is moved to content/renderer/render_view.cc:3951).

+      if (!is_ppapi_plugin_focused_) {
+        const std::vector<WebKit::WebCompositionUnderline>& underlines =
+            reinterpret_cast<
+                const std::vector<WebKit::WebCompositionUnderline>&>(
+                    composition_.underlines);
+        host->ImeSetComposition(composition_.text, underlines,
+                                composition_.selection.start(),
+                                composition_.selection.end());
+      }
     } else if (!committed) {
       host->ImeCancelComposition();
     }
   }
 }
 
 void GtkIMContextWrapper::ConfirmComposition() {
   if (!is_enabled_)
     return;
 
@@ skipping 19 matching lines @@
   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()) {
     // Workaround http://crbug.com/45478 by sending fake key down/up events.
     SendFakeCompositionKeyEvent(WebKit::WebInputEvent::RawKeyDown);
-    host_view_->GetRenderWidgetHost()->ImeConfirmComposition(text);
+    if (is_ppapi_plugin_focused_) {
+      // For now, if a PPAPI plugin is focused, we directly emit character
+      // events, instead of sending renderer an IME event.

[kochi, 2011/05/25 06:19:44]

For now -> TODO().

E.g. TODO(kinaba): Until PPAPI has an interface for sending an IME event, we
send character events.

[kinaba, 2011/05/25 22:23:53]

Done (the code is moved to content/renderer/render_view.cc:3967).

+      for (size_t i = 0; i<commit_text_.size(); ++i) {

[kochi, 2011/05/25 06:19:44]

Style nit: spaces around "<".

[kinaba, 2011/05/25 22:23:53]

Done (the code is moved to content/renderer/render_view.cc:3969).

+        NativeWebKeyboardEvent char_event(commit_text_[i],
+                                          0,
+                                          base::Time::Now().ToDoubleT());
+        char_event.skip_in_browser = true;
+        host_view_->ForwardKeyboardEvent(char_event);
+      }
+    } else {
+      host_view_->GetRenderWidgetHost()->ImeConfirmComposition(text);
+    }
     SendFakeCompositionKeyEvent(WebKit::WebInputEvent::KeyUp);
   }
 }
 
 void GtkIMContextWrapper::HandlePreeditStart() {
   // Ignore preedit related signals triggered by CancelComposition() method.
   if (suppress_next_commit_)
     return;
   is_composing_text_ = true;
 }
@@ skipping 22 matching lines @@
   if (composition_.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_ && is_composing_text_ &&
       host_view_->GetRenderWidgetHost()) {
     // Workaround http://crbug.com/45478 by sending fake key down/up events.
     SendFakeCompositionKeyEvent(WebKit::WebInputEvent::RawKeyDown);
-    // TODO(suzhe): convert both renderer_host and renderer to use
-    // ui::CompositionText.
-    const std::vector<WebKit::WebCompositionUnderline>& underlines =
-        reinterpret_cast<const std::vector<WebKit::WebCompositionUnderline>&>(
-            composition_.underlines);
-    host_view_->GetRenderWidgetHost()->ImeSetComposition(
-        composition_.text, underlines, composition_.selection.start(),
-        composition_.selection.end());
+    // For now, if a PPAPI plugin is focused, we don't send ImeSetComposition.

[kochi, 2011/05/25 06:19:44]

Ditto.

[kinaba, 2011/05/25 22:23:53]

Done (content/renderer/render_view.cc:3951).

+    if (!is_ppapi_plugin_focused_) {
+      // TODO(suzhe): convert both renderer_host and renderer to use
+      // ui::CompositionText.
+      const std::vector<WebKit::WebCompositionUnderline>& underlines =
+          reinterpret_cast<const std::vector<WebKit::WebCompositionUnderline>&>(
+              composition_.underlines);
+      host_view_->GetRenderWidgetHost()->ImeSetComposition(
+          composition_.text, underlines, composition_.selection.start(),
+          composition_.selection.end());
+    }
     SendFakeCompositionKeyEvent(WebKit::WebInputEvent::KeyUp);
   }
 }
 
 void GtkIMContextWrapper::HandlePreeditEnd() {
   if (composition_.text.length()) {
     // The composition session has been finished.
     composition_.Clear();
     is_composition_changed_ = true;
 
@@ skipping 60 matching lines @@
 
 void GtkIMContextWrapper::HandleHostViewRealizeThunk(
     GtkWidget* widget, GtkIMContextWrapper* self) {
   self->HandleHostViewRealize(widget);
 }
 
 void GtkIMContextWrapper::HandleHostViewUnrealizeThunk(
     GtkWidget* widget, GtkIMContextWrapper* self) {
   self->HandleHostViewUnrealize();
 }