Separate SwipeRefreshHandler and ContentViewCore

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 37 matching lines @@
 #include "content/browser/gpu/gpu_data_manager_impl.h"
 #include "content/browser/gpu/gpu_process_host_ui_shim.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"
 #include "content/browser/renderer_host/frame_metadata_util.h"
 #include "content/browser/renderer_host/input/input_router_impl.h"
 #include "content/browser/renderer_host/input/synthetic_gesture_target_android.h"
 #include "content/browser/renderer_host/input/web_input_event_builders_android.h"
 #include "content/browser/renderer_host/render_process_host_impl.h"
+#include "content/browser/renderer_host/render_view_host_delegate_view.h"
 #include "content/browser/renderer_host/render_view_host_impl.h"
 #include "content/browser/renderer_host/render_widget_host_impl.h"
 #include "content/common/gpu_host_messages.h"
 #include "content/common/input_messages.h"
 #include "content/common/view_messages.h"
 #include "content/public/browser/android/compositor.h"
 #include "content/public/browser/android/synchronous_compositor_client.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/devtools_agent_host.h"
 #include "content/public/browser/render_view_host.h"
@@ skipping 261 matching lines @@
   config.tap_slop = gfx::ViewConfiguration::GetTouchSlopInDips();
   config.enable_adaptive_handle_orientation =
       base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kEnableAdaptiveSelectionHandleOrientation);
   config.enable_longpress_drag_selection =
       base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kEnableLongpressDragSelection);
   return base::MakeUnique<ui::TouchSelectionController>(client, config);
 }
 
-std::unique_ptr<OverscrollControllerAndroid> CreateOverscrollController(
-    ContentViewCoreImpl* content_view_core,
-    float dpi_scale) {
-  return base::MakeUnique<OverscrollControllerAndroid>(content_view_core,
-                                                       dpi_scale);
-}
-
 gfx::RectF GetSelectionRect(const ui::TouchSelectionController& controller) {
   gfx::RectF rect = controller.GetRectBetweenBounds();
   if (rect.IsEmpty())
     return rect;
 
   rect.Union(controller.GetStartHandleRect());
   rect.Union(controller.GetEndHandleRect());
   return rect;
 }
 
@@ skipping 106 matching lines @@
   if (using_browser_compositor_) {
     delegated_frame_host_.reset(new ui::DelegatedFrameHostAndroid(
         &view_, cached_background_color_,
         base::Bind(&RenderWidgetHostViewAndroid::ReturnResources,
                    weak_ptr_factory_.GetWeakPtr())));
   }
 
   host_->SetView(this);
   SetContentViewCore(content_view_core);
 
+  CreateOverscrollControllerIfPossible();
+
   if (GetTextInputManager())
     GetTextInputManager()->AddObserver(this);
 }
 
 RenderWidgetHostViewAndroid::~RenderWidgetHostViewAndroid() {
   if (content_view_core_)
     content_view_core_->RemoveObserver(this);
   SetContentViewCore(NULL);
   DCHECK(ack_callbacks_.empty());
   DCHECK(!delegated_frame_host_);
@@ skipping 731 matching lines @@
 }
 
 void RenderWidgetHostViewAndroid::SetSynchronousCompositorClient(
       SynchronousCompositorClient* client) {
   synchronous_compositor_client_ = client;
   if (!sync_compositor_ && synchronous_compositor_client_) {
     sync_compositor_ = SynchronousCompositorHost::Create(this);
   }
 }
 
+void RenderWidgetHostViewAndroid::OnOverscrollRefreshHandlerSet() {
+  DCHECK(!overscroll_controller_);
+  CreateOverscrollControllerIfPossible();
+}
+
 bool RenderWidgetHostViewAndroid::SupportsAnimation() const {
   // The synchronous (WebView) compositor does not have a proper browser
   // compositor with which to drive animations.
   return using_browser_compositor_;
 }
 
 void RenderWidgetHostViewAndroid::SetNeedsAnimate() {
   DCHECK(view_.GetWindowAndroid());
   DCHECK(using_browser_compositor_);
   view_.GetWindowAndroid()->SetNeedsAnimate();
@@ skipping 528 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_) {
-    overscroll_controller_.reset();
     selection_controller_.reset();
     ReleaseLocksOnSurface();
     // 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_) {
@@ skipping 26 matching lines @@
   }
 
   if (is_showing_)
     StartObservingRootWindow();
 
   if (resize)
     WasResized();
 
   if (!selection_controller_)
     selection_controller_ = CreateSelectionController(this, content_view_core_);
-
-  if (!overscroll_controller_ &&
-      view_.GetWindowAndroid()->GetCompositor()) {
-    overscroll_controller_ = CreateOverscrollController(
-        content_view_core_, ui::GetScaleFactorForNativeView(GetNativeView()));
-  }
 }
 
 void RenderWidgetHostViewAndroid::RunAckCallbacks() {
   while (!ack_callbacks_.empty()) {
     ack_callbacks_.front().Run();
     ack_callbacks_.pop();
   }
 }
 
 void RenderWidgetHostViewAndroid::OnGestureEvent(
     const ui::GestureEventData& gesture) {
   blink::WebGestureEvent web_gesture =
       ui::CreateWebGestureEventFromGestureEventData(gesture);
   // TODO(jdduke): Remove this workaround after Android fixes UiAutomator to
   // stop providing shift meta values to synthetic MotionEvents. This prevents
   // unintended shift+click interpretation of all accessibility clicks.
   // See crbug.com/443247.
   if (web_gesture.type == blink::WebInputEvent::GestureTap &&
       web_gesture.modifiers == blink::WebInputEvent::ShiftKey) {
     web_gesture.modifiers = 0;
   }
   SendGestureEvent(web_gesture);
 }
 
 void RenderWidgetHostViewAndroid::OnContentViewCoreDestroyed() {
   SetContentViewCore(NULL);
+  overscroll_controller_.reset();
 }
 
 void RenderWidgetHostViewAndroid::OnCompositingDidCommit() {
   RunAckCallbacks();
 }
 
 void RenderWidgetHostViewAndroid::OnRootWindowVisibilityChanged(bool visible) {
   TRACE_EVENT1("browser",
                "RenderWidgetHostViewAndroid::OnRootWindowVisibilityChanged",
                "visible", visible);
@@ skipping 17 matching lines @@
     OnAttachCompositor();
 }
 
 void RenderWidgetHostViewAndroid::OnDetachedFromWindow() {
   StopObservingRootWindow();
   OnDetachCompositor();
 }
 
 void RenderWidgetHostViewAndroid::OnAttachCompositor() {
   DCHECK(content_view_core_);
-  if (!overscroll_controller_)
-    overscroll_controller_ = CreateOverscrollController(
-        content_view_core_, ui::GetScaleFactorForNativeView(GetNativeView()));
+  CreateOverscrollControllerIfPossible();
   ui::WindowAndroidCompositor* compositor =
       view_.GetWindowAndroid()->GetCompositor();
   delegated_frame_host_->RegisterFrameSinkHierarchy(
       compositor->GetFrameSinkId());
 }
 
 void RenderWidgetHostViewAndroid::OnDetachCompositor() {
   DCHECK(content_view_core_);
   DCHECK(using_browser_compositor_);
   RunAckCallbacks();
@@ skipping 93 matching lines @@
       return;
     case ui::MotionEvent::ACTION_UP:
     case ui::MotionEvent::ACTION_POINTER_UP:
       UMA_HISTOGRAM_CUSTOM_COUNTS("Event.Latency.OS.TOUCH_RELEASED",
                                   delta.InMicroseconds(), 1, 1000000, 50);
     default:
       return;
   }
 }
 
+void RenderWidgetHostViewAndroid::CreateOverscrollControllerIfPossible() {

[boliu, 2016/12/07 21:05:51]

also should call this in SetCVC when CVC is not null, matters for the case when
the compositor has already been created when SetCVC is called

[rlanday, 2016/12/07 22:13:39]

Ok

+  // an OverscrollController is already set
+  if (overscroll_controller_)
+    return;
+
+  RenderWidgetHostDelegate* delegate = host_->delegate();
+  if (!delegate)
+    return;
+
+  RenderViewHostDelegateView* delegate_view = delegate->GetDelegateView();
+  // render_widget_host_unittest.cc uses an object called
+  // MockRenderWidgetHostDelegate that does not have a DelegateView
+  if (!delegate_view)
+    return;
+
+  ui::OverscrollRefreshHandler* overscroll_refresh_handler =
+      delegate_view->GetOverscrollRefreshHandler();
+  if (!overscroll_refresh_handler)
+    return;
+
+  if (!content_view_core_)
+    return;
+
+  ui::WindowAndroid* window_android = content_view_core_->GetWindowAndroid();
+  if (!window_android)

[boliu, 2016/12/07 21:05:52]

this one can't happen

[rlanday, 2016/12/07 22:13:39]

Oh, I saw all the "if (GetWindowAndroid())" checks in ContentViewCoreImpl and
thought this might be necessary

[boliu, 2016/12/08 01:05:01]

Ohh, you are right. This can be null due to tab re-parenting, which is a user
action. But if we ever hit it here, we'd actually leave things in a bad state,
since we don't listen for WindowAndroid changing here.

Keep this check for now, with a comment to fix this edge case when we get
WindowAndroid from ViewAndroid..

+    return;
+
+  ui::WindowAndroidCompositor* compositor = window_android->GetCompositor();
+  if (!compositor)
+    return;
+
+  overscroll_controller_ = base::MakeUnique<OverscrollControllerAndroid>(
+      overscroll_refresh_handler,
+      compositor, ui::GetScaleFactorForNativeView(GetNativeView()));
+}
+
 }  // namespace content