OOPIF IME: Renderer Side Changes

content/renderer/render_widget.cc

 // Copyright (c) 2012 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_widget.h"
 
 #include <memory>
 #include <utility>
 
 #include "base/auto_reset.h"
@@ skipping 239 matching lines @@
       pending_window_rect_count_(0),
       screen_info_(screen_info),
       device_scale_factor_(screen_info_.deviceScaleFactor),
 #if defined(OS_ANDROID)
       text_field_is_dirty_(false),
 #endif
       popup_origin_scale_for_emulation_(0.f),
       frame_swap_message_queue_(new FrameSwapMessageQueue()),
       resizing_mode_selector_(new ResizingModeSelector()),
       has_host_context_menu_location_(false),
-      has_focus_(false) {
+      has_focus_(false),
+      focused_pepper_plugin_(nullptr) {
   if (!swapped_out)
     RenderProcess::current()->AddRefProcess();
   DCHECK(RenderThread::Get());
   device_color_profile_.push_back('0');
 #if defined(OS_ANDROID)
   text_input_info_history_.push_back(blink::WebTextInputInfo());
 #endif
 
   // In tests there may not be a RenderThreadImpl.
   if (RenderThreadImpl::current()) {
@@ skipping 1059 matching lines @@
 
 WebRect RenderWidget::windowResizerRect() {
   return resizer_rect_;
 }
 
 void RenderWidget::OnImeSetComposition(
     const base::string16& text,
     const std::vector<WebCompositionUnderline>& underlines,
     const gfx::Range& replacement_range,
     int selection_start, int selection_end) {
+#if defined(ENABLE_PLUGINS)
+  if (focused_pepper_plugin_) {
+    focused_pepper_plugin_->render_frame()->OnImeSetComposition(
+        text, underlines, selection_start, selection_end);
+    return;
+  }
+#endif
+  if (replacement_range.IsValid()) {
+    webwidget_->applyReplacementRange(replacement_range.start(),
+                                      replacement_range.length());
+  }
+
   if (!ShouldHandleImeEvent())
     return;
   ImeEventGuard guard(this);
   if (!webwidget_->setComposition(
       text, WebVector<WebCompositionUnderline>(underlines),
       selection_start, selection_end)) {
     // If we failed to set the composition text, then we need to let the browser
     // process to cancel the input method's ongoing composition session, to make
     // sure we are in a consistent state.
     Send(new InputHostMsg_ImeCancelComposition(routing_id()));
   }
   UpdateCompositionInfo(true);
 }
 
 void RenderWidget::OnImeConfirmComposition(const base::string16& text,
                                            const gfx::Range& replacement_range,
                                            bool keep_selection) {
+#if defined(ENABLE_PLUGINS)
+  if (focused_pepper_plugin_) {
+    focused_pepper_plugin_->render_frame()->OnImeConfirmComposition(
+        text, replacement_range, keep_selection);
+    return;
+  }
+#endif
+  if (replacement_range.IsValid()) {
+    webwidget_->applyReplacementRange(replacement_range.start(),
+                                      replacement_range.length());
+  }
+
   if (!ShouldHandleImeEvent())
     return;
   ImeEventGuard guard(this);
   input_handler_->set_handling_input_event(true);
   if (text.length())
     webwidget_->confirmComposition(text);
   else if (keep_selection)
     webwidget_->confirmComposition(WebWidget::KeepSelection);
   else
     webwidget_->confirmComposition(WebWidget::DoNotKeepSelection);
@@ skipping 67 matching lines @@
 void RenderWidget::OnHandleCompositorProto(const std::vector<uint8_t>& proto) {
   if (compositor_)
     compositor_->OnHandleCompositorProto(proto);
 }
 
 void RenderWidget::showImeIfNeeded() {
   OnShowImeIfNeeded();
 }
 
 ui::TextInputType RenderWidget::GetTextInputType() {
+#if defined(ENABLE_PLUGINS)
+  if (focused_pepper_plugin_)
+    return focused_pepper_plugin_->text_input_type();
+#endif
   if (webwidget_)
     return WebKitToUiTextInputType(webwidget_->textInputType());
   return ui::TEXT_INPUT_TYPE_NONE;
 }
 
 void RenderWidget::UpdateCompositionInfo(bool should_update_range) {
   TRACE_EVENT0("renderer", "RenderWidget::UpdateCompositionInfo");
   gfx::Range range = gfx::Range();
   if (should_update_range) {
     GetCompositionRange(&range);
@@ skipping 192 matching lines @@
   // ime event.
   UpdateSelectionBounds();
 #if defined(OS_ANDROID)
   UpdateTextInputState(
       guard->show_ime() ? ShowIme::IF_NEEDED : ShowIme::HIDE_IME,
       guard->from_ime() ? ChangeSource::FROM_IME : ChangeSource::FROM_NON_IME);
 #endif
 }
 
 void RenderWidget::GetSelectionBounds(gfx::Rect* focus, gfx::Rect* anchor) {
+#if defined(ENABLE_PLUGINS)
+  if (focused_pepper_plugin_) {
+    // TODO(kinaba) http://crbug.com/101101
+    // Current Pepper IME API does not handle selection bounds. So we simply
+    // use the caret position as an empty range for now. It will be updated
+    // after Pepper API equips features related to surrounding text retrieval.
+    blink::WebRect caret(focused_pepper_plugin_->GetCaretBounds());
+    convertViewportToWindow(&caret);
+    *focus = caret;
+    *anchor = caret;
+    return;
+  }
+#endif
   WebRect focus_webrect;
   WebRect anchor_webrect;
   webwidget_->selectionBounds(focus_webrect, anchor_webrect);
   convertViewportToWindow(&focus_webrect);
   convertViewportToWindow(&anchor_webrect);
   *focus = focus_webrect;
   *anchor = anchor_webrect;
 }
 
 void RenderWidget::UpdateSelectionBounds() {
@@ skipping 95 matching lines @@
   // Check the type is in the range representable by ui::TextInputType.
   DCHECK_LE(type, static_cast<int>(ui::TEXT_INPUT_TYPE_MAX)) <<
     "blink::WebTextInputType and ui::TextInputType not synchronized";
   return static_cast<ui::TextInputType>(type);
 }
 
 void RenderWidget::GetCompositionCharacterBounds(
     std::vector<gfx::Rect>* bounds) {
   DCHECK(bounds);
   bounds->clear();
+
+#if defined(ENABLE_PLUGINS)
+  if (focused_pepper_plugin_)
+    return;
+#endif
+
+  if (!webwidget_)
+    return;
+  blink::WebVector<blink::WebRect> bounds_from_blink;
+  if (!webwidget_->getCompositionCharacterBounds(bounds_from_blink))
+    return;
+
+  for (size_t i = 0; i < bounds_from_blink.size(); ++i) {
+    convertViewportToWindow(&bounds_from_blink[i]);
+    bounds->push_back(bounds_from_blink[i]);
+  }
 }
 
 void RenderWidget::GetCompositionRange(gfx::Range* range) {
+#if defined(ENABLE_PLUGINS)
+  if (focused_pepper_plugin_)
+    return;
+#endif
   size_t location, length;
   if (webwidget_->compositionRange(&location, &length)) {
     range->set_start(location);
     range->set_end(location + length);
   } else if (webwidget_->caretOrSelectionRange(&location, &length)) {
     range->set_start(location);
     range->set_end(location + length);
   } else {
     *range = gfx::Range::InvalidRange();
   }
 }
 
 bool RenderWidget::ShouldUpdateCompositionInfo(
     const gfx::Range& range,
     const std::vector<gfx::Rect>& bounds) {
   if (composition_range_ != range)
     return true;
   if (bounds.size() != composition_character_bounds_.size())
     return true;
   for (size_t i = 0; i < bounds.size(); ++i) {
     if (bounds[i] != composition_character_bounds_[i])
       return true;
   }
   return false;
 }
 
 bool RenderWidget::CanComposeInline() {
+#if defined(ENABLE_PLUGINS)
+  if (focused_pepper_plugin_)
+    return focused_pepper_plugin_->IsPluginAcceptingCompositionEvents();
+#endif
   return true;
 }
 
 WebScreenInfo RenderWidget::screenInfo() {
   return screen_info_;
 }
 
 void RenderWidget::resetInputMethod() {
   ImeEventGuard guard(this);
   // If the last text input type is not None, then we should finish any
@@ skipping 166 matching lines @@
 void RenderWidget::requestPointerUnlock() {
   mouse_lock_dispatcher_->UnlockMouse(webwidget_mouse_lock_target_.get());
 }
 
 bool RenderWidget::isPointerLocked() {
   return mouse_lock_dispatcher_->IsMouseLockedTo(
       webwidget_mouse_lock_target_.get());
 }
 
 }  // namespace content