Use scroll-boundary-behavior to control overscroll-refresh/glow on android.

content/browser/android/overscroll_controller_android.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/android/overscroll_controller_android.h"
 
 #include "base/android/build_info.h"
 #include "base/command_line.h"
 #include "base/memory/ptr_util.h"
 #include "cc/layers/layer.h"
@@ skipping 77 matching lines @@
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kDisablePullToRefreshEffect)) {
     return nullptr;
   }
 
   return base::MakeUnique<OverscrollRefresh>(overscroll_refresh_handler);
 }
 
 }  // namespace
 
 OverscrollControllerAndroid::OverscrollControllerAndroid(

[boliu, 2017/08/23 19:17:02]

this is only for tests right? Make that clear by making a static factory method
CreateForTests instead

[sunyunjia, 2017/08/23 23:47:05]

Done.

+    ui::WindowAndroidCompositor* compositor,
+    float dpi_scale,
+    std::unique_ptr<ui::OverscrollGlow> glow_effect,
+    std::unique_ptr<ui::OverscrollRefresh> refresh_effect)
+    : compositor_(compositor),
+      dpi_scale_(dpi_scale),
+      enabled_(true),
+      glow_effect_(std::move(glow_effect)),
+      refresh_effect_(std::move(refresh_effect)) {}
+
+OverscrollControllerAndroid::OverscrollControllerAndroid(
     ui::OverscrollRefreshHandler* overscroll_refresh_handler,
     ui::WindowAndroidCompositor* compositor,
     float dpi_scale)
-    : compositor_(compositor),
-      dpi_scale_(dpi_scale),
-      enabled_(true),
-      glow_effect_(CreateGlowEffect(this, dpi_scale_)),
-      refresh_effect_(CreateRefreshEffect(overscroll_refresh_handler)) {
-  DCHECK(compositor_);

[boliu, 2017/08/23 19:17:02]

ditto don't remove production checks

[sunyunjia, 2017/08/23 23:47:05]

Done.

-}
+    : OverscrollControllerAndroid(
+          compositor,
+          dpi_scale,
+          CreateGlowEffect(this, dpi_scale),
+          CreateRefreshEffect(overscroll_refresh_handler)) {}
 
 OverscrollControllerAndroid::~OverscrollControllerAndroid() {
 }
 
 bool OverscrollControllerAndroid::WillHandleGestureEvent(
     const blink::WebGestureEvent& event) {
   if (!enabled_)
     return false;
 
   if (!refresh_effect_)
@@ skipping 63 matching lines @@
   // sent from the renderer compositor.
   if (event.GetType() == blink::WebInputEvent::kGestureScrollEnd ||
       event.GetType() == blink::WebInputEvent::kGestureFlingStart) {
     OnOverscrolled(DidOverscrollParams());
   }
 
   if (event.GetType() == blink::WebInputEvent::kGestureScrollUpdate &&
       refresh_effect_) {
     // The effect should only be allowed if both the causal touch events go
     // unconsumed and the generated scroll events go unconsumed.
-    bool consumed =
-        ack_result == INPUT_EVENT_ACK_STATE_CONSUMED ||
-        event.data.scroll_update.previous_update_in_sequence_prevented;
-    refresh_effect_->OnScrollUpdateAck(consumed);
+    if (ack_result == INPUT_EVENT_ACK_STATE_CONSUMED ||
+        event.data.scroll_update.previous_update_in_sequence_prevented)

[boliu, 2017/08/23 19:17:02]

style nit: need braces

[sunyunjia, 2017/08/23 23:47:05]

Done.

+      refresh_effect_->Reset();
   }
 }
 
 void OverscrollControllerAndroid::OnOverscrolled(
     const DidOverscrollParams& params) {
   if (!enabled_)
     return;
 
-  if (refresh_effect_ && (refresh_effect_->IsActive() ||
-                          refresh_effect_->IsAwaitingScrollUpdateAck())) {
-    // An active (or potentially active) refresh effect should always pre-empt
-    // the passive glow effect.
-    return;
+  if (refresh_effect_) {
+    if (params.scroll_boundary_behavior.y !=
+        cc::ScrollBoundaryBehavior::ScrollBoundaryBehaviorType::
+            kScrollBoundaryBehaviorTypeAuto)
+      refresh_effect_->Reset();
+    else
+      refresh_effect_->OnOverscrolled();
+
+    if (refresh_effect_->IsActive() ||
+        refresh_effect_->IsAwaitingScrollUpdateAck()) {
+      // An active (or potentially active) refresh effect should always pre-empt
+      // the passive glow effect.
+      return;
+    }
   }
 
-  if (glow_effect_ &&
-      glow_effect_->OnOverscrolled(
-          base::TimeTicks::Now(),
-          gfx::ScaleVector2d(params.accumulated_overscroll, dpi_scale_),
-          gfx::ScaleVector2d(params.latest_overscroll_delta, dpi_scale_),
-          gfx::ScaleVector2d(params.current_fling_velocity, dpi_scale_),
-          gfx::ScaleVector2d(
-              params.causal_event_viewport_point.OffsetFromOrigin(),
-              dpi_scale_))) {
+  gfx::Vector2dF accumulated_overscroll =
+      gfx::ScaleVector2d(params.accumulated_overscroll, dpi_scale_);
+  gfx::Vector2dF latest_overscroll_delta =
+      gfx::ScaleVector2d(params.latest_overscroll_delta, dpi_scale_);
+  gfx::Vector2dF current_fling_velocity =
+      gfx::ScaleVector2d(params.current_fling_velocity, dpi_scale_);
+  gfx::Vector2dF overscroll_location = gfx::ScaleVector2d(
+      params.causal_event_viewport_point.OffsetFromOrigin(), dpi_scale_);
+
+  if (params.scroll_boundary_behavior.x ==
+      cc::ScrollBoundaryBehavior::ScrollBoundaryBehaviorType::
+          kScrollBoundaryBehaviorTypeNone) {
+    accumulated_overscroll.set_x(0);
+    latest_overscroll_delta.set_x(0);
+    current_fling_velocity.set_x(0);
+  }
+
+  if (params.scroll_boundary_behavior.y ==
+      cc::ScrollBoundaryBehavior::ScrollBoundaryBehaviorType::
+          kScrollBoundaryBehaviorTypeNone) {
+    accumulated_overscroll.set_y(0);
+    latest_overscroll_delta.set_y(0);
+    current_fling_velocity.set_y(0);
+  }
+
+  if (glow_effect_ && glow_effect_->OnOverscrolled(
+                          base::TimeTicks::Now(), accumulated_overscroll,
+                          latest_overscroll_delta, current_fling_velocity,
+                          overscroll_location)) {
     SetNeedsAnimate();
   }
 }
 
 bool OverscrollControllerAndroid::Animate(base::TimeTicks current_time,
                                           cc::Layer* parent_layer) {
   DCHECK(parent_layer);
   if (!enabled_ || !glow_effect_)
     return false;
 
@@ skipping 40 matching lines @@
       glow_effect_->Reset();
   }
 }
 
 std::unique_ptr<EdgeEffectBase>
 OverscrollControllerAndroid::CreateEdgeEffect() {
   return CreateGlowEdgeEffect(&compositor_->GetResourceManager(), dpi_scale_);
 }
 
 void OverscrollControllerAndroid::SetNeedsAnimate() {
-  compositor_->SetNeedsAnimate();
+  if (compositor_)

[boliu, 2017/08/23 19:17:02]

for testing again, right?

should either set a non-null compositor in tests, or alternatively, make this
method virtual and override it in the test to no-op. preferably the first option

[sunyunjia, 2017/08/23 23:47:05]

Done.

+    compositor_->SetNeedsAnimate();
 }
 
 }  // namespace content