Factor out RenderWidgetHostConnector

content/browser/renderer_host/render_widget_host_view_android.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_android.h"
 
 #include <android/bitmap.h>
 
 #include <utility>
 
@@ skipping 25 matching lines @@
 #include "cc/surfaces/surface_factory.h"
 #include "cc/surfaces/surface_hittest.h"
 #include "cc/surfaces/surface_manager.h"
 #include "cc/trees/layer_tree_host.h"
 #include "components/display_compositor/gl_helper.h"
 #include "content/browser/accessibility/browser_accessibility_manager_android.h"
 #include "content/browser/android/composited_touch_handle_drawable.h"
 #include "content/browser/android/content_view_core_impl.h"
 #include "content/browser/android/ime_adapter_android.h"
 #include "content/browser/android/overscroll_controller_android.h"
+#include "content/browser/android/selection_popup_controller.h"
 #include "content/browser/android/synchronous_compositor_host.h"
 #include "content/browser/compositor/surface_utils.h"
 #include "content/browser/devtools/render_frame_devtools_agent_host.h"
 #include "content/browser/gpu/browser_gpu_channel_host_factory.h"
 #include "content/browser/gpu/compositor_util.h"
 #include "content/browser/gpu/gpu_data_manager_impl.h"
 #include "content/browser/gpu/gpu_process_host.h"
 #include "content/browser/media/android/media_web_contents_observer_android.h"
 #include "content/browser/renderer_host/compositor_impl_android.h"
 #include "content/browser/renderer_host/dip_util.h"
@@ skipping 696 matching lines @@
 void RenderWidgetHostViewAndroid::OnTextSelectionChanged(
     TextInputManager* text_input_manager,
     RenderWidgetHostViewBase* updated_view) {
   DCHECK_EQ(text_input_manager_, text_input_manager);
 
   // TODO(asimjour): remove the flag and fix text selection popup for
   // virtual reality mode.
   if (is_in_vr_)
     return;
 
-  if (!content_view_core_)
+  if (!selection_popup_controller_)
     return;
 
   RenderWidgetHostImpl* focused_widget = GetFocusedWidget();
   if (!focused_widget || !focused_widget->GetView())
     return;
 
   const TextInputManager::TextSelection& selection =
       *text_input_manager_->GetTextSelection(focused_widget->GetView());
 
-  content_view_core_->OnSelectionChanged(
+  selection_popup_controller_->OnSelectionChanged(
       base::UTF16ToUTF8(selection.selected_text()));
 }
 
 void RenderWidgetHostViewAndroid::UpdateBackgroundColor(SkColor color) {
   if (cached_background_color_ == color)
     return;
 
   cached_background_color_ = color;
 
   view_.OnBackgroundColorChanged(color);
@@ skipping 128 matching lines @@
 bool RenderWidgetHostViewAndroid::OnTouchEvent(
     const ui::MotionEvent& event) {
   if (!host_ || !host_->delegate())
     return false;
 
   ComputeEventLatencyOSTouchHistograms(event);
 
   // If a browser-based widget consumes the touch event, it's critical that
   // touch event interception be disabled. This avoids issues with
   // double-handling for embedder-detected gestures like side swipe.
-  if (selection_controller_ &&
-      selection_controller_->WillHandleTouchEvent(event)) {
+  if (touch_selection_controller_ &&
+      touch_selection_controller_->WillHandleTouchEvent(event)) {
     RequestDisallowInterceptTouchEvent();
     return true;
   }
 
   if (stylus_text_selector_.OnTouchEvent(event)) {
     RequestDisallowInterceptTouchEvent();
     return true;
   }
 
   ui::FilteredGestureProvider::TouchHandlingResult result =
@@ skipping 18 matching lines @@
   // that BeginFrame requests made during ACTION_MOVE dispatch will be honored
   // in the same vsync phase.
   if (observing_root_window_ && result.moved_beyond_slop_region)
     AddBeginFrameRequest(BEGIN_FRAME);
 
   return true;
 }
 
 bool RenderWidgetHostViewAndroid::OnTouchHandleEvent(
     const ui::MotionEvent& event) {
-  return selection_controller_ &&
-         selection_controller_->WillHandleTouchEvent(event);
+  return touch_selection_controller_ &&
+         touch_selection_controller_->WillHandleTouchEvent(event);
 }
 
 void RenderWidgetHostViewAndroid::ResetGestureDetection() {
   const ui::MotionEvent* current_down_event =
       gesture_provider_.GetCurrentDownEvent();
   if (!current_down_event) {
     // A hard reset ensures prevention of any timer-based events that might fire
     // after a touch sequence has ended.
     gesture_provider_.ResetDetection();
     return;
@@ skipping 290 matching lines @@
 
 void RenderWidgetHostViewAndroid::SelectBetweenCoordinates(
     const gfx::PointF& base,
     const gfx::PointF& extent) {
   DCHECK(content_view_core_);
   content_view_core_->SelectBetweenCoordinates(base, extent);
 }
 
 void RenderWidgetHostViewAndroid::OnSelectionEvent(
     ui::SelectionEventType event) {
-  DCHECK(content_view_core_);
-  DCHECK(selection_controller_);
+  DCHECK(touch_selection_controller_);
+  if (!selection_popup_controller_)
+    return;
   // If a selection drag has started, it has taken over the active touch
   // sequence. Immediately cancel gesture detection and any downstream touch
   // listeners (e.g., web content) to communicate this transfer.
   if (event == ui::SELECTION_HANDLES_SHOWN &&
       gesture_provider_.GetCurrentDownEvent()) {
     ResetGestureDetection();
   }
-  content_view_core_->OnSelectionEvent(
-      event, selection_controller_->GetStartPosition(),
-      GetSelectionRect(*selection_controller_));
+  selection_popup_controller_->OnSelectionEvent(
+      event, touch_selection_controller_->GetStartPosition(),
+      GetSelectionRect(*touch_selection_controller_));
 }
 
 std::unique_ptr<ui::TouchHandleDrawable>
 RenderWidgetHostViewAndroid::CreateDrawable() {
   DCHECK(content_view_core_);
   if (!using_browser_compositor_) {
     if (!sync_compositor_)
       return nullptr;
     return std::unique_ptr<ui::TouchHandleDrawable>(
         sync_compositor_->client()->CreateDrawable());
@@ skipping 50 matching lines @@
     bool is_transparent) {
   bool is_mobile_optimized = IsMobileOptimizedFrame(frame_metadata);
   gesture_provider_.SetDoubleTapSupportForPageEnabled(!is_mobile_optimized);
 
   if (!content_view_core_)
     return;
 
   if (overscroll_controller_)
     overscroll_controller_->OnFrameMetadataUpdated(frame_metadata);
 
-  if (selection_controller_) {
-    selection_controller_->OnSelectionBoundsChanged(
+  if (touch_selection_controller_) {
+    touch_selection_controller_->OnSelectionBoundsChanged(
         frame_metadata.selection.start, frame_metadata.selection.end);
 
     // Set parameters for adaptive handle orientation.
     gfx::SizeF viewport_size(frame_metadata.scrollable_viewport_size);
     viewport_size.Scale(frame_metadata.page_scale_factor);
     gfx::RectF viewport_rect(0.0f, frame_metadata.top_controls_height *
                                        frame_metadata.top_controls_shown_ratio,
                              viewport_size.width(), viewport_size.height());
-    selection_controller_->OnViewportChanged(viewport_rect);
+    touch_selection_controller_->OnViewportChanged(viewport_rect);
   }
 
   UpdateBackgroundColor(is_transparent ? SK_ColorTRANSPARENT
                                        : frame_metadata.root_background_color);
 
   view_.set_content_offset(gfx::Vector2dF(0.0f,
       frame_metadata.top_controls_height *
           frame_metadata.top_controls_shown_ratio));
 
   float dip_scale = view_.GetDipScale();
@@ skipping 188 matching lines @@
   if (sync_compositor_)
     sync_compositor_->DidSendBeginFrame(view_.GetWindowAndroid());
 }
 
 bool RenderWidgetHostViewAndroid::Animate(base::TimeTicks frame_time) {
   bool needs_animate = false;
   if (overscroll_controller_ && !is_in_vr_) {
     needs_animate |= overscroll_controller_->Animate(
         frame_time, content_view_core_->GetViewAndroid()->GetLayer());
   }
-  if (selection_controller_)
-    needs_animate |= selection_controller_->Animate(frame_time);
+  if (touch_selection_controller_)
+    needs_animate |= touch_selection_controller_->Animate(frame_time);
   return needs_animate;
 }
 
 void RenderWidgetHostViewAndroid::RequestDisallowInterceptTouchEvent() {
   if (content_view_core_)
     content_view_core_->RequestDisallowInterceptTouchEvent();
 }
 
 void RenderWidgetHostViewAndroid::EvictDelegatedFrame() {
   DestroyDelegatedContent();
@@ skipping 23 matching lines @@
     InputEventAckState ack_result) {
   if (overscroll_controller_)
     overscroll_controller_->OnGestureEventAck(event, ack_result);
 
   if (content_view_core_)
     content_view_core_->OnGestureEventAck(event, ack_result);
 }
 
 InputEventAckState RenderWidgetHostViewAndroid::FilterInputEvent(
     const blink::WebInputEvent& input_event) {
-  if (selection_controller_ &&
+  if (touch_selection_controller_ &&
       blink::WebInputEvent::isGestureEventType(input_event.type())) {
     const blink::WebGestureEvent& gesture_event =
         static_cast<const blink::WebGestureEvent&>(input_event);
     switch (gesture_event.type()) {
       case blink::WebInputEvent::GestureLongPress:
-        selection_controller_->HandleLongPressEvent(
+        touch_selection_controller_->HandleLongPressEvent(
             base::TimeTicks() +
-            base::TimeDelta::FromSecondsD(input_event.timeStampSeconds()),
+                base::TimeDelta::FromSecondsD(input_event.timeStampSeconds()),
             gfx::PointF(gesture_event.x, gesture_event.y));
         break;
 
       case blink::WebInputEvent::GestureTap:
-        selection_controller_->HandleTapEvent(
+        touch_selection_controller_->HandleTapEvent(
             gfx::PointF(gesture_event.x, gesture_event.y),
             gesture_event.data.tap.tapCount);
         break;
 
       case blink::WebInputEvent::GestureScrollBegin:
-        selection_controller_->OnScrollBeginEvent();
+        touch_selection_controller_->OnScrollBeginEvent();
         break;
 
       default:
         break;
     }
   }
 
   if (overscroll_controller_ &&
       blink::WebInputEvent::isGestureEventType(input_event.type()) &&
       overscroll_controller_->WillHandleGestureEvent(
@@ skipping 146 matching lines @@
     host_->MoveCaret(point);
 }
 
 void RenderWidgetHostViewAndroid::ShowContextMenuAtPoint(
     const gfx::Point& point) {
   if (host_)
     host_->ShowContextMenuAtPoint(point);
 }
 
 void RenderWidgetHostViewAndroid::DismissTextHandles() {
-  if (selection_controller_)
-    selection_controller_->HideAndDisallowShowingAutomatically();
+  if (touch_selection_controller_)
+    touch_selection_controller_->HideAndDisallowShowingAutomatically();
 }
 
 void RenderWidgetHostViewAndroid::SetTextHandlesTemporarilyHidden(bool hidden) {
-  if (selection_controller_)
-    selection_controller_->SetTemporarilyHidden(hidden);
+  if (touch_selection_controller_)
+    touch_selection_controller_->SetTemporarilyHidden(hidden);
 }
 
 SkColor RenderWidgetHostViewAndroid::GetCachedBackgroundColor() const {
   return cached_background_color_;
 }
 
 void RenderWidgetHostViewAndroid::SetIsInVR(bool is_in_vr) {
   is_in_vr_ = is_in_vr;
 }
 
@@ skipping 26 matching lines @@
 }
 
 void RenderWidgetHostViewAndroid::SetContentViewCore(
     ContentViewCoreImpl* content_view_core) {
   DCHECK(!content_view_core || !content_view_core_ ||
          (content_view_core_ == content_view_core));
   StopObservingRootWindow();
 
   bool resize = false;
   if (content_view_core != content_view_core_) {
-    selection_controller_.reset();
+    touch_selection_controller_.reset();
     RunAckCallbacks();
     // TODO(yusufo) : Get rid of the below conditions and have a better handling
     // for resizing after crbug.com/628302 is handled.
     bool is_size_initialized = !content_view_core
         || content_view_core->GetViewportSizeDip().width() != 0
         || content_view_core->GetViewportSizeDip().height() != 0;
     if (content_view_core_ || is_size_initialized)
       resize = true;
     if (content_view_core_) {
       content_view_core_->RemoveObserver(this);
@@ skipping 23 matching lines @@
     sync_compositor_.reset();
     return;
   }
 
   if (is_showing_ && view_.GetWindowAndroid())
     StartObservingRootWindow();
 
   if (resize)
     WasResized();
 
-  if (!selection_controller_)
-    selection_controller_ = CreateSelectionController(this, content_view_core_);
+  if (!touch_selection_controller_)
+    touch_selection_controller_ =
+        CreateSelectionController(this, content_view_core_);
 
   if (content_view_core_)
     CreateOverscrollControllerIfPossible();
 }
 
 void RenderWidgetHostViewAndroid::RunAckCallbacks() {
   while (!ack_callbacks_.empty()) {
     ack_callbacks_.front().Run();
     ack_callbacks_.pop();
   }
@@ skipping 251 matching lines @@
 
   ui::WindowAndroidCompositor* compositor = window_android->GetCompositor();
   if (!compositor)
     return;
 
   overscroll_controller_ = base::MakeUnique<OverscrollControllerAndroid>(
       overscroll_refresh_handler, compositor, view_.GetDipScale());
 }
 
 }  // namespace content