Never submit: tentative Pepper IME.

webkit/plugins/ppapi/ppapi_plugin_instance.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 "webkit/plugins/ppapi/ppapi_plugin_instance.h"
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/metrics/histogram.h"
+#include "base/utf_offset_string_conversions.h"
 #include "base/utf_string_conversions.h"
 #include "ppapi/c/dev/ppb_find_dev.h"
 #include "ppapi/c/dev/ppb_fullscreen_dev.h"
 #include "ppapi/c/dev/ppb_memory_dev.h"
 #include "ppapi/c/dev/ppb_zoom_dev.h"
 #include "ppapi/c/dev/ppp_find_dev.h"
 #include "ppapi/c/dev/ppp_mouse_lock_dev.h"
 #include "ppapi/c/dev/ppp_policy_update_dev.h"
 #include "ppapi/c/dev/ppp_selection_dev.h"
 #include "ppapi/c/dev/ppp_zoom_dev.h"
 #include "ppapi/c/pp_input_event.h"
 #include "ppapi/c/pp_instance.h"
 #include "ppapi/c/pp_rect.h"
 #include "ppapi/c/pp_resource.h"
 #include "ppapi/c/pp_var.h"
 #include "ppapi/c/ppb_core.h"
 #include "ppapi/c/ppb_instance.h"
 #include "ppapi/c/ppp_input_event.h"
 #include "ppapi/c/ppp_instance.h"
 #include "ppapi/c/ppp_messaging.h"
 #include "ppapi/c/private/ppb_instance_private.h"
 #include "ppapi/c/private/ppp_instance_private.h"
 #include "ppapi/shared_impl/input_event_impl.h"
 #include "ppapi/shared_impl/resource.h"
+#include "ppapi/shared_impl/time_conversion.h"
 #include "ppapi/shared_impl/var.h"
 #include "ppapi/thunk/enter.h"
 #include "ppapi/thunk/ppb_buffer_api.h"
 #include "printing/units.h"
 #include "skia/ext/platform_canvas.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebBindings.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebCursorInfo.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebDocument.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebElement.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebFrame.h"
@@ skipping 190 matching lines @@
       checked_for_plugin_messaging_interface_(false),
       plugin_print_interface_(NULL),
       plugin_graphics_3d_interface_(NULL),
       always_on_top_(false),
       fullscreen_container_(NULL),
       fullscreen_(false),
       message_channel_(NULL),
       sad_plugin_(NULL),
       input_event_mask_(0),
       filtered_input_event_mask_(0),
+      text_input_type_(WebKit::WebTextInputTypeText),
+      text_input_caret_set_(false),
       lock_mouse_callback_(PP_BlockUntilComplete()) {
+  memset(&text_input_caret_, 0, sizeof(text_input_caret_));
+  memset(&text_input_caret_bounds_, 0, sizeof(text_input_caret_bounds_));
   pp_instance_ = ResourceTracker::Get()->AddInstance(this);
 
   memset(&current_print_settings_, 0, sizeof(current_print_settings_));
   DCHECK(delegate);
   module_->InstanceCreated(this);
   delegate_->InstanceCreated(this);
   message_channel_.reset(new MessageChannel(this));
 }
 
 PluginInstance::~PluginInstance() {
@@ skipping 182 matching lines @@
                                                   argc,
                                                   argn.get(),
                                                   argv.get()));
 }
 
 bool PluginInstance::HandleDocumentLoad(PPB_URLLoader_Impl* loader) {
   return PP_ToBool(instance_interface_->HandleDocumentLoad(
       pp_instance(), loader->pp_resource()));
 }
 
+bool PluginInstance::SendCompositionEventToPlugin(PP_InputEvent_Type type,
+                                                  const string16& text) {
+  std::vector<WebKit::WebCompositionUnderline> empty;
+  return SendCompositionEventWithUnderlineInformationToPlugin(
+      type, text, empty, static_cast<int>(text.size()),
+      static_cast<int>(text.size()));
+}
+
+bool PluginInstance::SendCompositionEventWithUnderlineInformationToPlugin(
+    PP_InputEvent_Type type,
+    const string16& text,
+    const std::vector<WebKit::WebCompositionUnderline>& underlines,
+    int selection_start,
+    int selection_end) {
+  // Keep a reference on the stack. See NOTE above.
+  scoped_refptr<PluginInstance> ref(this);
+
+  if (!LoadInputEventInterface())
+    return false;
+
+  PP_InputEvent_Class event_class = PP_INPUTEVENT_CLASS_IME;
+  if (!(filtered_input_event_mask_ & event_class) &&
+      !(input_event_mask_ & event_class))
+    return false;
+
+  ::ppapi::InputEventData event;
+  event.event_type = type;
+  event.event_time_stamp = ::ppapi::TimeTicksToPPTimeTicks(
+      base::TimeTicks::Now());
+
+  // Convert UTF16 text to UTF8 with offset conversion.
+  std::vector<size_t> offsets;
+  for (size_t i=0; i<underlines.size(); ++i) {
+    offsets.push_back(underlines[i].startOffset);
+    offsets.push_back(underlines[i].endOffset);
+  }
+  offsets.push_back(selection_start);
+  offsets.push_back(selection_end);
+  event.character_text = UTF16ToUTF8AndAdjustOffsets(text, &offsets);
+
+  size_t len = event.character_text.size();
+  for (size_t i=0; i<underlines.size(); ++i) {
+    // UTF16ToUTF8AndAdjustOffsets does not convert end-of-string offsets.
+    size_t left = underlines[i].startOffset==text.size() ? len : offsets[2*i];
+    size_t right = underlines[i].endOffset==text.size() ? len : offsets[2*i+1];
+    if (left != string16::npos && right != string16::npos) {
+      if (underlines[i].thick)
+        event.composition_target_segment = event.composition_segments.size()/2;
+      event.composition_segments.push_back(left);
+      event.composition_segments.push_back(right);
+    }
+  }
+  size_t left = selection_start==static_cast<int>(text.size()) ? len :
+      offsets[offsets.size()-2];
+  size_t right = selection_end==static_cast<int>(text.size()) ? len :
+      offsets[offsets.size()-1];
+  if (left != string16::npos && right != string16::npos) {
+    event.composition_selection_start = left;
+    event.composition_selection_end = right;
+  } else {
+    event.composition_selection_start = len;
+    event.composition_selection_end = len;
+  }
+
+  if (filtered_input_event_mask_ & event_class)
+    event.is_filtered = true;
+  scoped_refptr<InputEventImpl> event_resource(
+      new InputEventImpl(InputEventImpl::InitAsImpl(),
+                         pp_instance(), event));
+
+  return PP_ToBool(plugin_input_event_interface_->HandleInputEvent(
+      pp_instance(), event_resource->pp_resource()));
+}
+
+bool PluginInstance::HandleCompositionStart(const string16& text) {
+  return SendCompositionEventToPlugin(PP_INPUTEVENT_TYPE_COMPOSITION_START,
+                                      text);
+}
+
+bool PluginInstance::HandleCompositionUpdate(
+    const string16& text,
+    const std::vector<WebKit::WebCompositionUnderline>& underlines,
+    int selection_start,
+    int selection_end) {
+  return SendCompositionEventWithUnderlineInformationToPlugin(
+      PP_INPUTEVENT_TYPE_COMPOSITION_UPDATE,
+      text, underlines, selection_start, selection_end);
+}
+
+bool PluginInstance::HandleCompositionEnd(const string16& text) {
+  return SendCompositionEventToPlugin(PP_INPUTEVENT_TYPE_COMPOSITION_END,
+                                      text);
+}
+
+bool PluginInstance::HandleTextInput(const string16& text) {
+  return SendCompositionEventToPlugin(PP_INPUTEVENT_TYPE_IME_TEXT,
+                                      text);
+}
+
+void PluginInstance::UpdateCaretPosition(const PP_Rect& caret,
+                                         const PP_Rect& boundingBox) {
+  text_input_caret_ = caret;
+  text_input_caret_bounds_ = boundingBox;
+  text_input_caret_set_ = true;
+}
+
+void PluginInstance::SetTextInputType(WebKit::WebTextInputType type) {
+  text_input_type_ = type;
+}
+
+bool PluginInstance::CanComposeInline() const {
+  return (filtered_input_event_mask_ & PP_INPUTEVENT_CLASS_IME) ||
+      (input_event_mask_ & PP_INPUTEVENT_CLASS_IME);
+}
+
+WebKit::WebRect PluginInstance::GetCaretBounds() const {
+  if (!text_input_caret_set_) {
+    // If it is never set by the plugin, use the bottom left corner.
+    WebKit::WebRect caret(position().x(),
+                          position().y(),
+                          0,
+                          position().height());
+    return caret;
+  }
+
+  // TODO(kinaba) take bounds into account
+  // TODO(kinaba) take CSS transformation into accont
+  WebKit::WebRect caret(text_input_caret_.point.x,
+                        text_input_caret_.point.y,
+                        text_input_caret_.size.width,
+                        text_input_caret_.size.height);
+  caret.x += position().x();
+  caret.y += position().y();
+  return caret;
+}
+
 bool PluginInstance::HandleInputEvent(const WebKit::WebInputEvent& event,
                                       WebCursorInfo* cursor_info) {
   // Keep a reference on the stack. See NOTE above.
   scoped_refptr<PluginInstance> ref(this);
 
   bool rv = false;
   if (LoadInputEventInterface()) {
     PP_InputEvent_Class event_class = ClassifyInputEvent(event.type);
     if (!event_class)
       return false;
@@ skipping 77 matching lines @@
   instance_interface_->DidChangeView(pp_instance(), &pp_position, &pp_clip);
 }
 
 void PluginInstance::SetWebKitFocus(bool has_focus) {
   if (has_webkit_focus_ == has_focus)
     return;
 
   bool old_plugin_focus = PluginHasFocus();
   has_webkit_focus_ = has_focus;
   if (PluginHasFocus() != old_plugin_focus) {
-    delegate()->PluginFocusChanged(PluginHasFocus());
+    delegate()->PluginFocusChanged(this, PluginHasFocus());
     instance_interface_->DidChangeFocus(pp_instance(),
                                         PP_FromBool(PluginHasFocus()));
   }
 }
 
 void PluginInstance::SetContentAreaFocus(bool has_focus) {
   if (has_content_area_focus_ == has_focus)
     return;
 
   bool old_plugin_focus = PluginHasFocus();
@@ skipping 985 matching lines @@
 }
 
 void PluginInstance::DoSetCursor(WebCursorInfo* cursor) {
   cursor_.reset(cursor);
   if (fullscreen_container_)
     fullscreen_container_->DidChangeCursor(*cursor);
 }
 
 }  // namespace ppapi
 }  // namespace webkit