OOPIF IME: Renderer Side Changes

content/renderer/render_frame_impl.cc

 // Copyright 2013 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_frame_impl.h"
 
 #include <map>
 #include <string>
 #include <utility>
 #include <vector>
@@ skipping 4372 matching lines @@
 #if defined(ENABLE_PLUGINS)
   for (auto* plugin : active_pepper_instances_)
     plugin->PageVisibilityChanged(true);
 #endif  // ENABLE_PLUGINS
 }
 
 void RenderFrameImpl::WidgetWillClose() {
   FOR_EACH_OBSERVER(RenderFrameObserver, observers_, WidgetWillClose());
 }
 
+void RenderFrameImpl::OnImeSetComposition(
+    RenderWidget* render_widget,
+    const base::string16& text,
+    const std::vector<blink::WebCompositionUnderline>& underlines,
+    const gfx::Range& replacement_range,
+    int selection_start,
+    int selection_end) {
+  if (render_widget_ != render_widget)
+    return;
+
+#if defined(ENABLE_PLUGINS)
+  if (focused_pepper_plugin_) {
+    focused_pepper_plugin_->render_frame()->OnImeSetComposition(
+        text, underlines, selection_start, selection_end);
+    return;
+  }
+#endif
+  AdjustReplacementRangeForAccentedCharacters(replacement_range);
+  render_widget_->HandleImeSetComposition(text, underlines, replacement_range,
+                                          selection_start, selection_end);
+}
+
+void RenderFrameImpl::OnImeConfirmComposition(
+    RenderWidget* render_widget,
+    const base::string16& text,
+    const gfx::Range& replacement_range,
+    bool keep_selection) {
+  if (render_widget_ != render_widget)
+    return;
+#if defined(ENABLE_PLUGINS)
+  if (focused_pepper_plugin_) {
+    focused_pepper_plugin_->render_frame()->OnImeConfirmComposition(
+        text, replacement_range, keep_selection);
+    return;
+  }
+#endif
+  AdjustReplacementRangeForAccentedCharacters(replacement_range);
+  render_widget_->HandleImeConfirmComposition(text, replacement_range,
+                                              keep_selection);
+}
+
 bool RenderFrameImpl::IsMainFrame() {
   return is_main_frame_;
 }
 
 bool RenderFrameImpl::IsHidden() {
   return GetRenderWidget()->is_hidden();
 }
 
 bool RenderFrameImpl::IsLocalRoot() const {
   bool is_local_root = static_cast<bool>(render_widget_);
@@ skipping 213 matching lines @@
   // allowImages(), allowPlugins() is called for the new page, so that when
   // these functions send a ViewHostMsg_ContentBlocked message, it arrives
   // after the FrameHostMsg_DidCommitProvisionalLoad message.
   Send(new FrameHostMsg_DidCommitProvisionalLoad(routing_id_, params));
 
   // If we end up reusing this WebRequest (for example, due to a #ref click),
   // we don't want the transition type to persist.  Just clear it.
   navigation_state->set_transition_type(ui::PAGE_TRANSITION_LINK);
 }
 
+void RenderFrameImpl::AdjustReplacementRangeForAccentedCharacters(
+    const gfx::Range& replacement_range) const {
+  if (!replacement_range.IsValid())
+    return;
+
+  if (WebLocalFrame* frame =
+          render_view_->webview()->focusedFrame()->toWebLocalFrame()) {
+    WebRange webrange = WebRange::fromDocumentRange(
+        frame, replacement_range.start(), replacement_range.length());
+    if (!webrange.isNull())
+      frame->selectRange(webrange);
+  }
+}
+
 void RenderFrameImpl::didStartLoading(bool to_different_document) {
   TRACE_EVENT1("navigation", "RenderFrameImpl::didStartLoading",
                "id", routing_id_);
   render_view_->FrameDidStartLoading(frame_);
 
   // PlzNavigate: the browser is responsible for knowing the start of all
   // non-synchronous navigations.
   if (!IsBrowserSideNavigationEnabled() || !to_different_document)
     Send(new FrameHostMsg_DidStartLoading(routing_id_, to_different_document));
 }
@@ skipping 1489 matching lines @@
         new FrameHostMsg_PepperInstanceDeleted(render_frame->GetRoutingID()));
 }
 
 void RenderFrameImpl::PepperFocusChanged(PepperPluginInstanceImpl* instance,
                                          bool focused) {
   if (focused)
     focused_pepper_plugin_ = instance;
   else if (focused_pepper_plugin_ == instance)
     focused_pepper_plugin_ = nullptr;
 
+  GetRenderWidget()->set_focused_pepper_plugin(focused_pepper_plugin_);
+
   GetRenderWidget()->UpdateTextInputState(ShowIme::HIDE_IME,
                                           ChangeSource::FROM_NON_IME);
   GetRenderWidget()->UpdateSelectionBounds();
 }
 
 #endif  // ENABLE_PLUGINS
 
 void RenderFrameImpl::RenderWidgetSetFocus(bool enable) {
 #if defined(ENABLE_PLUGINS)
   // Notify all Pepper plugins.
   for (auto* plugin : active_pepper_instances_)
     plugin->SetContentAreaFocus(enable);
 #endif
 }
 
 void RenderFrameImpl::RenderWidgetWillHandleMouseEvent() {
 #if defined(ENABLE_PLUGINS)
   // This method is called for every mouse event that the RenderWidget receives.
   // And then the mouse event is forwarded to blink, which dispatches it to the
   // event target. Potentially a Pepper plugin will receive the event.
   // In order to tell whether a plugin gets the last mouse event and which it
   // is, we set |pepper_last_mouse_event_target_| to null here. If a plugin gets
   // the event, it will notify us via DidReceiveMouseEvent() and set itself as
   // |pepper_last_mouse_event_target_|.
   pepper_last_mouse_event_target_ = nullptr;
 #endif
 }
 
 }  // namespace content