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

ui/events/blink/input_handler_proxy_unittest.cc

 // Copyright 2013 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 "ui/events/blink/input_handler_proxy.h"
 
 #include <memory>
 
 #include "base/bind.h"
 #include "base/macros.h"
@@ skipping 294 matching lines @@
 
   std::unique_ptr<blink::WebGestureCurve> CreateFlingAnimationCurve(
       WebGestureDevice deviceSource,
       const WebFloatPoint& velocity,
       const WebSize& cumulative_scroll) override {
     return base::MakeUnique<FakeWebGestureCurve>(
         blink::WebFloatSize(velocity.x, velocity.y),
         blink::WebFloatSize(cumulative_scroll.width, cumulative_scroll.height));
   }
 
-  MOCK_METHOD4(DidOverscroll,
-               void(const gfx::Vector2dF& accumulated_overscroll,
-                    const gfx::Vector2dF& latest_overscroll_delta,
-                    const gfx::Vector2dF& current_fling_velocity,
-                    const gfx::PointF& causal_event_viewport_point));
+  MOCK_METHOD5(
+      DidOverscroll,
+      void(const gfx::Vector2dF& accumulated_overscroll,
+           const gfx::Vector2dF& latest_overscroll_delta,
+           const gfx::Vector2dF& current_fling_velocity,
+           const gfx::PointF& causal_event_viewport_point,
+           const cc::ScrollBoundaryBehavior& scroll_boundary_behavior));
   void DidStopFlinging() override {}
   void DidAnimateForInput() override {}
   MOCK_METHOD3(SetWhiteListedTouchAction,
                void(cc::TouchAction touch_action,
                     uint32_t unique_touch_event_id,
                     InputHandlerProxy::EventDisposition event_disposition));
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockInputHandlerProxyClient);
 };
@@ skipping 1894 matching lines @@
   if (!touchpad_and_wheel_scroll_latching_enabled_) {
     EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_))
         .WillOnce(testing::Return(kImplThreadScrollState));
   }
   EXPECT_CALL(
       mock_input_handler_,
       ScrollBy(testing::Property(&cc::ScrollState::delta_y, testing::Lt(0))))
       .WillOnce(testing::Return(overscroll));
   EXPECT_CALL(
       mock_client_,
-      DidOverscroll(
-          overscroll.accumulated_root_overscroll,
-          overscroll.unused_scroll_delta,
-          testing::Property(&gfx::Vector2dF::y, testing::Lt(0)),
-          testing::_));
+      DidOverscroll(overscroll.accumulated_root_overscroll,
+                    overscroll.unused_scroll_delta,
+                    testing::Property(&gfx::Vector2dF::y, testing::Lt(0)),
+                    testing::_, overscroll.scroll_boundary_behavior));
   if (!touchpad_and_wheel_scroll_latching_enabled_)
     EXPECT_CALL(mock_input_handler_, ScrollEnd(testing::_));
   EXPECT_SET_NEEDS_ANIMATE_INPUT(1);
   time += base::TimeDelta::FromMilliseconds(100);
   Animate(time);
   VERIFY_AND_RESET_MOCKS();
 
   // The next call to animate will no longer scroll vertically.
   EXPECT_SET_NEEDS_ANIMATE_INPUT(1);
   EXPECT_CALL(mock_input_handler_,
@@ skipping 140 matching lines @@
 
   // The third animate hits the bottom content edge.
   overscroll.accumulated_root_overscroll = gfx::Vector2dF(0, 100);
   overscroll.unused_scroll_delta = gfx::Vector2dF(0, 100);
   EXPECT_CALL(
       mock_input_handler_,
       ScrollBy(testing::Property(&cc::ScrollState::delta_y, testing::Lt(0))))
       .WillOnce(testing::Return(overscroll));
   EXPECT_CALL(
       mock_client_,
-      DidOverscroll(
-          overscroll.accumulated_root_overscroll,
-          overscroll.unused_scroll_delta,
-          testing::Property(&gfx::Vector2dF::y, testing::Lt(0)),
-          testing::_));
+      DidOverscroll(overscroll.accumulated_root_overscroll,
+                    overscroll.unused_scroll_delta,
+                    testing::Property(&gfx::Vector2dF::y, testing::Lt(0)),
+                    testing::_, overscroll.scroll_boundary_behavior));
   EXPECT_SET_NEEDS_ANIMATE_INPUT(1);
   time += base::TimeDelta::FromMilliseconds(10);
   Animate(time);
   VERIFY_AND_RESET_MOCKS();
 
   // The next call to animate will no longer scroll vertically.
   EXPECT_SET_NEEDS_ANIMATE_INPUT(1);
   EXPECT_CALL(
       mock_input_handler_,
       ScrollBy(testing::Property(&cc::ScrollState::delta_y, testing::Eq(0))))
       .WillOnce(testing::Return(scroll_result_did_scroll_));
   time += base::TimeDelta::FromMilliseconds(10);
   Animate(time);
   VERIFY_AND_RESET_MOCKS();
 
   // The next call will hit the right edge.
   overscroll.accumulated_root_overscroll = gfx::Vector2dF(100, 100);
   overscroll.unused_scroll_delta = gfx::Vector2dF(100, 0);
   EXPECT_CALL(
       mock_input_handler_,
       ScrollBy(testing::Property(&cc::ScrollState::delta_x, testing::Lt(0))))
       .WillOnce(testing::Return(overscroll));
   EXPECT_CALL(
       mock_client_,
-      DidOverscroll(
-          overscroll.accumulated_root_overscroll,
-          overscroll.unused_scroll_delta,
-          testing::Property(&gfx::Vector2dF::x, testing::Lt(0)),
-          testing::_));
+      DidOverscroll(overscroll.accumulated_root_overscroll,
+                    overscroll.unused_scroll_delta,
+                    testing::Property(&gfx::Vector2dF::x, testing::Lt(0)),
+                    testing::_, overscroll.scroll_boundary_behavior));
   EXPECT_CALL(mock_input_handler_, ScrollEnd(testing::_));
   time += base::TimeDelta::FromMilliseconds(10);
   Animate(time);
   VERIFY_AND_RESET_MOCKS();
 
   // The next call to animate will no longer scroll horizontally or vertically,
   // and the fling should be cancelled.
   EXPECT_SET_NEEDS_ANIMATE_INPUT(0);
   EXPECT_CALL(mock_input_handler_, ScrollBy(testing::_)).Times(0);
   time += base::TimeDelta::FromMilliseconds(10);
@@ skipping 1721 matching lines @@
 INSTANTIATE_TEST_CASE_P(AnimateInput,
                         InputHandlerProxyWithoutWheelScrollLatchingTest,
                         testing::ValuesIn(test_types));
 
 INSTANTIATE_TEST_CASE_P(InputHandlerProxyEventQueueTests,
                         InputHandlerProxyEventQueueTest,
                         testing::Bool());
 
 }  // namespace test
 }  // namespace ui