Implement Pepper IME API.

content/renderer/pepper_plugin_delegate_impl.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/pepper_plugin_delegate_impl.h"
 
 #include <cmath>
 #include <queue>
 
 #include "base/bind.h"
@@ skipping 648 matching lines @@
   // saved pipe handle.
   // Temporarily, just call back.
   client->BrokerConnected(PlatformFileToInt(plugin_handle), result);
 }
 
 PepperPluginDelegateImpl::PepperPluginDelegateImpl(RenderView* render_view)
     : render_view_(render_view),
       has_saved_context_menu_action_(false),
       saved_context_menu_action_(0),
       id_generator_(0),
-      is_pepper_plugin_focused_(false),
+      focused_plugin_(NULL),
       mouse_lock_owner_(NULL),
       mouse_locked_(false),
       pending_lock_request_(false),
       pending_unlock_request_(false) {
 }
 
 PepperPluginDelegateImpl::~PepperPluginDelegateImpl() {
   DCHECK(!mouse_lock_owner_);
 }
 
@@ skipping 162 matching lines @@
            active_instances_.begin();
        i != active_instances_.end(); ++i) {
     webkit::ppapi::PluginInstance* instance = *i;
     if (instance->GetBitmapForOptimizedPluginPaint(
             paint_bounds, dib, location, clip))
       return *i;
   }
   return NULL;
 }
 
-void PepperPluginDelegateImpl::PluginFocusChanged(bool focused) {
-  is_pepper_plugin_focused_ = focused;
+void PepperPluginDelegateImpl::PluginFocusChanged(
+    webkit::ppapi::PluginInstance* instance,
+    bool focused) {
+  if (focused)
+    focused_plugin_ = instance;
+  else if (focused_plugin_ == instance)
+    focused_plugin_ = NULL;
   if (render_view_)
     render_view_->PpapiPluginFocusChanged();
 }
 
+void PepperPluginDelegateImpl::PluginTextInputTypeChanged(
+    webkit::ppapi::PluginInstance* instance) {
+  if (focused_plugin_ == instance && render_view_)
+    render_view_->PpapiPluginTextInputTypeChanged();
+}
+
+void PepperPluginDelegateImpl::PluginRequestedCancelComposition(
+    webkit::ppapi::PluginInstance* instance) {
+  if (focused_plugin_ == instance && render_view_)
+    render_view_->PpapiPluginCancelComposition();
+}
+
+void PepperPluginDelegateImpl::OnImeSetComposition(
+    const string16& text,
+    const std::vector<WebKit::WebCompositionUnderline>& underlines,
+    int selection_start,
+    int selection_end) {
+  if (!IsPluginAcceptingCompositionEvents()) {
+    composition_text_ = text;
+  } else {
+    // TODO(kinaba) currently all composition events are sent directly to
+    // plugins. Use DOM event mechanism after WebKit is made aware about
+    // plugins that support composition.
+    // The code below mimics the behavior of WebCore::Editor::setComposition.
+
+    // Empty -> nonempty: composition started.
+    if (composition_text_.empty() && !text.empty())
+      focused_plugin_->HandleCompositionStart(string16());
+    // Nonempty -> empty: composition canceled.
+    if (!composition_text_.empty() && text.empty())
+       focused_plugin_->HandleCompositionEnd(string16());
+    composition_text_ = text;
+    // Nonempty: composition is ongoing.
+    if (!composition_text_.empty()) {
+      focused_plugin_->HandleCompositionUpdate(composition_text_, underlines,
+                                               selection_start, selection_end);
+    }
+  }
+}
+
+void PepperPluginDelegateImpl::OnImeConfirmComposition(const string16& text) {
+  if (!text.empty())
+    composition_text_ = text;

[James Su, 2011/10/11 04:13:04]

Looks like we don't need to copy text to composition_text_, as it'll always be
cleared at the end of this method.

[kinaba, 2011/10/11 09:12:21]

Done.
Also, added some comments on the text.empty() case.

+  if (composition_text_.empty())
+    return;
+
+  if (!IsPluginAcceptingCompositionEvents()) {
+    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 = composition_text_[i];
+      char_event.nativeKeyCode = composition_text_[i];
+      char_event.text[0] = composition_text_[i];
+      char_event.unmodifiedText[0] = composition_text_[i];
+      if (render_view_->webwidget())
+        render_view_->webwidget()->handleInputEvent(char_event);
+    }
+  } else {
+    // Mimics the order of events sent by WebKit.
+    // See WebCore::Editor::setComposition() for the corresponding code.
+    focused_plugin_->HandleCompositionEnd(composition_text_);
+    focused_plugin_->HandleTextInput(composition_text_);
+  }
+  composition_text_.clear();
+}
+
+gfx::Rect PepperPluginDelegateImpl::GetCaretBounds() const {
+  if (!focused_plugin_)
+    return gfx::Rect(0, 0, 0, 0);
+  return focused_plugin_->GetCaretBounds();
+}
+
+ui::TextInputType PepperPluginDelegateImpl::GetTextInputType() const {
+  if (!focused_plugin_)
+    return ui::TEXT_INPUT_TYPE_NONE;
+  return focused_plugin_->text_input_type();
+}
+
+bool PepperPluginDelegateImpl::IsPluginAcceptingCompositionEvents() const {
+  if (!focused_plugin_)
+    return false;
+  return focused_plugin_->IsPluginAcceptingCompositionEvents();
+}
+
+bool PepperPluginDelegateImpl::CanComposeInline() const {
+  return IsPluginAcceptingCompositionEvents();
+}
+
 void PepperPluginDelegateImpl::PluginCrashed(
     webkit::ppapi::PluginInstance* instance) {
   subscribed_to_policy_updates_.erase(instance);
   render_view_->PluginCrashed(instance->module()->path());
 
   UnlockMouse(instance);
 }
 
 void PepperPluginDelegateImpl::InstanceCreated(
     webkit::ppapi::PluginInstance* instance) {
@@ skipping 176 matching lines @@
 }
 
 void PepperPluginDelegateImpl::OnSetFocus(bool has_focus) {
   for (std::set<webkit::ppapi::PluginInstance*>::iterator i =
            active_instances_.begin();
        i != active_instances_.end(); ++i)
     (*i)->SetContentAreaFocus(has_focus);
 }
 
 bool PepperPluginDelegateImpl::IsPluginFocused() const {
-  return is_pepper_plugin_focused_;
+  return focused_plugin_ != NULL;
 }
 
 void PepperPluginDelegateImpl::OnLockMouseACK(bool succeeded) {
   DCHECK(!mouse_locked_ && pending_lock_request_);
 
   mouse_locked_ = succeeded;
   pending_lock_request_ = false;
   if (pending_unlock_request_ && !succeeded) {
     // We have sent an unlock request after the lock request. However, since
     // the lock request has failed, the unlock request will be ignored by the
@@ skipping 551 matching lines @@
 
 int PepperPluginDelegateImpl::GetRoutingId() const {
   return render_view_->routing_id();
 }
 
 void PepperPluginDelegateImpl::PublishInitialPolicy(
     scoped_refptr<webkit::ppapi::PluginInstance> instance,
     const std::string& policy) {
   instance->HandlePolicyUpdate(policy);
 }