Implement Pepper IME API.

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 4020 matching lines @@
 
     // Notify all Pepper plugins.
     pepper_delegate_.OnSetFocus(enable);
   }
 }
 
 void RenderView::PpapiPluginFocusChanged() {
   UpdateInputMethod();
 }
 
+void RenderView::PpapiPluginTextInputTypeChanged() {
+  UpdateInputMethod();
+}
+
+void RenderView::PpapiPluginCancelComposition() {
+  Send(new ViewHostMsg_ImeCancelComposition(routing_id()));
+  ui::Range range(ui::Range::InvalidRange());
+  Send(new ViewHostMsg_ImeCompositionRangeChanged(routing_id(), range));
+}
+
 void RenderView::RequestRemoteAccessClientFirewallTraversal() {
   Send(new ViewHostMsg_RequestRemoteAccessClientFirewallTraversal(routing_id_));
 }
 
 void RenderView::OnImeSetComposition(
     const string16& text,
     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 (pepper_delegate_.IsPluginFocused()) {
+    // When a PPAPI plugin has focus, we bypass WebKit.
+    pepper_delegate_.OnImeSetComposition(text,
+                                         underlines,
+                                         selection_start,
+                                         selection_end);
+  } else {
 #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);
@@ skipping 15 matching lines @@
 #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);
-    }
+    // When a PPAPI plugin has focus, we bypass WebKit.
+    pepper_delegate_.OnImeConfirmComposition(text);
   } 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;
-#else
-    // Disable keyboard input in flash for touch ui until PPAPI can support IME
-    // events.
-    return ui::TEXT_INPUT_TYPE_NONE;
-#endif
-  }
-  return RenderWidget::GetTextInputType();
+  return pepper_delegate_.IsPluginFocused() ?
+      pepper_delegate_.GetTextInputType() : RenderWidget::GetTextInputType();
+}
+
+gfx::Rect RenderView::GetCaretBounds() {
+  return pepper_delegate_.IsPluginFocused() ?
+      pepper_delegate_.GetCaretBounds() : RenderWidget::GetCaretBounds();
 }
 
 bool RenderView::CanComposeInline() {
-  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;
+  return pepper_delegate_.IsPluginFocused() ?
+      pepper_delegate_.CanComposeInline() : 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
@@ skipping 295 matching lines @@
   main_frame->enableViewSourceMode(true);
 }
 
 void RenderView::OnLockMouseACK(bool succeeded) {
   pepper_delegate_.OnLockMouseACK(succeeded);
 }
 
 void RenderView::OnMouseLockLost() {
   pepper_delegate_.OnMouseLockLost();
 }