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/frame_host/touch_selection_controller_client_child_frame.h"
 #include "content/browser/gpu/compositor_util.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/content_switches_internal.h"

[kenrb, 2017/05/23 16:19:02]

Why is this include being added?

[wjmaclean, 2017/05/23 17:00:40]

Removed.

Let over from an earlier version of the CL.

 #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 34 matching lines @@
   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();
+
+    if (selection_controller_client_) {
+      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();
+    }
   }
   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

[kenrb, 2017/05/23 16:19:02]

This is surprising. Why wouldn't this be initialized to 1.0 in
RenderWidgetHostViewBase? That's the identity for multiplicative values,
initializing to 0 seems to be just asking for browser process crashes.

[wjmaclean, 2017/05/23 17:00:40]

I have no idea why it was initialized to zero, but it's been in the code for a
long time. I think it was assumed that some early call to GetScreenInfo() would
set this to it's correct value, but it's hard to do that here (e.g. we can get
here during the detach of an interstitial page, in which case calling
GetScreenInfo() can actually crash). But even if we initialize to 1.f in RWHVB,
we need to somehow get the actual DSF ... I've made the assumption here that if
our root view had a non-zero DSF value, then that would be safe for use here.

+      // 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 manarer on Aura (and eventually Android).

[kenrb, 2017/05/23 16:19:02]

nit: /s/manarer/manager
Also, I'd mark this specifically as a TODO for Android to make it easier to
remember to update the comment when Android TSE OOPIF support is implemented.

[wjmaclean, 2017/05/23 17:00:40]

Done.

+        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_);
+    selection_controller_client_.reset();

[kenrb, 2017/05/23 16:19:02]

I'm trying to understand this. UnregisterFrameSinkId() is only called from the
derived class, RWHVGuest, as a way to disconnect the input routing path when the
Guest is detached. Is this path intended to be active for non-OOPIF GuestView?
If so, how does the observer get cleared from the manager?

[wjmaclean, 2017/05/23 17:00:40]

Hmm, good question. TSE has never worked in GuestView before now, although it
appears to work now for non-oopif (unplanned) as well as oopif cases. So this
patway should be supported.

Thanks for noticing the lack of detaching the observer ... I've fixed that.

   }
 }
 
 void RenderWidgetHostViewChildFrame::UpdateViewportIntersection(
     const gfx::Rect& viewport_intersection) {
   if (host_)
     host_->Send(new ViewMsg_SetViewportIntersection(host_->GetRoutingID(),
                                                     viewport_intersection));
 }
 
@@ skipping 38 matching lines @@
   current_surface_scale_factor_ = frame.metadata.device_scale_factor;
 
   support_->SubmitCompositorFrame(local_surface_id, std::move(frame));
   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 325 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())
+    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