Implement TouchSelectionEditing controls for OOPIF.

content/browser/frame_host/render_widget_host_view_child_frame.cc

 // Copyright 2014 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/frame_host/render_widget_host_view_child_frame.h"
 
 #include <algorithm>
 #include <utility>
 #include <vector>
 
 #include "base/location.h"
 #include "base/memory/ptr_util.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "build/build_config.h"
 #include "cc/output/copy_output_request.h"
 #include "cc/output/copy_output_result.h"
 #include "cc/surfaces/compositor_frame_sink_support.h"
 #include "cc/surfaces/surface.h"
 #include "cc/surfaces/surface_manager.h"
 #include "content/browser/accessibility/browser_accessibility_manager.h"
 #include "content/browser/browser_plugin/browser_plugin_guest.h"
 #include "content/browser/compositor/surface_utils.h"
 #include "content/browser/frame_host/cross_process_frame_connector.h"
 #include "content/browser/gpu/compositor_util.h"
+#include "content/browser/renderer_host/input/touch_selection_controller_client_child_frame.h"
 #include "content/browser/renderer_host/render_view_host_impl.h"
 #include "content/browser/renderer_host/render_widget_host_delegate.h"
 #include "content/browser/renderer_host/render_widget_host_impl.h"
 #include "content/browser/renderer_host/render_widget_host_input_event_router.h"
+#include "content/browser/renderer_host/render_widget_host_view_event_handler.h"
+#include "content/browser/renderer_host/text_input_manager.h"
 #include "content/common/text_input_state.h"
 #include "content/common/view_messages.h"
 #include "content/public/browser/guest_mode.h"
 #include "content/public/browser/render_process_host.h"
 #include "gpu/ipc/common/gpu_messages.h"
 #include "third_party/WebKit/public/platform/WebTouchEvent.h"
 #include "ui/gfx/geometry/size_conversions.h"
 #include "ui/gfx/geometry/size_f.h"
+#include "ui/touch_selection/touch_selection_controller.h"
 
 namespace content {
 
 // static
 RenderWidgetHostViewChildFrame* RenderWidgetHostViewChildFrame::Create(
     RenderWidgetHost* widget) {
   RenderWidgetHostViewChildFrame* view =
       new RenderWidgetHostViewChildFrame(widget);
   view->Init();
   return view;
@@ skipping 19 matching lines @@
   if (GetSurfaceManager())
     GetSurfaceManager()->InvalidateFrameSinkId(frame_sink_id_);
 }
 
 void RenderWidgetHostViewChildFrame::Init() {
   RegisterFrameSinkId();
   host_->SetView(this);
   GetTextInputManager();
 }
 
+void RenderWidgetHostViewChildFrame::
+    DetachFromTouchSelectionClientManagerIfNecessary() {
+  if (!selection_controller_client_)
+    return;
+
+  auto* root_view = frame_connector_->GetRootRenderWidgetHostView();
+  if (root_view) {
+    auto* manager = root_view->touch_selection_controller_client_manager();
+    if (manager)
+      manager->RemoveObserver(this);
+  }
+
+  selection_controller_client_.reset();
+}
+
 void RenderWidgetHostViewChildFrame::SetCrossProcessFrameConnector(
     CrossProcessFrameConnector* frame_connector) {
   if (frame_connector_ == frame_connector)
     return;
 
   if (frame_connector_) {
     if (parent_frame_sink_id_.is_valid()) {
       GetSurfaceManager()->UnregisterFrameSinkHierarchy(parent_frame_sink_id_,
                                                         frame_sink_id_);
     }
     parent_frame_sink_id_ = cc::FrameSinkId();
     local_surface_id_ = cc::LocalSurfaceId();
 
     // Unlocks the mouse if this RenderWidgetHostView holds the lock.
     UnlockMouse();
+    DetachFromTouchSelectionClientManagerIfNecessary();
   }
   frame_connector_ = frame_connector;
   if (frame_connector_) {
     RenderWidgetHostViewBase* parent_view =
         frame_connector_->GetParentRenderWidgetHostView();
     if (parent_view) {
       parent_frame_sink_id_ = parent_view->GetFrameSinkId();
       DCHECK(parent_frame_sink_id_.is_valid());
       GetSurfaceManager()->RegisterFrameSinkHierarchy(parent_frame_sink_id_,
                                                       frame_sink_id_);
     }
+
+    auto* root_view = frame_connector_->GetRootRenderWidgetHostView();
+    if (root_view) {
+      // Make sure we're not using the zero-valued default for
+      // current_device_scale_factor_.
+      current_device_scale_factor_ = root_view->current_device_scale_factor();
+      if (current_device_scale_factor_ == 0.f)
+        current_device_scale_factor_ = 1.f;
+
+      auto* manager = root_view->touch_selection_controller_client_manager();
+      if (manager) {
+        // We will only have a manager on Aura (and eventually Android).
+        // TODO(wjmaclean): update this comment when TSE OOPIF support becomes
+        // available on Android.
+        selection_controller_client_ =
+            base::MakeUnique<TouchSelectionControllerClientChildFrame>(this,
+                                                                       manager);
+        manager->AddObserver(this);
+      }
+    }
   }
 }
 
+void RenderWidgetHostViewChildFrame::OnManagerWillDestroy(
+    TouchSelectionControllerClientManager* manager) {
+  // We get the manager via the observer callback instead of through the
+  // frame_connector_ since our connection to the root_view may disappear by
+  // the time this function is called, but before frame_connector_ is reset.
+  manager->RemoveObserver(this);
+  selection_controller_client_.reset();
+}
+
 void RenderWidgetHostViewChildFrame::InitAsChild(
     gfx::NativeView parent_view) {
   NOTREACHED();
 }
 
 RenderWidgetHost* RenderWidgetHostViewChildFrame::GetRenderWidgetHost() const {
   return host_;
 }
 
 void RenderWidgetHostViewChildFrame::SetSize(const gfx::Size& size) {
@@ skipping 195 matching lines @@
     if (!router->is_registered(frame_sink_id_))
       router->AddFrameSinkIdOwner(frame_sink_id_, this);
   }
 }
 
 void RenderWidgetHostViewChildFrame::UnregisterFrameSinkId() {
   DCHECK(host_);
   if (host_->delegate() && host_->delegate()->GetInputEventRouter()) {
     host_->delegate()->GetInputEventRouter()->RemoveFrameSinkIdOwner(
         frame_sink_id_);
+    DetachFromTouchSelectionClientManagerIfNecessary();
   }
 }
 
 void RenderWidgetHostViewChildFrame::UpdateViewportIntersection(
     const gfx::Rect& viewport_intersection) {
   if (host_)
     host_->Send(new ViewMsg_SetViewportIntersection(host_->GetRoutingID(),
                                                     viewport_intersection));
 }
 
@@ skipping 40 matching lines @@
   bool result =
       support_->SubmitCompositorFrame(local_surface_id, std::move(frame));
   DCHECK(result);
   has_frame_ = true;
 
   if (local_surface_id_ != local_surface_id || HasEmbedderChanged()) {
     local_surface_id_ = local_surface_id;
     SendSurfaceInfoToEmbedder();
   }
 
+  if (selection_controller_client_) {
+    selection_controller_client_->UpdateSelectionBoundsIfNeeded(
+        frame.metadata.selection, current_device_scale_factor_);
+  }
+
   ProcessFrameSwappedCallbacks();
 }
 
 void RenderWidgetHostViewChildFrame::SendSurfaceInfoToEmbedder() {
   cc::SurfaceSequence sequence =
       cc::SurfaceSequence(frame_sink_id_, next_surface_sequence_++);
   cc::SurfaceManager* manager = GetSurfaceManager();
   cc::SurfaceId surface_id(frame_sink_id_, local_surface_id_);
   // The renderer process will satisfy this dependency when it creates a
   // SurfaceLayer.
@@ skipping 334 matching lines @@
     GetSurfaceManager()->UnregisterFrameSinkHierarchy(parent_frame_sink_id_,
                                                       frame_sink_id_);
   }
   support_.reset();
 }
 
 bool RenderWidgetHostViewChildFrame::HasEmbedderChanged() {
   return false;
 }
 
+bool RenderWidgetHostViewChildFrame::GetSelectionRange(
+    gfx::Range* range) const {
+  if (!text_input_manager_ || !GetFocusedWidget())

[EhsanK, 2017/05/29 15:41:45]

Just a comment that came to my mind when I was reading this part of code to work
on https://crbug.com/714771:

RenderWidgetHostViewBase::GetFocusedWidget() uses
RenderWidgetHostDelegate::GetFocusedRenderWidgetHost() on its own
RenderWidgetHost (not that of the page).

Therefore, when render_widget_host_ && render_widget_host_->delegate() exist,
GetFocusedWidget() always returns the |render_widget_host_|.

Having said this, I believe this should change to |render_widget_host_| here and
we should only pass |this| to TextInputManager::GetTextSelection().

If the intention is to look for focused RenderWidgetHostView in page then we
should use
render_widget_host_->delegate()->GetFocusedRenderWidgetHost(RenderWidgetHostImpl::From(
frame_connector_->GetRootRenderWidgetHostView()->GetRenderWidgetHost()));

[wjmaclean, 2017/05/29 16:39:06]

Good to know ... I'll try this out, and revise it to match what you suggest in a
new CL. I don't know if it will help with the bug, but we'll see what happens.

+    return false;
+
+  const TextInputManager::TextSelection* selection =
+      text_input_manager_->GetTextSelection(GetFocusedWidget()->GetView());
+  if (!selection)
+    return false;
+
+  range->set_start(selection->range().start());
+  range->set_end(selection->range().end());
+
+  return true;
+}
+
+ui::TextInputType RenderWidgetHostViewChildFrame::GetTextInputType() const {
+  if (!text_input_manager_)
+    return ui::TEXT_INPUT_TYPE_NONE;
+
+  if (text_input_manager_->GetTextInputState())
+    return text_input_manager_->GetTextInputState()->type;
+  return ui::TEXT_INPUT_TYPE_NONE;
+}
+
+gfx::Point RenderWidgetHostViewChildFrame::GetViewOriginInRoot() const {
+  if (frame_connector_) {
+    auto origin = GetViewBounds().origin() -
+                  frame_connector_->GetRootRenderWidgetHostView()
+                      ->GetViewBounds()
+                      .origin();
+    return gfx::Point(origin.x(), origin.y());
+  }
+  return gfx::Point();
+}
+
 }  // namespace content