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 228 matching lines @@
       screen_info_(screen_info),
       device_scale_factor_(screen_info_.deviceScaleFactor),
       next_output_surface_id_(0),
 #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 1217 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) {
+  FOR_EACH_OBSERVER(
+      RenderFrameImpl, render_frames_,
+      OnImeSetComposition(this, text, underlines, replacement_range,

[EhsanK, 2016/06/03 02:38:54]

This and the one below for OnImeConfirmComposition could be removed if we send
the IME IPC to the RenderFrameImpl instead (assuming that the whole change makes
sense).

[kenrb, 2016/06/07 20:18:13]

This is a bit tricky. The code is a bit tortured as is, because you are
notifying every RenderFrameImpl when you only need to let the local root have a
chance to intercept the message. The trouble with moving it to RenderFrameImpl
would be that it might arrive out of order with other InputMsg_ events going to
the RenderWidget, potentially causing race bugs.

Isn't it unnecessary now, though? You have moved a pointer to
focused_pepper_plugin_ into RenderWidget, and it really looks a lot more at home
here. Why not remove it from RenderFrameImpl and just have related Pepper
instance tracking all in RenderWidget, along with accented character
replacement? I don't see anything there that needs to live in RenderFrameImpl.

[EhsanK, 2016/06/09 03:24:26]

Done.

+                          selection_start, selection_end));
+}
+
+void RenderWidget::HandleImeSetComposition(
+    const base::string16& text,
+    const std::vector<WebCompositionUnderline>& underlines,
+    const gfx::Range& replacement_range,
+    int selection_start,
+    int selection_end) {
   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) {
+  FOR_EACH_OBSERVER(
+      RenderFrameImpl, render_frames_,
+      OnImeConfirmComposition(this, text, replacement_range, keep_selection));
+}
+
+void RenderWidget::HandleImeConfirmComposition(
+    const base::string16& text,
+    const gfx::Range& replacement_range,
+    bool keep_selection) {
   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 74 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 153 matching lines @@
 }
 
 float RenderWidget::GetOriginalDeviceScaleFactor() const {
   return
       screen_metrics_emulator_ ?
       screen_metrics_emulator_->original_screen_info().deviceScaleFactor :
       device_scale_factor_;
 }
 
 }  // namespace content