Send IME events to windowless plug-ins (Chromium side)

content/renderer/render_view.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 "content/renderer/render_view.h"
 
 #include <algorithm>
 #include <cmath>
 #include <string>
 #include <vector>
@@ skipping 305 matching lines @@
       page_id_(-1),
       last_page_id_sent_to_browser_(-1),
       history_list_offset_(-1),
       history_list_length_(0),
       target_url_status_(TARGET_NONE),
       cached_is_main_frame_pinned_to_left_(false),
       cached_is_main_frame_pinned_to_right_(false),
       cached_has_main_frame_horizontal_scrollbar_(false),
       cached_has_main_frame_vertical_scrollbar_(false),
       ALLOW_THIS_IN_INITIALIZER_LIST(pepper_delegate_(this)),
+#if defined(OS_WIN)
+      focused_plugin_id_(-1),
+#endif
       ALLOW_THIS_IN_INITIALIZER_LIST(cookie_jar_(this)),
       geolocation_dispatcher_(NULL),
       speech_input_dispatcher_(NULL),
       device_orientation_dispatcher_(NULL),
       p2p_socket_dispatcher_(NULL),
       devtools_agent_(NULL),
       renderer_accessibility_(NULL),
       session_storage_namespace_id_(session_storage_namespace_id),
       handling_select_range_(false) {
   routing_id_ = routing_id;
@@ skipping 3694 matching lines @@
     const std::vector<WebKit::WebCompositionUnderline>& underlines,
     int selection_start,
     int selection_end) {
   // Until PPAPI has an interface for handling IME events, we skip sending
   // OnImeSetComposition. Otherwise the composition is canceled when a
   // non-editable DOM element is focused.
   //
   // TODO(kinaba) This temporal remedy can be removed after PPAPI is extended
   // with an IME handling interface.
   if (!pepper_delegate_.IsPluginFocused()) {
+#if defined(OS_WIN)
+    // When a plug-in has focus, we create platform-specific IME data used by
+    // our IME emulator and send it directly to the focused plug-in, i.e. we
+    // bypass WebKit. (WebPluginDelegate dispatches this IME data only when its
+    // instance ID is the same one as the specified ID.)
+    if (focused_plugin_id_ >= 0) {
+      std::vector<int> clauses;
+      std::vector<int> target;
+      for (size_t i = 0; i < underlines.size(); ++i) {
+        clauses.push_back(underlines[i].startOffset);
+        clauses.push_back(underlines[i].endOffset);
+        if (underlines[i].thick) {
+          target.clear();
+          target.push_back(underlines[i].startOffset);
+          target.push_back(underlines[i].endOffset);
+        }
+      }
+      std::set<WebPluginDelegateProxy*>::iterator it;
+      for (it = plugin_delegates_.begin();
+           it != plugin_delegates_.end(); ++it) {
+        (*it)->ImeCompositionUpdated(text, clauses, target, selection_end,
+                                     focused_plugin_id_);
+      }
+      return;
+    }
+#endif
     RenderWidget::OnImeSetComposition(text,
                                       underlines,
                                       selection_start,
                                       selection_end);
   }
 }
 
 void RenderView::OnImeConfirmComposition(const string16& text) {
   if (pepper_delegate_.IsPluginFocused()) {
     // TODO(kinaba) Until PPAPI has an interface for handling IME events, we
     // send character events.
     for (size_t i = 0; i < text.size(); ++i) {
       WebKit::WebKeyboardEvent char_event;
       char_event.type = WebKit::WebInputEvent::Char;
       char_event.timeStampSeconds = base::Time::Now().ToDoubleT();
       char_event.modifiers = 0;
       char_event.windowsKeyCode = text[i];
       char_event.nativeKeyCode = text[i];
       char_event.text[0] = text[i];
       char_event.unmodifiedText[0] = text[i];
       if (webwidget_)
         webwidget_->handleInputEvent(char_event);
     }
   } else {
+#if defined(OS_WIN)
+    // Same as OnImeSetComposition(), we send the text from IMEs directly to
+    // plug-ins. When we send IME text directly to plug-ins, we should not send
+    // it to WebKit to prevent WebKit from controlling IMEs.
+    if (focused_plugin_id_ >= 0) {
+      std::set<WebPluginDelegateProxy*>::iterator it;
+      for (it = plugin_delegates_.begin();
+           it != plugin_delegates_.end(); ++it) {
+        (*it)->ImeCompositionCompleted(text, focused_plugin_id_);
+      }
+      return;
+    }
+#endif
     RenderWidget::OnImeConfirmComposition(text);
   }
 }
 
 ui::TextInputType RenderView::GetTextInputType() {
   if (pepper_delegate_.IsPluginFocused()) {
 #if !defined(TOUCH_UI)
     // TODO(kinaba) Until PPAPI has an interface for handling IME events, we
     // consider all the parts of PPAPI plugins are accepting text inputs.
     return ui::TEXT_INPUT_TYPE_TEXT;
@@ skipping 10 matching lines @@
   if (pepper_delegate_.IsPluginFocused()) {
     // TODO(kinaba) Until PPAPI has an interface for handling IME events, there
     // is no way for the browser to know whether the plugin is capable of
     // drawing composition text.  We assume plugins are incapable and let the
     // browser handle composition display for now.
     return false;
   }
   return true;
 }
 
+#if defined(OS_WIN)
+void RenderView::PluginFocusChanged(bool focused, int plugin_id) {
+  if (focused)
+    focused_plugin_id_ = plugin_id;
+  else
+    focused_plugin_id_ = -1;
+}
+#endif
+
 #if defined(OS_MACOSX)
 void RenderView::PluginFocusChanged(bool focused, int plugin_id) {
   IPC::Message* msg = new ViewHostMsg_PluginFocusChanged(routing_id(),
                                                          focused, plugin_id);
   Send(msg);
 }
 
 void RenderView::StartPluginIme() {
   IPC::Message* msg = new ViewHostMsg_StartPluginIme(routing_id());
   // This message can be sent during event-handling, and needs to be delivered
@@ skipping 293 matching lines @@
 }
 
 void RenderView::OnLockMouseACK(bool succeeded) {
   pepper_delegate_.OnLockMouseACK(succeeded);
 }
 
 void RenderView::OnMouseLockLost() {
   pepper_delegate_.OnMouseLockLost();
 }