Early terminate flings when scrolling impossible

content/renderer/input/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 "content/renderer/input/input_handler_proxy.h"
 
 #include "base/basictypes.h"
 #include "base/memory/scoped_ptr.h"
 #include "cc/base/swap_promise_monitor.h"
+#include "content/common/input/did_overscroll_params.h"
 #include "content/renderer/input/input_handler_proxy_client.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/WebKit/public/platform/WebFloatPoint.h"
 #include "third_party/WebKit/public/platform/WebFloatSize.h"
 #include "third_party/WebKit/public/platform/WebGestureCurve.h"
 #include "third_party/WebKit/public/platform/WebPoint.h"
 #include "third_party/WebKit/public/web/WebInputEvent.h"
 #include "ui/events/latency_info.h"
 
@@ skipping 59 matching lines @@
 
   virtual void OnRootLayerDelegatedScrollOffsetChanged() OVERRIDE {}
 
   DISALLOW_COPY_AND_ASSIGN(MockInputHandler);
 };
 
 // A simple WebGestureCurve implementation that flings at a constant velocity
 // indefinitely.
 class FakeWebGestureCurve : public blink::WebGestureCurve {
  public:
-  FakeWebGestureCurve(const blink::WebFloatPoint& velocity,
-                      const blink::WebSize& cumulative_scroll)
+  FakeWebGestureCurve(const blink::WebFloatSize& velocity,
+                      const blink::WebFloatSize& cumulative_scroll)
       : velocity_(velocity), cumulative_scroll_(cumulative_scroll) {}
 
   virtual ~FakeWebGestureCurve() {}
 
   // Returns false if curve has finished and can no longer be applied.
   virtual bool apply(double time, blink::WebGestureCurveTarget* target) {
-    blink::WebSize displacement(velocity_.x * time, velocity_.y * time);
+    blink::WebFloatSize displacement(velocity_.width * time,
+                                     velocity_.height * time);
     blink::WebFloatSize increment(
         displacement.width - cumulative_scroll_.width,
         displacement.height - cumulative_scroll_.height);
     cumulative_scroll_ = displacement;
     // scrollBy() could delete this curve if the animation is over, so don't
     // touch any member variables after making that call.
-    target->scrollBy(increment);
+    target->scrollBy(increment, velocity_);
     return true;
   }
 
  private:
-  blink::WebFloatPoint velocity_;
-  blink::WebSize cumulative_scroll_;
+  blink::WebFloatSize velocity_;
+  blink::WebFloatSize cumulative_scroll_;
 
   DISALLOW_COPY_AND_ASSIGN(FakeWebGestureCurve);
 };
 
 class MockInputHandlerProxyClient
     : public content::InputHandlerProxyClient {
  public:
   MockInputHandlerProxyClient() {}
   virtual ~MockInputHandlerProxyClient() {}
 
   virtual void WillShutdown() OVERRIDE {}
 
   MOCK_METHOD1(TransferActiveWheelFlingAnimation,
                void(const WebActiveWheelFlingParameters&));
 
   virtual blink::WebGestureCurve* CreateFlingAnimationCurve(
       int deviceSource,
       const WebFloatPoint& velocity,
       const WebSize& cumulative_scroll) OVERRIDE {
-    return new FakeWebGestureCurve(velocity, cumulative_scroll);
+    return new FakeWebGestureCurve(
+        blink::WebFloatSize(velocity.x, velocity.y),
+        blink::WebFloatSize(cumulative_scroll.width, cumulative_scroll.height));
   }
 
-  virtual void DidOverscroll(const cc::DidOverscrollParams& params) OVERRIDE {}
+  MOCK_METHOD1(DidOverscroll, void(const DidOverscrollParams&));
   virtual void DidStopFlinging() OVERRIDE {}
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockInputHandlerProxyClient);
 };
 
 WebTouchPoint CreateWebTouchPoint(WebTouchPoint::State state, float x,
                                   float y) {
   WebTouchPoint point;
   point.state = state;
@@ skipping 934 matching lines @@
   EXPECT_CALL(mock_input_handler_,
               ScrollBy(testing::_,
                        testing::Property(&gfx::Vector2dF::y, testing::Lt(0))))
       .WillOnce(testing::Return(true));
   EXPECT_CALL(mock_input_handler_, ScrollEnd());
   time += base::TimeDelta::FromMilliseconds(100);
   input_handler_->Animate(time);
   testing::Mock::VerifyAndClearExpectations(&mock_input_handler_);
 
   // Simulate hitting the bottom content edge.
-  cc::DidOverscrollParams overscroll_params;
-  overscroll_params.accumulated_overscroll = gfx::Vector2dF(0, 100);
-  overscroll_params.current_fling_velocity = gfx::Vector2dF(0, 10);
-  input_handler_->DidOverscroll(overscroll_params);
+  gfx::Vector2dF accumulated_overscroll(0, 100);
+  gfx::Vector2dF latest_overscroll_delta(0, 10);
+  EXPECT_CALL(mock_client_,
+              DidOverscroll(testing::AllOf(
+                  testing::Field(&DidOverscrollParams::accumulated_overscroll,
+                                 testing::Eq(accumulated_overscroll)),
+                  testing::Field(&DidOverscrollParams::latest_overscroll_delta,
+                                 testing::Eq(latest_overscroll_delta)),
+                  testing::Field(
+                      &DidOverscrollParams::current_fling_velocity,
+                      testing::Property(&gfx::Vector2dF::y, testing::Gt(0))))));
+  input_handler_->DidOverscroll(accumulated_overscroll,
+                                latest_overscroll_delta);
 
   // The next call to animate will no longer scroll vertically.
   EXPECT_CALL(mock_input_handler_, ScheduleAnimation());
   EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_))
       .WillOnce(testing::Return(cc::InputHandler::ScrollStarted));
   EXPECT_CALL(mock_input_handler_,
               ScrollBy(testing::_,
                        testing::Property(&gfx::Vector2dF::y, testing::Eq(0))))
       .WillOnce(testing::Return(true));
   EXPECT_CALL(mock_input_handler_, ScrollEnd());
@@ skipping 36 matching lines @@
   EXPECT_CALL(mock_input_handler_, ScheduleAnimation());
   EXPECT_CALL(mock_input_handler_,
               ScrollBy(testing::_,
                        testing::Property(&gfx::Vector2dF::y, testing::Lt(0))))
       .WillOnce(testing::Return(true));
   time += base::TimeDelta::FromMilliseconds(10);
   input_handler_->Animate(time);
   testing::Mock::VerifyAndClearExpectations(&mock_input_handler_);
 
   // Simulate hitting the bottom content edge.
-  cc::DidOverscrollParams overscroll_params;
-  overscroll_params.accumulated_overscroll = gfx::Vector2dF(0, 100);
-  input_handler_->DidOverscroll(overscroll_params);
+  gfx::Vector2dF accumulated_overscroll(0, 100);
+  gfx::Vector2dF latest_overscroll_delta(0, 100);
+  EXPECT_CALL(mock_client_,
+              DidOverscroll(testing::AllOf(
+                  testing::Field(&DidOverscrollParams::accumulated_overscroll,
+                                 testing::Eq(accumulated_overscroll)),
+                  testing::Field(&DidOverscrollParams::latest_overscroll_delta,
+                                 testing::Eq(latest_overscroll_delta)),
+                  testing::Field(
+                      &DidOverscrollParams::current_fling_velocity,
+                      testing::Property(&gfx::Vector2dF::y, testing::Gt(0))))));
+  input_handler_->DidOverscroll(accumulated_overscroll,
+                                latest_overscroll_delta);
 
   // The next call to animate will no longer scroll vertically.
   EXPECT_CALL(mock_input_handler_, ScheduleAnimation());
   EXPECT_CALL(mock_input_handler_,
               ScrollBy(testing::_,
                        testing::Property(&gfx::Vector2dF::y, testing::Eq(0))))
       .WillOnce(testing::Return(true));
   time += base::TimeDelta::FromMilliseconds(10);
   input_handler_->Animate(time);
   testing::Mock::VerifyAndClearExpectations(&mock_input_handler_);
 
   // Simulate hitting the right content edge.
-  overscroll_params.accumulated_overscroll = gfx::Vector2dF(100, 100);
-  input_handler_->DidOverscroll(overscroll_params);
-
+  accumulated_overscroll = gfx::Vector2dF(100, 100);
+  latest_overscroll_delta = gfx::Vector2dF(100, 0);
+  EXPECT_CALL(mock_client_,
+              DidOverscroll(testing::AllOf(
+                  testing::Field(&DidOverscrollParams::accumulated_overscroll,
+                                 testing::Eq(accumulated_overscroll)),
+                  testing::Field(&DidOverscrollParams::latest_overscroll_delta,
+                                 testing::Eq(latest_overscroll_delta)),
+                  testing::Field(
+                      &DidOverscrollParams::current_fling_velocity,
+                      testing::Property(&gfx::Vector2dF::x, testing::Gt(0))))));
+  input_handler_->DidOverscroll(accumulated_overscroll,
+                                latest_overscroll_delta);
   // The next call to animate will no longer scroll horizontally or vertically,
   // and the fling should be cancelled.
   EXPECT_CALL(mock_input_handler_, ScheduleAnimation()).Times(0);
   EXPECT_CALL(mock_input_handler_, ScrollBy(testing::_, testing::_)).Times(0);
   EXPECT_CALL(mock_input_handler_, ScrollEnd());
   time += base::TimeDelta::FromMilliseconds(10);
   input_handler_->Animate(time);
   testing::Mock::VerifyAndClearExpectations(&mock_input_handler_);
   EXPECT_FALSE(input_handler_->gesture_scroll_on_impl_thread_for_testing());
 }
@@ skipping 45 matching lines @@
 
   touch.touchesLength = 3;
   touch.touches[0] = CreateWebTouchPoint(WebTouchPoint::StatePressed, 0, 0);
   touch.touches[1] = CreateWebTouchPoint(WebTouchPoint::StatePressed, 10, 10);
   touch.touches[2] = CreateWebTouchPoint(WebTouchPoint::StatePressed, -10, 10);
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(touch));
 }
 
 } // namespace
 } // namespace content