Browser Side Text Input State Tracking for OOPIF.

content/browser/renderer_host/render_widget_host_view_base.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/browser/renderer_host/render_widget_host_view_base.h"
 
 #include "base/logging.h"
 #include "build/build_config.h"
 #include "content/browser/accessibility/browser_accessibility_manager.h"
+#include "content/browser/frame_host/frame_tree.h"
 #include "content/browser/gpu/gpu_data_manager_impl.h"
 #include "content/browser/renderer_host/input/synthetic_gesture_target_base.h"
 #include "content/browser/renderer_host/render_process_host_impl.h"
+#include "content/browser/renderer_host/render_view_host_delegate.h"
+#include "content/browser/renderer_host/render_view_host_impl.h"
 #include "content/browser/renderer_host/render_widget_host_impl.h"
 #include "content/common/content_switches_internal.h"
+#include "content/common/view_messages.h"
 #include "content/public/browser/render_widget_host_view_frame_subscriber.h"
+#include "content/public/common/browser_plugin_guest_mode.h"
 #include "ui/gfx/display.h"
 #include "ui/gfx/geometry/point_conversions.h"
 #include "ui/gfx/geometry/size_conversions.h"
 #include "ui/gfx/geometry/size_f.h"
 #include "ui/gfx/screen.h"
 
 #if defined(OS_WIN)
 #include "base/command_line.h"
 #include "base/message_loop/message_loop.h"
 #include "base/win/wrapped_window_proc.h"
@@ skipping 344 matching lines @@
     : popup_type_(blink::WebPopupTypeNone),
       background_color_(SK_ColorWHITE),
       mouse_locked_(false),
       showing_context_menu_(false),
       selection_text_offset_(0),
       selection_range_(gfx::Range::InvalidRange()),
       current_device_scale_factor_(0),
       current_display_rotation_(gfx::Display::ROTATE_0),
       pinch_zoom_enabled_(content::IsPinchToZoomEnabled()),
       renderer_frame_number_(0),
+      text_input_state_(new TextInputState),
+      cached_text_input_state_(text_input_state_.get()),
+      focused_guest_rwhv_(nullptr),
       weak_factory_(this) {
+  text_input_state_->can_compose_inline = true;
 }
 
 RenderWidgetHostViewBase::~RenderWidgetHostViewBase() {
   DCHECK(!mouse_locked_);
 }
 
 bool RenderWidgetHostViewBase::OnMessageReceived(const IPC::Message& msg){
   return false;
 }
 
@@ skipping 149 matching lines @@
       current_display_rotation_ == display.rotation()) {
     return false;
   }
 
   current_display_area_ = display.work_area();
   current_device_scale_factor_ = display.device_scale_factor();
   current_display_rotation_ = display.rotation();
   return true;
 }
 
+RenderFrameHostImpl* RenderWidgetHostViewBase::GetFocusedFrame() const {
+  RenderViewHost* rvh =
+      RenderViewHost::From(RenderWidgetHostImpl::From(GetRenderWidgetHost()));
+  if (!rvh)
+    return nullptr;
+
+  FrameTreeNode* focused_frame =
+      rvh->GetDelegate()->GetFrameTree()->GetFocusedFrame();
+  if (!focused_frame)
+    return nullptr;
+
+  return focused_frame->current_frame_host();
+}
+
 base::WeakPtr<RenderWidgetHostViewBase> RenderWidgetHostViewBase::GetWeakPtr() {
   return weak_factory_.GetWeakPtr();
 }
 
 scoped_ptr<SyntheticGestureTarget>
 RenderWidgetHostViewBase::CreateSyntheticGestureTarget() {
   RenderWidgetHostImpl* host =
       RenderWidgetHostImpl::From(GetRenderWidgetHost());
   return scoped_ptr<SyntheticGestureTarget>(
       new SyntheticGestureTargetBase(host));
@@ skipping 134 matching lines @@
       gfx::ToRoundedPoint(point)));
 }
 
 void RenderWidgetHostViewBase::TransformPointToLocalCoordSpace(
     const gfx::Point& point,
     cc::SurfaceId original_surface,
     gfx::Point* transformed_point) {
   *transformed_point = point;
 }
 
+void RenderWidgetHostViewBase::TextInputStateChanged(
+    const ViewHostMsg_TextInputState_Params& params) {
+  if (text_input_state_->type != params.type ||
+#ifndef OS_MACOSX
+      text_input_state_->mode != params.mode ||
+      text_input_state_->flags != params.flags ||
+#endif
+      text_input_state_->can_compose_inline != params.can_compose_inline) {
+    *text_input_state_ = params;
+    NotifyTextInputStateChanged();
+  }
+}
+
+const TextInputState* RenderWidgetHostViewBase::FindCurrentTextInputState() {
+  if (!ShouldObtainTextInputStateFromSubFrameViews())

[kenrb, 2016/02/01 20:12:43]

Why is this needed? Can't you just compare GetFocusedFrame()->GetView() to
|this| and recurse on GetFocusedFrame() if they are different? Or is this method
only required because of the BrowserPlugin alternate code path?

[EhsanK, 2016/02/12 15:46:59]

Good point! I removed this part and all other code related to Non-OOPIF
<webview> which were introduced to fix crbug.com/546645. I will deal with that
later.

I also renamed the NotifyText... to UpdateText..

+    return text_input_state_.get();
+
+  // TODO(ekaramad): This is for out of process contents based on BrowserPlugin.
+  // Remove this block when BrowserPlugin is removed.
+  if (!BrowserPluginGuestMode::UseCrossProcessFramesForGuests())
+    if (focused_guest_rwhv_)
+      return focused_guest_rwhv_->current_text_input_state();
+
+  const TextInputState* state = text_input_state_.get();
+  RenderFrameHostImpl* rfhi = GetFocusedFrame();
+  // TODO(ekaramd): Remove the RVH part when it goes away.
+  if (rfhi) {
+    RenderWidgetHostViewBase* focused_view = nullptr;
+    if (rfhi->GetRenderWidgetHost())
+      focused_view = rfhi->GetRenderWidgetHost()->GetView();
+    else if (rfhi->GetRenderViewHost())
+      focused_view =
+          RenderWidgetHostImpl::From(rfhi->GetRenderViewHost()->GetWidget())
+              ->GetView();
+    if (focused_view && focused_view != this) {
+      DCHECK(!focused_view->ShouldObtainTextInputStateFromSubFrameViews());
+      state = focused_view->FindCurrentTextInputState();
+    }
+  }
+  return state;
+}
+
+void RenderWidgetHostViewBase::NotifyGuestTextInputStateChanged(
+    RenderWidgetHostViewBase* guest_rwhv) {
+  if (guest_rwhv->current_text_input_state()->type != ui::TEXT_INPUT_TYPE_NONE)
+    focused_guest_rwhv_ = guest_rwhv;
+  else if (focused_guest_rwhv_ == guest_rwhv)
+    focused_guest_rwhv_ = nullptr;
+  NotifyTextInputStateChanged();
+}
+
+void RenderWidgetHostViewBase::NotifyTextInputStateChanged() {

[kenrb, 2016/02/01 20:12:43]

Does this need to be called when the focused frame changes?

[EhsanK, 2016/02/12 15:46:59]

This is called whenever after a ViewHostMsg_TextInputStateChanged, which is
either:
1- An input on the same frame,
2- An input on a child frame, which in turn called this (top-level) RWHV.

The text input IPC is tied with focus, I believe it is sent just after the focus
related IPC. However, if the input fields are within the same frame, then there
is no focus IPC.

On a related note, there was a way to not use this method and keep overriding
the TextInputStateChanged for all RWHV*. However, in such a case we would not be
informed of a state change in a child frame and hence, everytime there was a
need to the state (e.g., at the Aura) we had to search for the focused frame.
Now by notifying and caching the last state we only search for focused frame
when there is a change.

+  cached_text_input_state_ = FindCurrentTextInputState();
+}
+
+bool RenderWidgetHostViewBase::ShouldObtainTextInputStateFromSubFrameViews()
+const {
+  return true;
+}
+
 }  // namespace content