Index: content/renderer/input/input_handler_proxy_unittest.cc |
diff --git a/content/renderer/input/input_handler_proxy_unittest.cc b/content/renderer/input/input_handler_proxy_unittest.cc |
deleted file mode 100644 |
index aee95d8d93a53ea5591c5553bffd5bcbb519ae83..0000000000000000000000000000000000000000 |
--- a/content/renderer/input/input_handler_proxy_unittest.cc |
+++ /dev/null |
@@ -1,2478 +0,0 @@ |
-// 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/trees/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" |
-#include "ui/gfx/geometry/scroll_offset.h" |
-#include "ui/gfx/geometry/size_f.h" |
- |
-using blink::WebActiveWheelFlingParameters; |
-using blink::WebFloatPoint; |
-using blink::WebFloatSize; |
-using blink::WebGestureDevice; |
-using blink::WebGestureEvent; |
-using blink::WebInputEvent; |
-using blink::WebKeyboardEvent; |
-using blink::WebMouseWheelEvent; |
-using blink::WebPoint; |
-using blink::WebSize; |
-using blink::WebTouchEvent; |
-using blink::WebTouchPoint; |
-using testing::Field; |
- |
-namespace content { |
-namespace test { |
- |
-namespace { |
- |
-enum InputHandlerProxyTestType { |
- ROOT_SCROLL_NORMAL_HANDLER, |
- ROOT_SCROLL_SYNCHRONOUS_HANDLER, |
- CHILD_SCROLL_NORMAL_HANDLER, |
- CHILD_SCROLL_SYNCHRONOUS_HANDLER, |
-}; |
-static const InputHandlerProxyTestType test_types[] = { |
- ROOT_SCROLL_NORMAL_HANDLER, ROOT_SCROLL_SYNCHRONOUS_HANDLER, |
- CHILD_SCROLL_NORMAL_HANDLER, CHILD_SCROLL_SYNCHRONOUS_HANDLER}; |
- |
-double InSecondsF(const base::TimeTicks& time) { |
- return (time - base::TimeTicks()).InSecondsF(); |
-} |
- |
-WebGestureEvent CreateFling(base::TimeTicks timestamp, |
- WebGestureDevice source_device, |
- WebFloatPoint velocity, |
- WebPoint point, |
- WebPoint global_point, |
- int modifiers) { |
- WebGestureEvent fling; |
- fling.type = WebInputEvent::GestureFlingStart; |
- fling.sourceDevice = source_device; |
- fling.timeStampSeconds = (timestamp - base::TimeTicks()).InSecondsF(); |
- fling.data.flingStart.velocityX = velocity.x; |
- fling.data.flingStart.velocityY = velocity.y; |
- fling.x = point.x; |
- fling.y = point.y; |
- fling.globalX = global_point.x; |
- fling.globalY = global_point.y; |
- fling.modifiers = modifiers; |
- return fling; |
-} |
- |
-WebGestureEvent CreateFling(WebGestureDevice source_device, |
- WebFloatPoint velocity, |
- WebPoint point, |
- WebPoint global_point, |
- int modifiers) { |
- return CreateFling(base::TimeTicks(), |
- source_device, |
- velocity, |
- point, |
- global_point, |
- modifiers); |
-} |
- |
-class MockInputHandler : public cc::InputHandler { |
- public: |
- MockInputHandler() {} |
- ~MockInputHandler() override {} |
- |
- MOCK_METHOD0(PinchGestureBegin, void()); |
- MOCK_METHOD2(PinchGestureUpdate, |
- void(float magnify_delta, const gfx::Point& anchor)); |
- MOCK_METHOD0(PinchGestureEnd, void()); |
- |
- MOCK_METHOD0(SetNeedsAnimateInput, void()); |
- |
- MOCK_METHOD2(ScrollBegin, |
- ScrollStatus(const gfx::Point& viewport_point, |
- cc::InputHandler::ScrollInputType type)); |
- MOCK_METHOD1(RootScrollBegin, |
- ScrollStatus(cc::InputHandler::ScrollInputType type)); |
- MOCK_METHOD2(ScrollAnimated, |
- ScrollStatus(const gfx::Point& viewport_point, |
- const gfx::Vector2dF& scroll_delta)); |
- MOCK_METHOD2(ScrollBy, |
- cc::InputHandlerScrollResult( |
- const gfx::Point& viewport_point, |
- const gfx::Vector2dF& scroll_delta)); |
- MOCK_METHOD2(ScrollVerticallyByPage, |
- bool(const gfx::Point& viewport_point, |
- cc::ScrollDirection direction)); |
- MOCK_METHOD0(ScrollEnd, void()); |
- MOCK_METHOD0(FlingScrollBegin, cc::InputHandler::ScrollStatus()); |
- |
- scoped_ptr<cc::SwapPromiseMonitor> CreateLatencyInfoSwapPromiseMonitor( |
- ui::LatencyInfo* latency) override { |
- return scoped_ptr<cc::SwapPromiseMonitor>(); |
- } |
- |
- cc::ScrollElasticityHelper* CreateScrollElasticityHelper() override { |
- return NULL; |
- } |
- |
- void BindToClient(cc::InputHandlerClient* client) override {} |
- |
- void MouseMoveAt(const gfx::Point& mouse_position) override {} |
- |
- MOCK_CONST_METHOD2(IsCurrentlyScrollingLayerAt, |
- bool(const gfx::Point& point, |
- cc::InputHandler::ScrollInputType type)); |
- |
- MOCK_METHOD1(HaveWheelEventHandlersAt, bool(const gfx::Point& point)); |
- MOCK_METHOD1(DoTouchEventsBlockScrollAt, bool(const gfx::Point& point)); |
- |
- MOCK_METHOD0(RequestUpdateForSynchronousInputHandler, void()); |
- MOCK_METHOD1(SetSynchronousInputHandlerRootScrollOffset, |
- void(const gfx::ScrollOffset& root_offset)); |
- |
- bool IsCurrentlyScrollingInnerViewport() const override { |
- return is_scrolling_root_; |
- } |
- void set_is_scrolling_root(bool is) { is_scrolling_root_ = is; } |
- |
- private: |
- bool is_scrolling_root_ = true; |
- DISALLOW_COPY_AND_ASSIGN(MockInputHandler); |
-}; |
- |
-class MockSynchronousInputHandler : public content::SynchronousInputHandler { |
- public: |
- MOCK_METHOD0(SetNeedsSynchronousAnimateInput, void()); |
- MOCK_METHOD6(UpdateRootLayerState, |
- void(const gfx::ScrollOffset& total_scroll_offset, |
- const gfx::ScrollOffset& max_scroll_offset, |
- const gfx::SizeF& scrollable_size, |
- float page_scale_factor, |
- float min_page_scale_factor, |
- float max_page_scale_factor)); |
-}; |
- |
-// A simple WebGestureCurve implementation that flings at a constant velocity |
-// indefinitely. |
-class FakeWebGestureCurve : public blink::WebGestureCurve { |
- public: |
- FakeWebGestureCurve(const blink::WebFloatSize& velocity, |
- const blink::WebFloatSize& cumulative_scroll) |
- : velocity_(velocity), cumulative_scroll_(cumulative_scroll) {} |
- |
- ~FakeWebGestureCurve() override {} |
- |
- // Returns false if curve has finished and can no longer be applied. |
- bool apply(double time, blink::WebGestureCurveTarget* target) override { |
- 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. |
- return target->scrollBy(increment, velocity_); |
- } |
- |
- private: |
- blink::WebFloatSize velocity_; |
- blink::WebFloatSize cumulative_scroll_; |
- |
- DISALLOW_COPY_AND_ASSIGN(FakeWebGestureCurve); |
-}; |
- |
-class MockInputHandlerProxyClient |
- : public content::InputHandlerProxyClient { |
- public: |
- MockInputHandlerProxyClient() {} |
- ~MockInputHandlerProxyClient() override {} |
- |
- void WillShutdown() override {} |
- |
- MOCK_METHOD1(TransferActiveWheelFlingAnimation, |
- void(const WebActiveWheelFlingParameters&)); |
- |
- blink::WebGestureCurve* CreateFlingAnimationCurve( |
- WebGestureDevice deviceSource, |
- const WebFloatPoint& velocity, |
- const WebSize& cumulative_scroll) override { |
- return new FakeWebGestureCurve( |
- blink::WebFloatSize(velocity.x, velocity.y), |
- blink::WebFloatSize(cumulative_scroll.width, cumulative_scroll.height)); |
- } |
- |
- MOCK_METHOD1(DidOverscroll, void(const DidOverscrollParams&)); |
- void DidStopFlinging() override {} |
- void DidAnimateForInput() override {} |
- |
- private: |
- DISALLOW_COPY_AND_ASSIGN(MockInputHandlerProxyClient); |
-}; |
- |
-class MockInputHandlerProxyClientWithDidAnimateForInput |
- : public MockInputHandlerProxyClient { |
- public: |
- MockInputHandlerProxyClientWithDidAnimateForInput() {} |
- ~MockInputHandlerProxyClientWithDidAnimateForInput() override {} |
- |
- MOCK_METHOD0(DidAnimateForInput, void()); |
- |
- private: |
- DISALLOW_COPY_AND_ASSIGN(MockInputHandlerProxyClientWithDidAnimateForInput); |
-}; |
- |
-WebTouchPoint CreateWebTouchPoint(WebTouchPoint::State state, float x, |
- float y) { |
- WebTouchPoint point; |
- point.state = state; |
- point.screenPosition = WebFloatPoint(x, y); |
- point.position = WebFloatPoint(x, y); |
- return point; |
-} |
- |
-} // namespace |
- |
-class InputHandlerProxyTest |
- : public testing::Test, |
- public testing::WithParamInterface<InputHandlerProxyTestType> { |
- public: |
- InputHandlerProxyTest() |
- : synchronous_root_scroll_(GetParam() == ROOT_SCROLL_SYNCHRONOUS_HANDLER), |
- install_synchronous_handler_( |
- GetParam() == ROOT_SCROLL_SYNCHRONOUS_HANDLER || |
- GetParam() == CHILD_SCROLL_SYNCHRONOUS_HANDLER), |
- expected_disposition_(InputHandlerProxy::DID_HANDLE) { |
- input_handler_.reset( |
- new content::InputHandlerProxy(&mock_input_handler_, &mock_client_)); |
- scroll_result_did_scroll_.did_scroll = true; |
- scroll_result_did_not_scroll_.did_scroll = false; |
- |
- if (install_synchronous_handler_) { |
- EXPECT_CALL(mock_input_handler_, |
- RequestUpdateForSynchronousInputHandler()) |
- .Times(1); |
- input_handler_->SetOnlySynchronouslyAnimateRootFlings( |
- &mock_synchronous_input_handler_); |
- } |
- |
- mock_input_handler_.set_is_scrolling_root(synchronous_root_scroll_); |
- |
- // Set a default device so tests don't always have to set this. |
- gesture_.sourceDevice = blink::WebGestureDeviceTouchpad; |
- } |
- |
- ~InputHandlerProxyTest() { |
- input_handler_.reset(); |
- } |
- |
-// This is defined as a macro so the line numbers can be traced back to the |
-// correct spot when it fails. |
-#define EXPECT_SET_NEEDS_ANIMATE_INPUT(times) \ |
- do { \ |
- if (synchronous_root_scroll_) { \ |
- EXPECT_CALL(mock_synchronous_input_handler_, \ |
- SetNeedsSynchronousAnimateInput()) \ |
- .Times(times); \ |
- EXPECT_CALL(mock_input_handler_, SetNeedsAnimateInput()).Times(0); \ |
- } else { \ |
- EXPECT_CALL(mock_input_handler_, SetNeedsAnimateInput()).Times(times); \ |
- EXPECT_CALL(mock_synchronous_input_handler_, \ |
- SetNeedsSynchronousAnimateInput()) \ |
- .Times(0); \ |
- } \ |
- } while (false) |
- |
-// This is defined as a macro because when an expectation is not satisfied the |
-// only output you get out of gmock is the line number that set the expectation. |
-#define VERIFY_AND_RESET_MOCKS() \ |
- do { \ |
- testing::Mock::VerifyAndClearExpectations(&mock_input_handler_); \ |
- testing::Mock::VerifyAndClearExpectations( \ |
- &mock_synchronous_input_handler_); \ |
- testing::Mock::VerifyAndClearExpectations(&mock_client_); \ |
- } while (false) |
- |
- void Animate(base::TimeTicks time) { |
- if (synchronous_root_scroll_) { |
- input_handler_->SynchronouslyAnimate(time); |
- } else { |
- input_handler_->Animate(time); |
- } |
- } |
- |
- void StartFling(base::TimeTicks timestamp, |
- WebGestureDevice source_device, |
- WebFloatPoint velocity, |
- WebPoint position) { |
- expected_disposition_ = InputHandlerProxy::DID_HANDLE; |
- VERIFY_AND_RESET_MOCKS(); |
- |
- EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_)) |
- .WillOnce(testing::Return(cc::InputHandler::SCROLL_STARTED)); |
- gesture_.type = WebInputEvent::GestureScrollBegin; |
- gesture_.sourceDevice = source_device; |
- EXPECT_EQ(expected_disposition_, |
- input_handler_->HandleInputEvent(gesture_)); |
- |
- VERIFY_AND_RESET_MOCKS(); |
- |
- EXPECT_CALL(mock_input_handler_, FlingScrollBegin()) |
- .WillOnce(testing::Return(cc::InputHandler::SCROLL_STARTED)); |
- EXPECT_SET_NEEDS_ANIMATE_INPUT(1); |
- |
- gesture_ = |
- CreateFling(timestamp, source_device, velocity, position, position, 0); |
- EXPECT_EQ(expected_disposition_, |
- input_handler_->HandleInputEvent(gesture_)); |
- |
- VERIFY_AND_RESET_MOCKS(); |
- } |
- |
- void CancelFling(base::TimeTicks timestamp) { |
- gesture_.timeStampSeconds = InSecondsF(timestamp); |
- gesture_.type = WebInputEvent::GestureFlingCancel; |
- EXPECT_EQ(expected_disposition_, |
- input_handler_->HandleInputEvent(gesture_)); |
- |
- VERIFY_AND_RESET_MOCKS(); |
- } |
- |
- void SetSmoothScrollEnabled(bool value) { |
- input_handler_->smooth_scroll_enabled_ = value; |
- } |
- |
- protected: |
- const bool synchronous_root_scroll_; |
- const bool install_synchronous_handler_; |
- testing::StrictMock<MockInputHandler> mock_input_handler_; |
- testing::StrictMock<MockSynchronousInputHandler> |
- mock_synchronous_input_handler_; |
- scoped_ptr<content::InputHandlerProxy> input_handler_; |
- testing::StrictMock<MockInputHandlerProxyClient> mock_client_; |
- WebGestureEvent gesture_; |
- InputHandlerProxy::EventDisposition expected_disposition_; |
- cc::InputHandlerScrollResult scroll_result_did_scroll_; |
- cc::InputHandlerScrollResult scroll_result_did_not_scroll_; |
-}; |
- |
-TEST_P(InputHandlerProxyTest, MouseWheelByPageMainThread) { |
- expected_disposition_ = InputHandlerProxy::DID_NOT_HANDLE; |
- WebMouseWheelEvent wheel; |
- wheel.type = WebInputEvent::MouseWheel; |
- wheel.scrollByPage = true; |
- |
- EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(wheel)); |
- VERIFY_AND_RESET_MOCKS(); |
-} |
- |
-TEST_P(InputHandlerProxyTest, MouseWheelWithCtrlNotScroll) { |
- expected_disposition_ = InputHandlerProxy::DID_NOT_HANDLE; |
- WebMouseWheelEvent wheel; |
- wheel.type = WebInputEvent::MouseWheel; |
- wheel.modifiers = WebInputEvent::ControlKey; |
- wheel.canScroll = false; |
- EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(wheel)); |
- VERIFY_AND_RESET_MOCKS(); |
-} |
- |
-TEST_P(InputHandlerProxyTest, MouseWheelWithPreciseScrollingDeltas) { |
- SetSmoothScrollEnabled(true); |
- expected_disposition_ = InputHandlerProxy::DID_HANDLE; |
- WebMouseWheelEvent wheel; |
- wheel.type = WebInputEvent::MouseWheel; |
- |
- VERIFY_AND_RESET_MOCKS(); |
- |
- // Smooth scroll because hasPreciseScrollingDeltas is set to false. |
- wheel.hasPreciseScrollingDeltas = false; |
- EXPECT_CALL(mock_input_handler_, ScrollAnimated(::testing::_, ::testing::_)) |
- .WillOnce(testing::Return(cc::InputHandler::SCROLL_STARTED)); |
- EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(wheel)); |
- |
- VERIFY_AND_RESET_MOCKS(); |
- |
- // No smooth scroll because hasPreciseScrollingDeltas is set to true. |
- wheel.hasPreciseScrollingDeltas = true; |
- EXPECT_CALL(mock_input_handler_, ScrollBegin(::testing::_, ::testing::_)) |
- .WillOnce(testing::Return(cc::InputHandler::SCROLL_STARTED)); |
- EXPECT_CALL(mock_input_handler_, ScrollBy(::testing::_, ::testing::_)) |
- .WillOnce(testing::Return(scroll_result_did_scroll_)); |
- EXPECT_CALL(mock_input_handler_, ScrollEnd()); |
- EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(wheel)); |
- |
- VERIFY_AND_RESET_MOCKS(); |
-} |
- |
-TEST_P(InputHandlerProxyTest, MouseWheelScrollIgnored) { |
- SetSmoothScrollEnabled(true); |
- expected_disposition_ = InputHandlerProxy::DROP_EVENT; |
- WebMouseWheelEvent wheel; |
- wheel.type = WebInputEvent::MouseWheel; |
- |
- EXPECT_CALL(mock_input_handler_, ScrollAnimated(testing::_, testing::_)) |
- .WillOnce(testing::Return(cc::InputHandler::SCROLL_IGNORED)); |
- |
- EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(wheel)); |
- VERIFY_AND_RESET_MOCKS(); |
-} |
- |
-TEST_P(InputHandlerProxyTest, GestureScrollStarted) { |
- // We shouldn't send any events to the widget for this gesture. |
- expected_disposition_ = InputHandlerProxy::DID_HANDLE; |
- VERIFY_AND_RESET_MOCKS(); |
- |
- EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_)) |
- .WillOnce(testing::Return(cc::InputHandler::SCROLL_STARTED)); |
- |
- gesture_.type = WebInputEvent::GestureScrollBegin; |
- EXPECT_EQ(expected_disposition_,input_handler_->HandleInputEvent(gesture_)); |
- |
- // The event should not be marked as handled if scrolling is not possible. |
- expected_disposition_ = InputHandlerProxy::DROP_EVENT; |
- VERIFY_AND_RESET_MOCKS(); |
- |
- gesture_.type = WebInputEvent::GestureScrollUpdate; |
- gesture_.data.scrollUpdate.deltaY = |
- -40; // -Y means scroll down - i.e. in the +Y direction. |
- EXPECT_CALL(mock_input_handler_, |
- ScrollBy(testing::_, |
- testing::Property(&gfx::Vector2dF::y, testing::Gt(0)))) |
- .WillOnce(testing::Return(scroll_result_did_not_scroll_)); |
- EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_)); |
- |
- // Mark the event as handled if scroll happens. |
- expected_disposition_ = InputHandlerProxy::DID_HANDLE; |
- VERIFY_AND_RESET_MOCKS(); |
- |
- gesture_.type = WebInputEvent::GestureScrollUpdate; |
- gesture_.data.scrollUpdate.deltaY = |
- -40; // -Y means scroll down - i.e. in the +Y direction. |
- EXPECT_CALL(mock_input_handler_, |
- ScrollBy(testing::_, |
- testing::Property(&gfx::Vector2dF::y, testing::Gt(0)))) |
- .WillOnce(testing::Return(scroll_result_did_scroll_)); |
- EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_)); |
- |
- VERIFY_AND_RESET_MOCKS(); |
- |
- gesture_.type = WebInputEvent::GestureScrollEnd; |
- gesture_.data.scrollUpdate.deltaY = 0; |
- EXPECT_CALL(mock_input_handler_, ScrollEnd()); |
- EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_)); |
- |
- VERIFY_AND_RESET_MOCKS(); |
-} |
- |
-TEST_P(InputHandlerProxyTest, GestureScrollOnMainThread) { |
- // We should send all events to the widget for this gesture. |
- expected_disposition_ = InputHandlerProxy::DID_NOT_HANDLE; |
- VERIFY_AND_RESET_MOCKS(); |
- |
- EXPECT_CALL(mock_input_handler_, ScrollBegin(::testing::_, ::testing::_)) |
- .WillOnce(testing::Return(cc::InputHandler::SCROLL_ON_MAIN_THREAD)); |
- |
- gesture_.type = WebInputEvent::GestureScrollBegin; |
- EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_)); |
- |
- VERIFY_AND_RESET_MOCKS(); |
- |
- gesture_.type = WebInputEvent::GestureScrollUpdate; |
- gesture_.data.scrollUpdate.deltaY = 40; |
- EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_)); |
- |
- VERIFY_AND_RESET_MOCKS(); |
- |
- gesture_.type = WebInputEvent::GestureScrollEnd; |
- gesture_.data.scrollUpdate.deltaY = 0; |
- EXPECT_CALL(mock_input_handler_, ScrollEnd()).WillOnce(testing::Return()); |
- EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_)); |
- |
- VERIFY_AND_RESET_MOCKS(); |
-} |
- |
-TEST_P(InputHandlerProxyTest, GestureScrollIgnored) { |
- // We shouldn't handle the GestureScrollBegin. |
- // Instead, we should get a DROP_EVENT result, indicating |
- // that we could determine that there's nothing that could scroll or otherwise |
- // react to this gesture sequence and thus we should drop the whole gesture |
- // sequence on the floor, except for the ScrollEnd. |
- expected_disposition_ = InputHandlerProxy::DROP_EVENT; |
- VERIFY_AND_RESET_MOCKS(); |
- |
- EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_)) |
- .WillOnce(testing::Return(cc::InputHandler::SCROLL_IGNORED)); |
- |
- gesture_.type = WebInputEvent::GestureScrollBegin; |
- EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_)); |
- |
- expected_disposition_ = InputHandlerProxy::DID_NOT_HANDLE; |
- gesture_.type = WebInputEvent::GestureScrollEnd; |
- EXPECT_CALL(mock_input_handler_, ScrollEnd()).WillOnce(testing::Return()); |
- EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_)); |
- |
- VERIFY_AND_RESET_MOCKS(); |
-} |
- |
-TEST_P(InputHandlerProxyTest, GestureScrollBeginThatTargetViewport) { |
- // We shouldn't send any events to the widget for this gesture. |
- expected_disposition_ = InputHandlerProxy::DID_HANDLE; |
- VERIFY_AND_RESET_MOCKS(); |
- |
- EXPECT_CALL(mock_input_handler_, RootScrollBegin(testing::_)) |
- .WillOnce(testing::Return(cc::InputHandler::SCROLL_STARTED)); |
- |
- gesture_.type = WebInputEvent::GestureScrollBegin; |
- gesture_.data.scrollBegin.targetViewport = true; |
- EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_)); |
- |
- VERIFY_AND_RESET_MOCKS(); |
-} |
- |
-TEST_P(InputHandlerProxyTest, GesturePinch) { |
- // We shouldn't send any events to the widget for this gesture. |
- expected_disposition_ = InputHandlerProxy::DID_HANDLE; |
- VERIFY_AND_RESET_MOCKS(); |
- |
- gesture_.type = WebInputEvent::GesturePinchBegin; |
- EXPECT_CALL(mock_input_handler_, HaveWheelEventHandlersAt(testing::_)) |
- .WillOnce(testing::Return(false)); |
- EXPECT_CALL(mock_input_handler_, PinchGestureBegin()); |
- EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_)); |
- |
- VERIFY_AND_RESET_MOCKS(); |
- |
- gesture_.type = WebInputEvent::GesturePinchUpdate; |
- gesture_.data.pinchUpdate.scale = 1.5; |
- gesture_.x = 7; |
- gesture_.y = 13; |
- EXPECT_CALL(mock_input_handler_, PinchGestureUpdate(1.5, gfx::Point(7, 13))); |
- EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_)); |
- |
- VERIFY_AND_RESET_MOCKS(); |
- |
- gesture_.type = WebInputEvent::GesturePinchUpdate; |
- gesture_.data.pinchUpdate.scale = 0.5; |
- gesture_.data.pinchUpdate.zoomDisabled = true; |
- gesture_.x = 9; |
- gesture_.y = 6; |
- EXPECT_EQ(InputHandlerProxy::DROP_EVENT, |
- input_handler_->HandleInputEvent(gesture_)); |
- gesture_.data.pinchUpdate.zoomDisabled = false; |
- |
- VERIFY_AND_RESET_MOCKS(); |
- |
- gesture_.type = WebInputEvent::GesturePinchUpdate; |
- gesture_.data.pinchUpdate.scale = 0.5; |
- gesture_.x = 9; |
- gesture_.y = 6; |
- EXPECT_CALL(mock_input_handler_, PinchGestureUpdate(.5, gfx::Point(9, 6))); |
- EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_)); |
- |
- VERIFY_AND_RESET_MOCKS(); |
- |
- gesture_.type = WebInputEvent::GesturePinchEnd; |
- EXPECT_CALL(mock_input_handler_, PinchGestureEnd()); |
- EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_)); |
- |
- VERIFY_AND_RESET_MOCKS(); |
-} |
- |
-TEST_P(InputHandlerProxyTest, GesturePinchWithWheelHandler) { |
- // We will send the synthetic wheel event to the widget. |
- expected_disposition_ = InputHandlerProxy::DID_NOT_HANDLE; |
- VERIFY_AND_RESET_MOCKS(); |
- |
- gesture_.type = WebInputEvent::GesturePinchBegin; |
- EXPECT_CALL(mock_input_handler_, HaveWheelEventHandlersAt(testing::_)) |
- .WillOnce(testing::Return(true)); |
- EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_)); |
- |
- VERIFY_AND_RESET_MOCKS(); |
- |
- gesture_.type = WebInputEvent::GesturePinchUpdate; |
- gesture_.data.pinchUpdate.scale = 1.5; |
- gesture_.x = 7; |
- gesture_.y = 13; |
- EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_)); |
- |
- VERIFY_AND_RESET_MOCKS(); |
- |
- gesture_.type = WebInputEvent::GesturePinchUpdate; |
- gesture_.data.pinchUpdate.scale = 0.5; |
- gesture_.x = 9; |
- gesture_.y = 6; |
- EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_)); |
- |
- VERIFY_AND_RESET_MOCKS(); |
- |
- gesture_.type = WebInputEvent::GesturePinchEnd; |
- EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_)); |
-} |
- |
-TEST_P(InputHandlerProxyTest, GesturePinchAfterScrollOnMainThread) { |
- // Scrolls will start by being sent to the main thread. |
- expected_disposition_ = InputHandlerProxy::DID_NOT_HANDLE; |
- VERIFY_AND_RESET_MOCKS(); |
- |
- EXPECT_CALL(mock_input_handler_, ScrollBegin(::testing::_, ::testing::_)) |
- .WillOnce(testing::Return(cc::InputHandler::SCROLL_ON_MAIN_THREAD)); |
- |
- gesture_.type = WebInputEvent::GestureScrollBegin; |
- EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_)); |
- |
- VERIFY_AND_RESET_MOCKS(); |
- |
- gesture_.type = WebInputEvent::GestureScrollUpdate; |
- gesture_.data.scrollUpdate.deltaY = 40; |
- EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_)); |
- |
- // However, after the pinch gesture starts, they should go to the impl |
- // thread. |
- expected_disposition_ = InputHandlerProxy::DID_HANDLE; |
- VERIFY_AND_RESET_MOCKS(); |
- |
- gesture_.type = WebInputEvent::GesturePinchBegin; |
- EXPECT_CALL(mock_input_handler_, HaveWheelEventHandlersAt(testing::_)) |
- .WillOnce(testing::Return(false)); |
- EXPECT_CALL(mock_input_handler_, PinchGestureBegin()); |
- EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_)); |
- |
- VERIFY_AND_RESET_MOCKS(); |
- |
- gesture_.type = WebInputEvent::GesturePinchUpdate; |
- gesture_.data.pinchUpdate.scale = 1.5; |
- gesture_.x = 7; |
- gesture_.y = 13; |
- EXPECT_CALL(mock_input_handler_, PinchGestureUpdate(1.5, gfx::Point(7, 13))); |
- EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_)); |
- |
- VERIFY_AND_RESET_MOCKS(); |
- |
- gesture_.type = WebInputEvent::GestureScrollUpdate; |
- gesture_.data.scrollUpdate.deltaY = |
- -40; // -Y means scroll down - i.e. in the +Y direction. |
- EXPECT_CALL(mock_input_handler_, |
- ScrollBy(testing::_, |
- testing::Property(&gfx::Vector2dF::y, testing::Gt(0)))) |
- .WillOnce(testing::Return(scroll_result_did_scroll_)); |
- EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_)); |
- |
- VERIFY_AND_RESET_MOCKS(); |
- |
- gesture_.type = WebInputEvent::GesturePinchUpdate; |
- gesture_.data.pinchUpdate.scale = 0.5; |
- gesture_.x = 9; |
- gesture_.y = 6; |
- EXPECT_CALL(mock_input_handler_, PinchGestureUpdate(.5, gfx::Point(9, 6))); |
- EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_)); |
- |
- VERIFY_AND_RESET_MOCKS(); |
- |
- gesture_.type = WebInputEvent::GesturePinchEnd; |
- EXPECT_CALL(mock_input_handler_, PinchGestureEnd()); |
- EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_)); |
- |
- // After the pinch gesture ends, they should go to back to the main |
- // thread. |
- expected_disposition_ = InputHandlerProxy::DID_NOT_HANDLE; |
- VERIFY_AND_RESET_MOCKS(); |
- |
- gesture_.type = WebInputEvent::GestureScrollEnd; |
- gesture_.data.scrollUpdate.deltaY = 0; |
- EXPECT_CALL(mock_input_handler_, ScrollEnd()) |
- .WillOnce(testing::Return()); |
- EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_)); |
- |
- VERIFY_AND_RESET_MOCKS(); |
-} |
- |
-TEST_P(InputHandlerProxyTest, GestureFlingStartedTouchpad) { |
- // We shouldn't send any events to the widget for this gesture. |
- expected_disposition_ = InputHandlerProxy::DID_HANDLE; |
- VERIFY_AND_RESET_MOCKS(); |
- |
- EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_)) |
- .WillOnce(testing::Return(cc::InputHandler::SCROLL_STARTED)); |
- EXPECT_CALL(mock_input_handler_, ScrollEnd()); |
- EXPECT_SET_NEEDS_ANIMATE_INPUT(1); |
- |
- gesture_.type = WebInputEvent::GestureFlingStart; |
- gesture_.data.flingStart.velocityX = 10; |
- gesture_.sourceDevice = blink::WebGestureDeviceTouchpad; |
- EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_)); |
- |
- VERIFY_AND_RESET_MOCKS(); |
- |
- // Verify that a GestureFlingCancel during an animation cancels it. |
- gesture_.type = WebInputEvent::GestureFlingCancel; |
- gesture_.sourceDevice = blink::WebGestureDeviceTouchpad; |
- EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_)); |
-} |
- |
-TEST_P(InputHandlerProxyTest, GestureFlingOnMainThreadTouchpad) { |
- // We should send all events to the widget for this gesture. |
- expected_disposition_ = InputHandlerProxy::DID_NOT_HANDLE; |
- VERIFY_AND_RESET_MOCKS(); |
- |
- EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_)) |
- .WillOnce(testing::Return(cc::InputHandler::SCROLL_ON_MAIN_THREAD)); |
- |
- gesture_.type = WebInputEvent::GestureFlingStart; |
- gesture_.sourceDevice = blink::WebGestureDeviceTouchpad; |
- EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_)); |
- |
- // Since we returned ScrollStatusOnMainThread from scrollBegin, ensure the |
- // input handler knows it's scrolling off the impl thread |
- ASSERT_FALSE(input_handler_->gesture_scroll_on_impl_thread_for_testing()); |
- |
- VERIFY_AND_RESET_MOCKS(); |
- |
- // Even if we didn't start a fling ourselves, we still need to send the cancel |
- // event to the widget. |
- gesture_.type = WebInputEvent::GestureFlingCancel; |
- gesture_.sourceDevice = blink::WebGestureDeviceTouchpad; |
- EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_)); |
-} |
- |
-TEST_P(InputHandlerProxyTest, GestureFlingIgnoredTouchpad) { |
- expected_disposition_ = InputHandlerProxy::DID_NOT_HANDLE; |
- VERIFY_AND_RESET_MOCKS(); |
- |
- EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_)) |
- .WillOnce(testing::Return(cc::InputHandler::SCROLL_IGNORED)); |
- |
- gesture_.type = WebInputEvent::GestureFlingStart; |
- gesture_.sourceDevice = blink::WebGestureDeviceTouchpad; |
- EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_)); |
- |
- expected_disposition_ = InputHandlerProxy::DROP_EVENT; |
- VERIFY_AND_RESET_MOCKS(); |
- |
- // Since the previous fling was ignored, we should also be dropping the next |
- // fling_cancel. |
- gesture_.type = WebInputEvent::GestureFlingCancel; |
- gesture_.sourceDevice = blink::WebGestureDeviceTouchpad; |
- EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_)); |
-} |
- |
-TEST_P(InputHandlerProxyTest, GestureFlingAnimatesTouchpad) { |
- // We shouldn't send any events to the widget for this gesture. |
- expected_disposition_ = InputHandlerProxy::DID_HANDLE; |
- VERIFY_AND_RESET_MOCKS(); |
- |
- // On the fling start, we should schedule an animation but not actually start |
- // scrolling. |
- gesture_.type = WebInputEvent::GestureFlingStart; |
- WebFloatPoint fling_delta = WebFloatPoint(1000, 0); |
- WebPoint fling_point = WebPoint(7, 13); |
- WebPoint fling_global_point = WebPoint(17, 23); |
- // Note that for trackpad, wheel events with the Control modifier are |
- // special (reserved for zoom), so don't set that here. |
- int modifiers = WebInputEvent::ShiftKey | WebInputEvent::AltKey; |
- gesture_ = CreateFling(blink::WebGestureDeviceTouchpad, |
- fling_delta, |
- fling_point, |
- fling_global_point, |
- modifiers); |
- EXPECT_SET_NEEDS_ANIMATE_INPUT(1); |
- EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_)) |
- .WillOnce(testing::Return(cc::InputHandler::SCROLL_STARTED)); |
- EXPECT_CALL(mock_input_handler_, ScrollEnd()); |
- EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_)); |
- |
- VERIFY_AND_RESET_MOCKS(); |
- // The first animate call should let us pick up an animation start time, but |
- // we shouldn't actually move anywhere just yet. The first frame after the |
- // fling start will typically include the last scroll from the gesture that |
- // lead to the scroll (either wheel or gesture scroll), so there should be no |
- // visible hitch. |
- EXPECT_SET_NEEDS_ANIMATE_INPUT(1); |
- EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_)) |
- .Times(0); |
- base::TimeTicks time = base::TimeTicks() + base::TimeDelta::FromSeconds(10); |
- Animate(time); |
- |
- VERIFY_AND_RESET_MOCKS(); |
- |
- // The second call should start scrolling in the -X direction. |
- EXPECT_SET_NEEDS_ANIMATE_INPUT(1); |
- EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_)) |
- .WillOnce(testing::Return(cc::InputHandler::SCROLL_STARTED)); |
- EXPECT_CALL(mock_input_handler_, |
- ScrollBy(testing::_, |
- testing::Property(&gfx::Vector2dF::x, testing::Lt(0)))) |
- .WillOnce(testing::Return(scroll_result_did_scroll_)); |
- EXPECT_CALL(mock_input_handler_, ScrollEnd()); |
- time += base::TimeDelta::FromMilliseconds(100); |
- Animate(time); |
- |
- VERIFY_AND_RESET_MOCKS(); |
- |
- // Let's say on the third call we hit a non-scrollable region. We should abort |
- // the fling and not scroll. |
- // We also should pass the current fling parameters out to the client so the |
- // rest of the fling can be |
- // transferred to the main thread. |
- EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_)) |
- .WillOnce(testing::Return(cc::InputHandler::SCROLL_ON_MAIN_THREAD)); |
- EXPECT_CALL(mock_input_handler_, ScrollBy(testing::_, testing::_)).Times(0); |
- EXPECT_CALL(mock_input_handler_, ScrollEnd()).Times(0); |
- // Expected wheel fling animation parameters: |
- // *) fling_delta and fling_point should match the original GestureFlingStart |
- // event |
- // *) startTime should be 10 to match the time parameter of the first |
- // Animate() call after the GestureFlingStart |
- // *) cumulativeScroll depends on the curve, but since we've animated in the |
- // -X direction the X value should be < 0 |
- EXPECT_CALL( |
- mock_client_, |
- TransferActiveWheelFlingAnimation(testing::AllOf( |
- testing::Field(&WebActiveWheelFlingParameters::delta, |
- testing::Eq(fling_delta)), |
- testing::Field(&WebActiveWheelFlingParameters::point, |
- testing::Eq(fling_point)), |
- testing::Field(&WebActiveWheelFlingParameters::globalPoint, |
- testing::Eq(fling_global_point)), |
- testing::Field(&WebActiveWheelFlingParameters::modifiers, |
- testing::Eq(modifiers)), |
- testing::Field(&WebActiveWheelFlingParameters::startTime, |
- testing::Eq(10)), |
- testing::Field(&WebActiveWheelFlingParameters::cumulativeScroll, |
- testing::Field(&WebSize::width, testing::Gt(0)))))); |
- time += base::TimeDelta::FromMilliseconds(100); |
- Animate(time); |
- |
- VERIFY_AND_RESET_MOCKS(); |
- |
- // Since we've aborted the fling, the next animation should be a no-op and |
- // should not result in another |
- // frame being requested. |
- EXPECT_SET_NEEDS_ANIMATE_INPUT(0); |
- EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_)) |
- .Times(0); |
- time += base::TimeDelta::FromMilliseconds(100); |
- Animate(time); |
- |
- // Since we've transferred the fling to the main thread, we need to pass the |
- // next GestureFlingCancel to the main |
- // thread as well. |
- expected_disposition_ = InputHandlerProxy::DID_NOT_HANDLE; |
- gesture_.type = WebInputEvent::GestureFlingCancel; |
- EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_)); |
- |
- VERIFY_AND_RESET_MOCKS(); |
-} |
- |
-TEST_P(InputHandlerProxyTest, GestureFlingTransferResetsTouchpad) { |
- // We shouldn't send any events to the widget for this gesture. |
- expected_disposition_ = InputHandlerProxy::DID_HANDLE; |
- VERIFY_AND_RESET_MOCKS(); |
- |
- // Start a gesture fling in the -X direction with zero Y movement. |
- WebFloatPoint fling_delta = WebFloatPoint(1000, 0); |
- WebPoint fling_point = WebPoint(7, 13); |
- WebPoint fling_global_point = WebPoint(17, 23); |
- // Note that for trackpad, wheel events with the Control modifier are |
- // special (reserved for zoom), so don't set that here. |
- int modifiers = WebInputEvent::ShiftKey | WebInputEvent::AltKey; |
- gesture_ = CreateFling(blink::WebGestureDeviceTouchpad, |
- fling_delta, |
- fling_point, |
- fling_global_point, |
- modifiers); |
- EXPECT_SET_NEEDS_ANIMATE_INPUT(1); |
- EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_)) |
- .WillOnce(testing::Return(cc::InputHandler::SCROLL_STARTED)); |
- EXPECT_CALL(mock_input_handler_, ScrollEnd()); |
- EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_)); |
- |
- VERIFY_AND_RESET_MOCKS(); |
- |
- // Start the fling animation at time 10. This shouldn't actually scroll, just |
- // establish a start time. |
- EXPECT_SET_NEEDS_ANIMATE_INPUT(1); |
- EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_)) |
- .Times(0); |
- base::TimeTicks time = base::TimeTicks() + base::TimeDelta::FromSeconds(10); |
- Animate(time); |
- |
- VERIFY_AND_RESET_MOCKS(); |
- |
- // The second call should start scrolling in the -X direction. |
- EXPECT_SET_NEEDS_ANIMATE_INPUT(1); |
- EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_)) |
- .WillOnce(testing::Return(cc::InputHandler::SCROLL_STARTED)); |
- EXPECT_CALL(mock_input_handler_, |
- ScrollBy(testing::_, |
- testing::Property(&gfx::Vector2dF::x, testing::Lt(0)))) |
- .WillOnce(testing::Return(scroll_result_did_scroll_)); |
- EXPECT_CALL(mock_input_handler_, ScrollEnd()); |
- time += base::TimeDelta::FromMilliseconds(100); |
- Animate(time); |
- |
- VERIFY_AND_RESET_MOCKS(); |
- |
- // Let's say on the third call we hit a non-scrollable region. We should abort |
- // the fling and not scroll. |
- // We also should pass the current fling parameters out to the client so the |
- // rest of the fling can be |
- // transferred to the main thread. |
- EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_)) |
- .WillOnce(testing::Return(cc::InputHandler::SCROLL_ON_MAIN_THREAD)); |
- EXPECT_CALL(mock_input_handler_, ScrollBy(testing::_, testing::_)).Times(0); |
- EXPECT_CALL(mock_input_handler_, ScrollEnd()).Times(0); |
- |
- // Expected wheel fling animation parameters: |
- // *) fling_delta and fling_point should match the original GestureFlingStart |
- // event |
- // *) startTime should be 10 to match the time parameter of the first |
- // Animate() call after the GestureFlingStart |
- // *) cumulativeScroll depends on the curve, but since we've animated in the |
- // -X direction the X value should be < 0 |
- EXPECT_CALL( |
- mock_client_, |
- TransferActiveWheelFlingAnimation(testing::AllOf( |
- testing::Field(&WebActiveWheelFlingParameters::delta, |
- testing::Eq(fling_delta)), |
- testing::Field(&WebActiveWheelFlingParameters::point, |
- testing::Eq(fling_point)), |
- testing::Field(&WebActiveWheelFlingParameters::globalPoint, |
- testing::Eq(fling_global_point)), |
- testing::Field(&WebActiveWheelFlingParameters::modifiers, |
- testing::Eq(modifiers)), |
- testing::Field(&WebActiveWheelFlingParameters::startTime, |
- testing::Eq(10)), |
- testing::Field(&WebActiveWheelFlingParameters::cumulativeScroll, |
- testing::Field(&WebSize::width, testing::Gt(0)))))); |
- time += base::TimeDelta::FromMilliseconds(100); |
- Animate(time); |
- |
- VERIFY_AND_RESET_MOCKS(); |
- |
- // Since we've aborted the fling, the next animation should be a no-op and |
- // should not result in another |
- // frame being requested. |
- EXPECT_SET_NEEDS_ANIMATE_INPUT(0); |
- EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_)) |
- .Times(0); |
- time += base::TimeDelta::FromMilliseconds(100); |
- Animate(time); |
- |
- VERIFY_AND_RESET_MOCKS(); |
- |
- // Since we've transferred the fling to the main thread, we need to pass the |
- // next GestureFlingCancel to the main |
- // thread as well. |
- expected_disposition_ = InputHandlerProxy::DID_NOT_HANDLE; |
- gesture_.type = WebInputEvent::GestureFlingCancel; |
- EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_)); |
- |
- VERIFY_AND_RESET_MOCKS(); |
- input_handler_->MainThreadHasStoppedFlinging(); |
- |
- // Start a second gesture fling, this time in the +Y direction with no X. |
- fling_delta = WebFloatPoint(0, -1000); |
- fling_point = WebPoint(95, 87); |
- fling_global_point = WebPoint(32, 71); |
- modifiers = WebInputEvent::AltKey; |
- gesture_ = CreateFling(blink::WebGestureDeviceTouchpad, |
- fling_delta, |
- fling_point, |
- fling_global_point, |
- modifiers); |
- EXPECT_SET_NEEDS_ANIMATE_INPUT(1); |
- EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_)) |
- .WillOnce(testing::Return(cc::InputHandler::SCROLL_STARTED)); |
- EXPECT_CALL(mock_input_handler_, ScrollEnd()); |
- expected_disposition_ = InputHandlerProxy::DID_HANDLE; |
- EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_)); |
- |
- VERIFY_AND_RESET_MOCKS(); |
- |
- // Start the second fling animation at time 30. |
- EXPECT_SET_NEEDS_ANIMATE_INPUT(1); |
- EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_)) |
- .Times(0); |
- time = base::TimeTicks() + base::TimeDelta::FromSeconds(30); |
- Animate(time); |
- |
- VERIFY_AND_RESET_MOCKS(); |
- |
- // Tick the second fling once normally. |
- EXPECT_SET_NEEDS_ANIMATE_INPUT(1); |
- EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_)) |
- .WillOnce(testing::Return(cc::InputHandler::SCROLL_STARTED)); |
- EXPECT_CALL(mock_input_handler_, |
- ScrollBy(testing::_, |
- testing::Property(&gfx::Vector2dF::y, testing::Gt(0)))) |
- .WillOnce(testing::Return(scroll_result_did_scroll_)); |
- EXPECT_CALL(mock_input_handler_, ScrollEnd()); |
- time += base::TimeDelta::FromMilliseconds(100); |
- Animate(time); |
- |
- VERIFY_AND_RESET_MOCKS(); |
- |
- // Then abort the second fling. |
- EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_)) |
- .WillOnce(testing::Return(cc::InputHandler::SCROLL_ON_MAIN_THREAD)); |
- EXPECT_CALL(mock_input_handler_, ScrollBy(testing::_, testing::_)).Times(0); |
- EXPECT_CALL(mock_input_handler_, ScrollEnd()).Times(0); |
- |
- // We should get parameters from the second fling, nothing from the first |
- // fling should "leak". |
- EXPECT_CALL( |
- mock_client_, |
- TransferActiveWheelFlingAnimation(testing::AllOf( |
- testing::Field(&WebActiveWheelFlingParameters::delta, |
- testing::Eq(fling_delta)), |
- testing::Field(&WebActiveWheelFlingParameters::point, |
- testing::Eq(fling_point)), |
- testing::Field(&WebActiveWheelFlingParameters::globalPoint, |
- testing::Eq(fling_global_point)), |
- testing::Field(&WebActiveWheelFlingParameters::modifiers, |
- testing::Eq(modifiers)), |
- testing::Field(&WebActiveWheelFlingParameters::startTime, |
- testing::Eq(30)), |
- testing::Field(&WebActiveWheelFlingParameters::cumulativeScroll, |
- testing::Field(&WebSize::height, testing::Lt(0)))))); |
- time += base::TimeDelta::FromMilliseconds(100); |
- Animate(time); |
- |
- VERIFY_AND_RESET_MOCKS(); |
-} |
- |
-TEST_P(InputHandlerProxyTest, GestureFlingStartedTouchscreen) { |
- // We shouldn't send any events to the widget for this gesture. |
- expected_disposition_ = InputHandlerProxy::DID_HANDLE; |
- VERIFY_AND_RESET_MOCKS(); |
- |
- EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_)) |
- .WillOnce(testing::Return(cc::InputHandler::SCROLL_STARTED)); |
- gesture_.type = WebInputEvent::GestureScrollBegin; |
- gesture_.sourceDevice = blink::WebGestureDeviceTouchscreen; |
- EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_)); |
- |
- VERIFY_AND_RESET_MOCKS(); |
- |
- EXPECT_CALL(mock_input_handler_, FlingScrollBegin()) |
- .WillOnce(testing::Return(cc::InputHandler::SCROLL_STARTED)); |
- EXPECT_SET_NEEDS_ANIMATE_INPUT(1); |
- |
- gesture_.type = WebInputEvent::GestureFlingStart; |
- gesture_.data.flingStart.velocityX = 10; |
- gesture_.sourceDevice = blink::WebGestureDeviceTouchscreen; |
- EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_)); |
- |
- VERIFY_AND_RESET_MOCKS(); |
- |
- EXPECT_CALL(mock_input_handler_, ScrollEnd()); |
- |
- // Verify that a GestureFlingCancel during an animation cancels it. |
- gesture_.type = WebInputEvent::GestureFlingCancel; |
- gesture_.sourceDevice = blink::WebGestureDeviceTouchscreen; |
- EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_)); |
- |
- VERIFY_AND_RESET_MOCKS(); |
-} |
- |
-TEST_P(InputHandlerProxyTest, GestureFlingOnMainThreadTouchscreen) { |
- // We should send all events to the widget for this gesture. |
- expected_disposition_ = InputHandlerProxy::DID_NOT_HANDLE; |
- VERIFY_AND_RESET_MOCKS(); |
- |
- EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_)) |
- .WillOnce(testing::Return(cc::InputHandler::SCROLL_ON_MAIN_THREAD)); |
- |
- gesture_.type = WebInputEvent::GestureScrollBegin; |
- EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_)); |
- |
- VERIFY_AND_RESET_MOCKS(); |
- |
- EXPECT_CALL(mock_input_handler_, FlingScrollBegin()).Times(0); |
- |
- gesture_.type = WebInputEvent::GestureFlingStart; |
- gesture_.sourceDevice = blink::WebGestureDeviceTouchscreen; |
- EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_)); |
- |
- VERIFY_AND_RESET_MOCKS(); |
- |
- // Even if we didn't start a fling ourselves, we still need to send the cancel |
- // event to the widget. |
- gesture_.type = WebInputEvent::GestureFlingCancel; |
- gesture_.sourceDevice = blink::WebGestureDeviceTouchscreen; |
- EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_)); |
-} |
- |
-TEST_P(InputHandlerProxyTest, GestureFlingIgnoredTouchscreen) { |
- expected_disposition_ = InputHandlerProxy::DID_HANDLE; |
- VERIFY_AND_RESET_MOCKS(); |
- |
- EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_)) |
- .WillOnce(testing::Return(cc::InputHandler::SCROLL_STARTED)); |
- |
- gesture_.type = WebInputEvent::GestureScrollBegin; |
- gesture_.sourceDevice = blink::WebGestureDeviceTouchscreen; |
- EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_)); |
- |
- expected_disposition_ = InputHandlerProxy::DROP_EVENT; |
- VERIFY_AND_RESET_MOCKS(); |
- |
- // Flings ignored by the InputHandler should be dropped, signalling the end |
- // of the touch scroll sequence. |
- EXPECT_CALL(mock_input_handler_, FlingScrollBegin()) |
- .WillOnce(testing::Return(cc::InputHandler::SCROLL_IGNORED)); |
- |
- gesture_.type = WebInputEvent::GestureFlingStart; |
- gesture_.sourceDevice = blink::WebGestureDeviceTouchscreen; |
- EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_)); |
- |
- VERIFY_AND_RESET_MOCKS(); |
- |
- // Subsequent scrolls should behave normally, even without an intervening |
- // GestureFlingCancel, as the original GestureFlingStart was dropped. |
- expected_disposition_ = InputHandlerProxy::DID_HANDLE; |
- EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_)) |
- .WillOnce(testing::Return(cc::InputHandler::SCROLL_STARTED)); |
- gesture_.type = WebInputEvent::GestureScrollBegin; |
- gesture_.sourceDevice = blink::WebGestureDeviceTouchscreen; |
- EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_)); |
- |
- VERIFY_AND_RESET_MOCKS(); |
-} |
- |
-TEST_P(InputHandlerProxyTest, GestureFlingAnimatesTouchscreen) { |
- // We shouldn't send any events to the widget for this gesture. |
- expected_disposition_ = InputHandlerProxy::DID_HANDLE; |
- VERIFY_AND_RESET_MOCKS(); |
- |
- EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_)) |
- .WillOnce(testing::Return(cc::InputHandler::SCROLL_STARTED)); |
- |
- gesture_.type = WebInputEvent::GestureScrollBegin; |
- gesture_.sourceDevice = blink::WebGestureDeviceTouchscreen; |
- EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_)); |
- |
- VERIFY_AND_RESET_MOCKS(); |
- |
- // On the fling start, we should schedule an animation but not actually start |
- // scrolling. |
- WebFloatPoint fling_delta = WebFloatPoint(100, 0); |
- WebPoint fling_point = WebPoint(7, 13); |
- WebPoint fling_global_point = WebPoint(17, 23); |
- // Note that for touchscreen the control modifier is not special. |
- int modifiers = WebInputEvent::ControlKey; |
- gesture_ = CreateFling(blink::WebGestureDeviceTouchscreen, |
- fling_delta, |
- fling_point, |
- fling_global_point, |
- modifiers); |
- EXPECT_SET_NEEDS_ANIMATE_INPUT(1); |
- EXPECT_CALL(mock_input_handler_, FlingScrollBegin()) |
- .WillOnce(testing::Return(cc::InputHandler::SCROLL_STARTED)); |
- EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_)); |
- |
- VERIFY_AND_RESET_MOCKS(); |
- // The first animate call should let us pick up an animation start time, but |
- // we shouldn't actually move anywhere just yet. The first frame after the |
- // fling start will typically include the last scroll from the gesture that |
- // lead to the scroll (either wheel or gesture scroll), so there should be no |
- // visible hitch. |
- EXPECT_SET_NEEDS_ANIMATE_INPUT(1); |
- base::TimeTicks time = base::TimeTicks() + base::TimeDelta::FromSeconds(10); |
- Animate(time); |
- |
- VERIFY_AND_RESET_MOCKS(); |
- |
- // The second call should start scrolling in the -X direction. |
- EXPECT_SET_NEEDS_ANIMATE_INPUT(1); |
- EXPECT_CALL(mock_input_handler_, |
- ScrollBy(testing::_, |
- testing::Property(&gfx::Vector2dF::x, testing::Lt(0)))) |
- .WillOnce(testing::Return(scroll_result_did_scroll_)); |
- time += base::TimeDelta::FromMilliseconds(100); |
- Animate(time); |
- |
- VERIFY_AND_RESET_MOCKS(); |
- |
- EXPECT_CALL(mock_input_handler_, ScrollEnd()); |
- gesture_.type = WebInputEvent::GestureFlingCancel; |
- EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_)); |
- |
- VERIFY_AND_RESET_MOCKS(); |
-} |
- |
-TEST_P(InputHandlerProxyTest, GestureFlingWithValidTimestamp) { |
- // We shouldn't send any events to the widget for this gesture. |
- expected_disposition_ = InputHandlerProxy::DID_HANDLE; |
- VERIFY_AND_RESET_MOCKS(); |
- |
- EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_)) |
- .WillOnce(testing::Return(cc::InputHandler::SCROLL_STARTED)); |
- |
- gesture_.type = WebInputEvent::GestureScrollBegin; |
- gesture_.sourceDevice = blink::WebGestureDeviceTouchscreen; |
- EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_)); |
- |
- VERIFY_AND_RESET_MOCKS(); |
- |
- // On the fling start, we should schedule an animation but not actually start |
- // scrolling. |
- base::TimeDelta dt = base::TimeDelta::FromMilliseconds(10); |
- base::TimeTicks time = base::TimeTicks() + dt; |
- WebFloatPoint fling_delta = WebFloatPoint(100, 0); |
- WebPoint fling_point = WebPoint(7, 13); |
- WebPoint fling_global_point = WebPoint(17, 23); |
- int modifiers = WebInputEvent::ControlKey; |
- gesture_ = CreateFling(time, |
- blink::WebGestureDeviceTouchscreen, |
- fling_delta, |
- fling_point, |
- fling_global_point, |
- modifiers); |
- EXPECT_SET_NEEDS_ANIMATE_INPUT(1); |
- EXPECT_CALL(mock_input_handler_, FlingScrollBegin()) |
- .WillOnce(testing::Return(cc::InputHandler::SCROLL_STARTED)); |
- EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_)); |
- |
- VERIFY_AND_RESET_MOCKS(); |
- // With a valid time stamp, the first animate call should skip start time |
- // initialization and immediately begin scroll update production. This reduces |
- // the likelihood of a hitch between the scroll preceding the fling and |
- // the first scroll generated by the fling. |
- // Scrolling should start in the -X direction. |
- EXPECT_SET_NEEDS_ANIMATE_INPUT(1); |
- EXPECT_CALL(mock_input_handler_, |
- ScrollBy(testing::_, |
- testing::Property(&gfx::Vector2dF::x, testing::Lt(0)))) |
- .WillOnce(testing::Return(scroll_result_did_scroll_)); |
- time += dt; |
- Animate(time); |
- |
- VERIFY_AND_RESET_MOCKS(); |
- |
- EXPECT_CALL(mock_input_handler_, ScrollEnd()); |
- gesture_.type = WebInputEvent::GestureFlingCancel; |
- EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_)); |
- |
- VERIFY_AND_RESET_MOCKS(); |
-} |
- |
-TEST_P(InputHandlerProxyTest, GestureFlingWithInvalidTimestamp) { |
- // We shouldn't send any events to the widget for this gesture. |
- expected_disposition_ = InputHandlerProxy::DID_HANDLE; |
- VERIFY_AND_RESET_MOCKS(); |
- |
- EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_)) |
- .WillOnce(testing::Return(cc::InputHandler::SCROLL_STARTED)); |
- |
- gesture_.type = WebInputEvent::GestureScrollBegin; |
- gesture_.sourceDevice = blink::WebGestureDeviceTouchscreen; |
- EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_)); |
- |
- VERIFY_AND_RESET_MOCKS(); |
- |
- // On the fling start, we should schedule an animation but not actually start |
- // scrolling. |
- base::TimeDelta start_time_offset = base::TimeDelta::FromMilliseconds(10); |
- gesture_.type = WebInputEvent::GestureFlingStart; |
- WebFloatPoint fling_delta = WebFloatPoint(100, 0); |
- WebPoint fling_point = WebPoint(7, 13); |
- WebPoint fling_global_point = WebPoint(17, 23); |
- int modifiers = WebInputEvent::ControlKey; |
- gesture_.timeStampSeconds = start_time_offset.InSecondsF(); |
- gesture_.data.flingStart.velocityX = fling_delta.x; |
- gesture_.data.flingStart.velocityY = fling_delta.y; |
- gesture_.sourceDevice = blink::WebGestureDeviceTouchscreen; |
- gesture_.x = fling_point.x; |
- gesture_.y = fling_point.y; |
- gesture_.globalX = fling_global_point.x; |
- gesture_.globalY = fling_global_point.y; |
- gesture_.modifiers = modifiers; |
- EXPECT_SET_NEEDS_ANIMATE_INPUT(1); |
- EXPECT_CALL(mock_input_handler_, FlingScrollBegin()) |
- .WillOnce(testing::Return(cc::InputHandler::SCROLL_STARTED)); |
- EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_)); |
- |
- VERIFY_AND_RESET_MOCKS(); |
- // Event though a time stamp was provided for the fling event, it will be |
- // ignored as its too far in the past relative to the first animate call's |
- // timestamp. |
- EXPECT_SET_NEEDS_ANIMATE_INPUT(1); |
- base::TimeTicks time = |
- base::TimeTicks() + start_time_offset + base::TimeDelta::FromSeconds(1); |
- Animate(time); |
- |
- VERIFY_AND_RESET_MOCKS(); |
- |
- // Further animation ticks should update the fling as usual. |
- EXPECT_SET_NEEDS_ANIMATE_INPUT(1); |
- EXPECT_CALL(mock_input_handler_, |
- ScrollBy(testing::_, |
- testing::Property(&gfx::Vector2dF::x, testing::Lt(0)))) |
- .WillOnce(testing::Return(scroll_result_did_scroll_)); |
- time += base::TimeDelta::FromMilliseconds(10); |
- Animate(time); |
- |
- VERIFY_AND_RESET_MOCKS(); |
- |
- EXPECT_CALL(mock_input_handler_, ScrollEnd()); |
- gesture_.type = WebInputEvent::GestureFlingCancel; |
- EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_)); |
- |
- VERIFY_AND_RESET_MOCKS(); |
-} |
- |
-TEST_P(InputHandlerProxyTest, GestureScrollOnImplThreadFlagClearedAfterFling) { |
- // We shouldn't send any events to the widget for this gesture. |
- expected_disposition_ = InputHandlerProxy::DID_HANDLE; |
- VERIFY_AND_RESET_MOCKS(); |
- |
- EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_)) |
- .WillOnce(testing::Return(cc::InputHandler::SCROLL_STARTED)); |
- |
- gesture_.type = WebInputEvent::GestureScrollBegin; |
- EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_)); |
- |
- // After sending a GestureScrollBegin, the member variable |
- // |gesture_scroll_on_impl_thread_| should be true. |
- EXPECT_TRUE(input_handler_->gesture_scroll_on_impl_thread_for_testing()); |
- |
- expected_disposition_ = InputHandlerProxy::DID_HANDLE; |
- VERIFY_AND_RESET_MOCKS(); |
- |
- // On the fling start, we should schedule an animation but not actually start |
- // scrolling. |
- WebFloatPoint fling_delta = WebFloatPoint(100, 0); |
- WebPoint fling_point = WebPoint(7, 13); |
- WebPoint fling_global_point = WebPoint(17, 23); |
- int modifiers = WebInputEvent::ControlKey | WebInputEvent::AltKey; |
- gesture_ = CreateFling(blink::WebGestureDeviceTouchscreen, |
- fling_delta, |
- fling_point, |
- fling_global_point, |
- modifiers); |
- EXPECT_SET_NEEDS_ANIMATE_INPUT(1); |
- EXPECT_CALL(mock_input_handler_, FlingScrollBegin()) |
- .WillOnce(testing::Return(cc::InputHandler::SCROLL_STARTED)); |
- EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_)); |
- |
- // |gesture_scroll_on_impl_thread_| should still be true after |
- // a GestureFlingStart is sent. |
- EXPECT_TRUE(input_handler_->gesture_scroll_on_impl_thread_for_testing()); |
- |
- VERIFY_AND_RESET_MOCKS(); |
- // The first animate call should let us pick up an animation start time, but |
- // we shouldn't actually move anywhere just yet. The first frame after the |
- // fling start will typically include the last scroll from the gesture that |
- // lead to the scroll (either wheel or gesture scroll), so there should be no |
- // visible hitch. |
- EXPECT_SET_NEEDS_ANIMATE_INPUT(1); |
- base::TimeTicks time = base::TimeTicks() + base::TimeDelta::FromSeconds(10); |
- Animate(time); |
- |
- VERIFY_AND_RESET_MOCKS(); |
- |
- // The second call should start scrolling in the -X direction. |
- EXPECT_SET_NEEDS_ANIMATE_INPUT(1); |
- EXPECT_CALL(mock_input_handler_, |
- ScrollBy(testing::_, |
- testing::Property(&gfx::Vector2dF::x, testing::Lt(0)))) |
- .WillOnce(testing::Return(scroll_result_did_scroll_)); |
- time += base::TimeDelta::FromMilliseconds(100); |
- Animate(time); |
- |
- VERIFY_AND_RESET_MOCKS(); |
- |
- EXPECT_CALL(mock_input_handler_, ScrollEnd()); |
- gesture_.type = WebInputEvent::GestureFlingCancel; |
- EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_)); |
- |
- // |gesture_scroll_on_impl_thread_| should be false once |
- // the fling has finished (note no GestureScrollEnd has been sent). |
- EXPECT_TRUE(!input_handler_->gesture_scroll_on_impl_thread_for_testing()); |
- |
- VERIFY_AND_RESET_MOCKS(); |
-} |
- |
-TEST_P(InputHandlerProxyTest, |
- BeginScrollWhenGestureScrollOnImplThreadFlagIsSet) { |
- // We shouldn't send any events to the widget for this gesture. |
- expected_disposition_ = InputHandlerProxy::DID_HANDLE; |
- VERIFY_AND_RESET_MOCKS(); |
- |
- EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_)) |
- .WillOnce(testing::Return(cc::InputHandler::SCROLL_STARTED)); |
- |
- gesture_.type = WebInputEvent::GestureScrollBegin; |
- EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_)); |
- |
- // After sending a GestureScrollBegin, the member variable |
- // |gesture_scroll_on_impl_thread_| should be true. |
- EXPECT_TRUE(input_handler_->gesture_scroll_on_impl_thread_for_testing()); |
- |
- expected_disposition_ = InputHandlerProxy::DID_HANDLE; |
- VERIFY_AND_RESET_MOCKS(); |
- |
- // On the fling start, we should schedule an animation but not actually start |
- // scrolling. |
- WebFloatPoint fling_delta = WebFloatPoint(100, 0); |
- WebPoint fling_point = WebPoint(7, 13); |
- WebPoint fling_global_point = WebPoint(17, 23); |
- int modifiers = WebInputEvent::ControlKey | WebInputEvent::AltKey; |
- gesture_ = CreateFling(blink::WebGestureDeviceTouchscreen, fling_delta, |
- fling_point, fling_global_point, modifiers); |
- EXPECT_SET_NEEDS_ANIMATE_INPUT(1); |
- EXPECT_CALL(mock_input_handler_, FlingScrollBegin()) |
- .WillOnce(testing::Return(cc::InputHandler::SCROLL_STARTED)); |
- EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_)); |
- |
- // |gesture_scroll_on_impl_thread_| should still be true after |
- // a GestureFlingStart is sent. |
- EXPECT_TRUE(input_handler_->gesture_scroll_on_impl_thread_for_testing()); |
- |
- VERIFY_AND_RESET_MOCKS(); |
- |
- // gesture_scroll_on_impl_thread_ is still true when this scroll begins. As a |
- // result, this scroll begin will cancel the previous fling. |
- EXPECT_CALL(mock_input_handler_, ScrollEnd()); |
- EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_)) |
- .WillOnce(testing::Return(cc::InputHandler::SCROLL_STARTED)); |
- |
- gesture_.type = WebInputEvent::GestureScrollBegin; |
- EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_)); |
- |
- // After sending a GestureScrollBegin, the member variable |
- // |gesture_scroll_on_impl_thread_| should be true. |
- EXPECT_TRUE(input_handler_->gesture_scroll_on_impl_thread_for_testing()); |
- VERIFY_AND_RESET_MOCKS(); |
-} |
- |
-TEST_P(InputHandlerProxyTest, GestureFlingStopsAtContentEdge) { |
- // We shouldn't send any events to the widget for this gesture. |
- expected_disposition_ = InputHandlerProxy::DID_HANDLE; |
- VERIFY_AND_RESET_MOCKS(); |
- |
- // On the fling start, we should schedule an animation but not actually start |
- // scrolling. |
- gesture_.type = WebInputEvent::GestureFlingStart; |
- WebFloatPoint fling_delta = WebFloatPoint(100, 100); |
- gesture_.data.flingStart.velocityX = fling_delta.x; |
- gesture_.data.flingStart.velocityY = fling_delta.y; |
- EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_)) |
- .WillOnce(testing::Return(cc::InputHandler::SCROLL_STARTED)); |
- EXPECT_CALL(mock_input_handler_, ScrollEnd()); |
- EXPECT_SET_NEEDS_ANIMATE_INPUT(1); |
- EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_)); |
- VERIFY_AND_RESET_MOCKS(); |
- |
- // The first animate doesn't cause any scrolling. |
- EXPECT_SET_NEEDS_ANIMATE_INPUT(1); |
- base::TimeTicks time = base::TimeTicks() + base::TimeDelta::FromSeconds(10); |
- Animate(time); |
- VERIFY_AND_RESET_MOCKS(); |
- |
- // The second animate starts scrolling in the positive X and Y directions. |
- EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_)) |
- .WillOnce(testing::Return(cc::InputHandler::SCROLL_STARTED)); |
- EXPECT_CALL(mock_input_handler_, |
- ScrollBy(testing::_, |
- testing::Property(&gfx::Vector2dF::y, testing::Lt(0)))) |
- .WillOnce(testing::Return(scroll_result_did_scroll_)); |
- EXPECT_CALL(mock_input_handler_, ScrollEnd()); |
- EXPECT_SET_NEEDS_ANIMATE_INPUT(1); |
- time += base::TimeDelta::FromMilliseconds(100); |
- Animate(time); |
- VERIFY_AND_RESET_MOCKS(); |
- |
- // The third animate overscrolls in the positive Y direction but scrolls |
- // somewhat. |
- cc::InputHandlerScrollResult overscroll; |
- overscroll.did_scroll = true; |
- overscroll.did_overscroll_root = true; |
- overscroll.accumulated_root_overscroll = gfx::Vector2dF(0, 100); |
- overscroll.unused_scroll_delta = gfx::Vector2dF(0, 10); |
- EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_)) |
- .WillOnce(testing::Return(cc::InputHandler::SCROLL_STARTED)); |
- EXPECT_CALL(mock_input_handler_, |
- ScrollBy(testing::_, |
- testing::Property(&gfx::Vector2dF::y, testing::Lt(0)))) |
- .WillOnce(testing::Return(overscroll)); |
- EXPECT_CALL( |
- mock_client_, |
- DidOverscroll(testing::AllOf( |
- testing::Field( |
- &DidOverscrollParams::accumulated_overscroll, |
- testing::Eq(overscroll.accumulated_root_overscroll)), |
- testing::Field( |
- &DidOverscrollParams::latest_overscroll_delta, |
- testing::Eq(overscroll.unused_scroll_delta)), |
- testing::Field( |
- &DidOverscrollParams::current_fling_velocity, |
- testing::Property(&gfx::Vector2dF::y, testing::Lt(0)))))); |
- EXPECT_CALL(mock_input_handler_, ScrollEnd()); |
- 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_, ScrollBegin(testing::_, testing::_)) |
- .WillOnce(testing::Return(cc::InputHandler::SCROLL_STARTED)); |
- EXPECT_CALL(mock_input_handler_, |
- ScrollBy(testing::_, |
- testing::Property(&gfx::Vector2dF::y, testing::Eq(0)))) |
- .WillOnce(testing::Return(scroll_result_did_scroll_)); |
- EXPECT_CALL(mock_input_handler_, ScrollEnd()); |
- time += base::TimeDelta::FromMilliseconds(100); |
- Animate(time); |
- VERIFY_AND_RESET_MOCKS(); |
-} |
- |
-TEST_P(InputHandlerProxyTest, GestureFlingNotCancelledBySmallTimeDelta) { |
- // We shouldn't send any events to the widget for this gesture. |
- expected_disposition_ = InputHandlerProxy::DID_HANDLE; |
- VERIFY_AND_RESET_MOCKS(); |
- |
- EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_)) |
- .WillOnce(testing::Return(cc::InputHandler::SCROLL_STARTED)); |
- |
- gesture_.type = WebInputEvent::GestureScrollBegin; |
- gesture_.sourceDevice = blink::WebGestureDeviceTouchscreen; |
- EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_)); |
- |
- VERIFY_AND_RESET_MOCKS(); |
- |
- // On the fling start, we should schedule an animation but not actually start |
- // scrolling. |
- base::TimeDelta dt = base::TimeDelta::FromMilliseconds(10); |
- base::TimeTicks time = base::TimeTicks() + dt; |
- WebFloatPoint fling_delta = WebFloatPoint(100, 0); |
- WebPoint fling_point = WebPoint(7, 13); |
- WebPoint fling_global_point = WebPoint(17, 23); |
- int modifiers = WebInputEvent::ControlKey; |
- gesture_ = CreateFling(time, |
- blink::WebGestureDeviceTouchscreen, |
- fling_delta, |
- fling_point, |
- fling_global_point, |
- modifiers); |
- EXPECT_SET_NEEDS_ANIMATE_INPUT(1); |
- EXPECT_CALL(mock_input_handler_, FlingScrollBegin()) |
- .WillOnce(testing::Return(cc::InputHandler::SCROLL_STARTED)); |
- EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_)); |
- |
- VERIFY_AND_RESET_MOCKS(); |
- // With an animation timestamp equivalent to the starting timestamp, the |
- // animation will simply be rescheduled. |
- EXPECT_SET_NEEDS_ANIMATE_INPUT(1); |
- Animate(time); |
- |
- VERIFY_AND_RESET_MOCKS(); |
- EXPECT_TRUE(input_handler_->gesture_scroll_on_impl_thread_for_testing()); |
- |
- // A small time delta should not stop the fling, even if the client |
- // reports no scrolling. |
- EXPECT_SET_NEEDS_ANIMATE_INPUT(1); |
- EXPECT_CALL(mock_input_handler_, |
- ScrollBy(testing::_, |
- testing::Property(&gfx::Vector2dF::x, testing::Lt(0)))) |
- .WillOnce(testing::Return(scroll_result_did_not_scroll_)); |
- time += base::TimeDelta::FromMicroseconds(5); |
- Animate(time); |
- |
- VERIFY_AND_RESET_MOCKS(); |
- EXPECT_TRUE(input_handler_->gesture_scroll_on_impl_thread_for_testing()); |
- |
- // A time delta of zero should not stop the fling, and neither should it |
- // trigger scrolling on the client. |
- EXPECT_SET_NEEDS_ANIMATE_INPUT(1); |
- Animate(time); |
- |
- VERIFY_AND_RESET_MOCKS(); |
- EXPECT_TRUE(input_handler_->gesture_scroll_on_impl_thread_for_testing()); |
- |
- // Lack of movement on the client, with a non-trivial scroll delta, should |
- // terminate the fling. |
- EXPECT_CALL(mock_input_handler_, ScrollEnd()); |
- EXPECT_CALL(mock_input_handler_, |
- ScrollBy(testing::_, |
- testing::Property(&gfx::Vector2dF::x, testing::Lt(1)))) |
- .WillOnce(testing::Return(scroll_result_did_not_scroll_)); |
- time += base::TimeDelta::FromMilliseconds(100); |
- Animate(time); |
- |
- VERIFY_AND_RESET_MOCKS(); |
- EXPECT_FALSE(input_handler_->gesture_scroll_on_impl_thread_for_testing()); |
-} |
- |
-TEST_P(InputHandlerProxyTest, GestureFlingCancelledAfterBothAxesStopScrolling) { |
- cc::InputHandlerScrollResult overscroll; |
- overscroll.did_scroll = true; |
- overscroll.did_overscroll_root = true; |
- |
- // We shouldn't send any events to the widget for this gesture. |
- expected_disposition_ = InputHandlerProxy::DID_HANDLE; |
- VERIFY_AND_RESET_MOCKS(); |
- |
- EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_)) |
- .WillOnce(testing::Return(cc::InputHandler::SCROLL_STARTED)); |
- gesture_.type = WebInputEvent::GestureScrollBegin; |
- gesture_.sourceDevice = blink::WebGestureDeviceTouchscreen; |
- EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_)); |
- VERIFY_AND_RESET_MOCKS(); |
- |
- // On the fling start, we should schedule an animation but not actually start |
- // scrolling. |
- gesture_.type = WebInputEvent::GestureFlingStart; |
- WebFloatPoint fling_delta = WebFloatPoint(100, 100); |
- gesture_.data.flingStart.velocityX = fling_delta.x; |
- gesture_.data.flingStart.velocityY = fling_delta.y; |
- EXPECT_CALL(mock_input_handler_, FlingScrollBegin()) |
- .WillOnce(testing::Return(cc::InputHandler::SCROLL_STARTED)); |
- EXPECT_SET_NEEDS_ANIMATE_INPUT(1); |
- EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_)); |
- VERIFY_AND_RESET_MOCKS(); |
- |
- // The first animate doesn't cause any scrolling. |
- EXPECT_SET_NEEDS_ANIMATE_INPUT(1); |
- base::TimeTicks time = base::TimeTicks() + base::TimeDelta::FromSeconds(10); |
- Animate(time); |
- VERIFY_AND_RESET_MOCKS(); |
- |
- // The second animate starts scrolling in the positive X and Y directions. |
- EXPECT_SET_NEEDS_ANIMATE_INPUT(1); |
- EXPECT_CALL(mock_input_handler_, |
- ScrollBy(testing::_, |
- testing::Property(&gfx::Vector2dF::y, testing::Lt(0)))) |
- .WillOnce(testing::Return(scroll_result_did_scroll_)); |
- time += base::TimeDelta::FromMilliseconds(10); |
- Animate(time); |
- VERIFY_AND_RESET_MOCKS(); |
- |
- // 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::_, |
- testing::Property(&gfx::Vector2dF::y, testing::Lt(0)))) |
- .WillOnce(testing::Return(overscroll)); |
- EXPECT_CALL( |
- mock_client_, |
- DidOverscroll(testing::AllOf( |
- testing::Field( |
- &DidOverscrollParams::accumulated_overscroll, |
- testing::Eq(overscroll.accumulated_root_overscroll)), |
- testing::Field( |
- &DidOverscrollParams::latest_overscroll_delta, |
- testing::Eq(overscroll.unused_scroll_delta)), |
- testing::Field( |
- &DidOverscrollParams::current_fling_velocity, |
- testing::Property(&gfx::Vector2dF::y, testing::Lt(0)))))); |
- 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::_, |
- testing::Property(&gfx::Vector2dF::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::_, |
- testing::Property(&gfx::Vector2dF::x, testing::Lt(0)))) |
- .WillOnce(testing::Return(overscroll)); |
- EXPECT_CALL( |
- mock_client_, |
- DidOverscroll(testing::AllOf( |
- testing::Field( |
- &DidOverscrollParams::accumulated_overscroll, |
- testing::Eq(overscroll.accumulated_root_overscroll)), |
- testing::Field( |
- &DidOverscrollParams::latest_overscroll_delta, |
- testing::Eq(overscroll.unused_scroll_delta)), |
- testing::Field( |
- &DidOverscrollParams::current_fling_velocity, |
- testing::Property(&gfx::Vector2dF::x, testing::Lt(0)))))); |
- EXPECT_CALL(mock_input_handler_, ScrollEnd()); |
- 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::_, testing::_)).Times(0); |
- time += base::TimeDelta::FromMilliseconds(10); |
- Animate(time); |
- VERIFY_AND_RESET_MOCKS(); |
- EXPECT_FALSE(input_handler_->gesture_scroll_on_impl_thread_for_testing()); |
-} |
- |
-TEST_P(InputHandlerProxyTest, MultiTouchPointHitTestNegative) { |
- // None of the three touch points fall in the touch region. So the event |
- // should be dropped. |
- expected_disposition_ = InputHandlerProxy::DROP_EVENT; |
- VERIFY_AND_RESET_MOCKS(); |
- |
- EXPECT_CALL(mock_input_handler_, |
- DoTouchEventsBlockScrollAt( |
- testing::Property(&gfx::Point::x, testing::Gt(0)))) |
- .WillOnce(testing::Return(false)); |
- EXPECT_CALL(mock_input_handler_, |
- DoTouchEventsBlockScrollAt( |
- testing::Property(&gfx::Point::x, testing::Lt(0)))) |
- .WillOnce(testing::Return(false)); |
- |
- WebTouchEvent touch; |
- touch.type = WebInputEvent::TouchStart; |
- |
- touch.touchesLength = 3; |
- touch.touches[0] = CreateWebTouchPoint(WebTouchPoint::StateStationary, 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)); |
- |
- VERIFY_AND_RESET_MOCKS(); |
-} |
- |
-TEST_P(InputHandlerProxyTest, MultiTouchPointHitTestPositive) { |
- // One of the touch points is on a touch-region. So the event should be sent |
- // to the main thread. |
- expected_disposition_ = InputHandlerProxy::DID_NOT_HANDLE; |
- VERIFY_AND_RESET_MOCKS(); |
- |
- EXPECT_CALL(mock_input_handler_, |
- DoTouchEventsBlockScrollAt( |
- testing::Property(&gfx::Point::x, testing::Eq(0)))) |
- .WillOnce(testing::Return(false)); |
- EXPECT_CALL(mock_input_handler_, |
- DoTouchEventsBlockScrollAt( |
- testing::Property(&gfx::Point::x, testing::Gt(0)))) |
- .WillOnce(testing::Return(true)); |
- // Since the second touch point hits a touch-region, there should be no |
- // hit-testing for the third touch point. |
- |
- WebTouchEvent touch; |
- touch.type = WebInputEvent::TouchStart; |
- |
- 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)); |
- |
- VERIFY_AND_RESET_MOCKS(); |
-} |
- |
-TEST_P(InputHandlerProxyTest, GestureFlingCancelledByKeyboardEvent) { |
- // We shouldn't send any events to the widget for this gesture. |
- expected_disposition_ = InputHandlerProxy::DID_HANDLE; |
- VERIFY_AND_RESET_MOCKS(); |
- |
- EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_)) |
- .WillOnce(testing::Return(cc::InputHandler::SCROLL_STARTED)); |
- gesture_.type = WebInputEvent::GestureScrollBegin; |
- gesture_.sourceDevice = blink::WebGestureDeviceTouchscreen; |
- EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_)); |
- EXPECT_TRUE(input_handler_->gesture_scroll_on_impl_thread_for_testing()); |
- VERIFY_AND_RESET_MOCKS(); |
- |
- // Keyboard events received during a scroll should have no effect. |
- WebKeyboardEvent key_event; |
- key_event.type = WebInputEvent::KeyDown; |
- EXPECT_EQ(InputHandlerProxy::DID_NOT_HANDLE, |
- input_handler_->HandleInputEvent(key_event)); |
- EXPECT_TRUE(input_handler_->gesture_scroll_on_impl_thread_for_testing()); |
- VERIFY_AND_RESET_MOCKS(); |
- |
- // On the fling start, animation should be scheduled, but no scrolling occurs. |
- gesture_.type = WebInputEvent::GestureFlingStart; |
- WebFloatPoint fling_delta = WebFloatPoint(100, 100); |
- gesture_.data.flingStart.velocityX = fling_delta.x; |
- gesture_.data.flingStart.velocityY = fling_delta.y; |
- EXPECT_CALL(mock_input_handler_, FlingScrollBegin()) |
- .WillOnce(testing::Return(cc::InputHandler::SCROLL_STARTED)); |
- EXPECT_SET_NEEDS_ANIMATE_INPUT(1); |
- EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_)); |
- EXPECT_TRUE(input_handler_->gesture_scroll_on_impl_thread_for_testing()); |
- VERIFY_AND_RESET_MOCKS(); |
- |
- // Keyboard events received during a fling should cancel the active fling. |
- EXPECT_CALL(mock_input_handler_, ScrollEnd()); |
- EXPECT_EQ(InputHandlerProxy::DID_NOT_HANDLE, |
- input_handler_->HandleInputEvent(key_event)); |
- EXPECT_FALSE(input_handler_->gesture_scroll_on_impl_thread_for_testing()); |
- VERIFY_AND_RESET_MOCKS(); |
- |
- // The call to animate should have no effect, as the fling was cancelled. |
- base::TimeTicks time = base::TimeTicks() + base::TimeDelta::FromSeconds(10); |
- Animate(time); |
- VERIFY_AND_RESET_MOCKS(); |
- |
- // A fling cancel should be dropped, as there is nothing to cancel. |
- gesture_.type = WebInputEvent::GestureFlingCancel; |
- EXPECT_EQ(InputHandlerProxy::DROP_EVENT, |
- input_handler_->HandleInputEvent(gesture_)); |
- EXPECT_FALSE(input_handler_->gesture_scroll_on_impl_thread_for_testing()); |
-} |
- |
-TEST_P(InputHandlerProxyTest, GestureFlingWithNegativeTimeDelta) { |
- // We shouldn't send any events to the widget for this gesture. |
- expected_disposition_ = InputHandlerProxy::DID_HANDLE; |
- VERIFY_AND_RESET_MOCKS(); |
- |
- EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_)) |
- .WillOnce(testing::Return(cc::InputHandler::SCROLL_STARTED)); |
- |
- gesture_.type = WebInputEvent::GestureScrollBegin; |
- gesture_.sourceDevice = blink::WebGestureDeviceTouchscreen; |
- EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_)); |
- |
- VERIFY_AND_RESET_MOCKS(); |
- |
- // On the fling start, we should schedule an animation but not actually start |
- // scrolling. |
- base::TimeDelta dt = base::TimeDelta::FromMilliseconds(10); |
- base::TimeTicks time = base::TimeTicks() + dt; |
- WebFloatPoint fling_delta = WebFloatPoint(100, 0); |
- WebPoint fling_point = WebPoint(7, 13); |
- WebPoint fling_global_point = WebPoint(17, 23); |
- int modifiers = WebInputEvent::ControlKey; |
- gesture_ = CreateFling(time, |
- blink::WebGestureDeviceTouchscreen, |
- fling_delta, |
- fling_point, |
- fling_global_point, |
- modifiers); |
- EXPECT_SET_NEEDS_ANIMATE_INPUT(1); |
- EXPECT_CALL(mock_input_handler_, FlingScrollBegin()) |
- .WillOnce(testing::Return(cc::InputHandler::SCROLL_STARTED)); |
- EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_)); |
- |
- VERIFY_AND_RESET_MOCKS(); |
- |
- // If we get a negative time delta, that is, the Animation tick time happens |
- // before the fling's start time then we should *not* try scrolling and |
- // instead reset the fling start time. |
- EXPECT_SET_NEEDS_ANIMATE_INPUT(1); |
- EXPECT_CALL(mock_input_handler_, |
- ScrollBy(testing::_, |
- testing::_)).Times(0); |
- time -= base::TimeDelta::FromMilliseconds(5); |
- Animate(time); |
- |
- VERIFY_AND_RESET_MOCKS(); |
- |
- // The first call should have reset the start time so subsequent calls should |
- // generate scroll events. |
- EXPECT_SET_NEEDS_ANIMATE_INPUT(1); |
- EXPECT_CALL(mock_input_handler_, |
- ScrollBy(testing::_, |
- testing::Property(&gfx::Vector2dF::x, testing::Lt(0)))) |
- .WillOnce(testing::Return(scroll_result_did_scroll_)); |
- |
- Animate(time + base::TimeDelta::FromMilliseconds(1)); |
- |
- VERIFY_AND_RESET_MOCKS(); |
- |
- EXPECT_CALL(mock_input_handler_, ScrollEnd()); |
- gesture_.type = WebInputEvent::GestureFlingCancel; |
- EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_)); |
- |
- VERIFY_AND_RESET_MOCKS(); |
-} |
- |
-TEST_P(InputHandlerProxyTest, FlingBoost) { |
- base::TimeDelta dt = base::TimeDelta::FromMilliseconds(10); |
- base::TimeTicks time = base::TimeTicks() + dt; |
- base::TimeTicks last_animate_time = time; |
- WebFloatPoint fling_delta = WebFloatPoint(1000, 0); |
- WebPoint fling_point = WebPoint(7, 13); |
- StartFling( |
- time, blink::WebGestureDeviceTouchscreen, fling_delta, fling_point); |
- |
- // Now cancel the fling. The fling cancellation should be deferred to allow |
- // fling boosting events to arrive. |
- time += dt; |
- CancelFling(time); |
- |
- // The GestureScrollBegin should be swallowed by the fling if it hits the same |
- // scrolling layer. |
- EXPECT_CALL(mock_input_handler_, |
- IsCurrentlyScrollingLayerAt(testing::_, testing::_)) |
- .WillOnce(testing::Return(true)); |
- |
- time += dt; |
- gesture_.timeStampSeconds = InSecondsF(time); |
- gesture_.type = WebInputEvent::GestureScrollBegin; |
- EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_)); |
- |
- VERIFY_AND_RESET_MOCKS(); |
- |
- // Animate calls within the deferred cancellation window should continue. |
- time += dt; |
- float expected_delta = |
- (time - last_animate_time).InSecondsF() * -fling_delta.x; |
- EXPECT_SET_NEEDS_ANIMATE_INPUT(1); |
- EXPECT_CALL(mock_input_handler_, |
- ScrollBy(testing::_, |
- testing::Property(&gfx::Vector2dF::x, |
- testing::Eq(expected_delta)))) |
- .WillOnce(testing::Return(scroll_result_did_scroll_)); |
- Animate(time); |
- last_animate_time = time; |
- |
- VERIFY_AND_RESET_MOCKS(); |
- |
- // GestureScrollUpdates in the same direction and at sufficient speed should |
- // be swallowed by the fling. |
- time += dt; |
- gesture_.timeStampSeconds = InSecondsF(time); |
- gesture_.type = WebInputEvent::GestureScrollUpdate; |
- gesture_.data.scrollUpdate.deltaX = fling_delta.x; |
- EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_)); |
- |
- VERIFY_AND_RESET_MOCKS(); |
- |
- // Animate calls within the deferred cancellation window should continue. |
- time += dt; |
- expected_delta = (time - last_animate_time).InSecondsF() * -fling_delta.x; |
- EXPECT_SET_NEEDS_ANIMATE_INPUT(1); |
- EXPECT_CALL(mock_input_handler_, |
- ScrollBy(testing::_, |
- testing::Property(&gfx::Vector2dF::x, |
- testing::Eq(expected_delta)))) |
- .WillOnce(testing::Return(scroll_result_did_scroll_)); |
- Animate(time); |
- last_animate_time = time; |
- |
- VERIFY_AND_RESET_MOCKS(); |
- |
- // GestureFlingStart in the same direction and at sufficient speed should |
- // boost the active fling. |
- |
- gesture_ = CreateFling(time, |
- blink::WebGestureDeviceTouchscreen, |
- fling_delta, |
- fling_point, |
- fling_point, |
- 0); |
- EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_)); |
- VERIFY_AND_RESET_MOCKS(); |
- |
- time += dt; |
- // Note we get *2x* as much delta because 2 flings have combined. |
- expected_delta = 2 * (time - last_animate_time).InSecondsF() * -fling_delta.x; |
- EXPECT_SET_NEEDS_ANIMATE_INPUT(1); |
- EXPECT_CALL(mock_input_handler_, |
- ScrollBy(testing::_, |
- testing::Property(&gfx::Vector2dF::x, |
- testing::Eq(expected_delta)))) |
- .WillOnce(testing::Return(scroll_result_did_scroll_)); |
- Animate(time); |
- last_animate_time = time; |
- |
- VERIFY_AND_RESET_MOCKS(); |
- |
- // Repeated GestureFlingStarts should accumulate. |
- |
- CancelFling(time); |
- gesture_ = CreateFling(time, |
- blink::WebGestureDeviceTouchscreen, |
- fling_delta, |
- fling_point, |
- fling_point, |
- 0); |
- EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_)); |
- VERIFY_AND_RESET_MOCKS(); |
- |
- time += dt; |
- // Note we get *3x* as much delta because 3 flings have combined. |
- expected_delta = 3 * (time - last_animate_time).InSecondsF() * -fling_delta.x; |
- EXPECT_SET_NEEDS_ANIMATE_INPUT(1); |
- EXPECT_CALL(mock_input_handler_, |
- ScrollBy(testing::_, |
- testing::Property(&gfx::Vector2dF::x, |
- testing::Eq(expected_delta)))) |
- .WillOnce(testing::Return(scroll_result_did_scroll_)); |
- Animate(time); |
- last_animate_time = time; |
- |
- VERIFY_AND_RESET_MOCKS(); |
- |
- // GestureFlingCancel should terminate the fling if no boosting gestures are |
- // received within the timeout window. |
- |
- time += dt; |
- gesture_.timeStampSeconds = InSecondsF(time); |
- gesture_.type = WebInputEvent::GestureFlingCancel; |
- EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_)); |
- |
- VERIFY_AND_RESET_MOCKS(); |
- |
- time += base::TimeDelta::FromMilliseconds(100); |
- EXPECT_CALL(mock_input_handler_, ScrollEnd()); |
- Animate(time); |
- |
- VERIFY_AND_RESET_MOCKS(); |
-} |
- |
-TEST_P(InputHandlerProxyTest, NoFlingBoostIfScrollTargetsDifferentLayer) { |
- base::TimeDelta dt = base::TimeDelta::FromMilliseconds(10); |
- base::TimeTicks time = base::TimeTicks() + dt; |
- WebFloatPoint fling_delta = WebFloatPoint(1000, 0); |
- WebPoint fling_point = WebPoint(7, 13); |
- StartFling( |
- time, blink::WebGestureDeviceTouchscreen, fling_delta, fling_point); |
- |
- // Cancel the fling. The fling cancellation should be deferred to allow |
- // fling boosting events to arrive. |
- time += dt; |
- CancelFling(time); |
- |
- // If the GestureScrollBegin targets a different layer, the fling should be |
- // cancelled and the scroll should be handled as usual. |
- EXPECT_CALL(mock_input_handler_, |
- IsCurrentlyScrollingLayerAt(testing::_, testing::_)) |
- .WillOnce(testing::Return(false)); |
- EXPECT_CALL(mock_input_handler_, ScrollEnd()); |
- EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_)) |
- .WillOnce(testing::Return(cc::InputHandler::SCROLL_STARTED)); |
- |
- time += dt; |
- gesture_.timeStampSeconds = InSecondsF(time); |
- gesture_.type = WebInputEvent::GestureScrollBegin; |
- EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_)); |
- |
- VERIFY_AND_RESET_MOCKS(); |
-} |
- |
-TEST_P(InputHandlerProxyTest, NoFlingBoostIfScrollDelayed) { |
- base::TimeDelta dt = base::TimeDelta::FromMilliseconds(10); |
- base::TimeTicks time = base::TimeTicks() + dt; |
- WebFloatPoint fling_delta = WebFloatPoint(1000, 0); |
- WebPoint fling_point = WebPoint(7, 13); |
- StartFling( |
- time, blink::WebGestureDeviceTouchscreen, fling_delta, fling_point); |
- |
- // Cancel the fling. The fling cancellation should be deferred to allow |
- // fling boosting events to arrive. |
- time += dt; |
- CancelFling(time); |
- |
- // The GestureScrollBegin should be swallowed by the fling if it hits the same |
- // scrolling layer. |
- EXPECT_CALL(mock_input_handler_, |
- IsCurrentlyScrollingLayerAt(testing::_, testing::_)) |
- .WillOnce(testing::Return(true)); |
- |
- time += dt; |
- gesture_.timeStampSeconds = InSecondsF(time); |
- gesture_.type = WebInputEvent::GestureScrollBegin; |
- EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_)); |
- |
- VERIFY_AND_RESET_MOCKS(); |
- |
- // If no GestureScrollUpdate or GestureFlingStart is received within the |
- // timeout window, the fling should be cancelled and scrolling should resume. |
- time += base::TimeDelta::FromMilliseconds(100); |
- EXPECT_CALL(mock_input_handler_, ScrollEnd()); |
- EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_)) |
- .WillOnce(testing::Return(cc::InputHandler::SCROLL_STARTED)); |
- Animate(time); |
- |
- VERIFY_AND_RESET_MOCKS(); |
-} |
- |
-TEST_P(InputHandlerProxyTest, NoFlingBoostIfNotAnimated) { |
- base::TimeDelta dt = base::TimeDelta::FromMilliseconds(10); |
- base::TimeTicks time = base::TimeTicks() + dt; |
- WebFloatPoint fling_delta = WebFloatPoint(1000, 0); |
- WebPoint fling_point = WebPoint(7, 13); |
- StartFling( |
- time, blink::WebGestureDeviceTouchscreen, fling_delta, fling_point); |
- |
- // Animate fling once. |
- time += dt; |
- EXPECT_CALL(mock_input_handler_, ScrollBy(testing::_, testing::_)) |
- .WillOnce(testing::Return(scroll_result_did_scroll_)); |
- EXPECT_SET_NEEDS_ANIMATE_INPUT(1); |
- Animate(time); |
- |
- // Cancel the fling after long delay of no animate. The fling cancellation |
- // should be deferred to allow fling boosting events to arrive. |
- time += base::TimeDelta::FromMilliseconds(100); |
- CancelFling(time); |
- |
- // The GestureScrollBegin should be swallowed by the fling if it hits the same |
- // scrolling layer. |
- EXPECT_CALL(mock_input_handler_, |
- IsCurrentlyScrollingLayerAt(testing::_, testing::_)) |
- .WillOnce(testing::Return(true)); |
- |
- time += dt; |
- gesture_.timeStampSeconds = InSecondsF(time); |
- gesture_.type = WebInputEvent::GestureScrollBegin; |
- EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_)); |
- |
- VERIFY_AND_RESET_MOCKS(); |
- |
- // Should exit scroll bosting on GestureScrollUpdate due to long delay |
- // since last animate. Cancel old fling and start new scroll. |
- gesture_.type = WebInputEvent::GestureScrollUpdate; |
- gesture_.data.scrollUpdate.deltaY = -40; |
- EXPECT_CALL(mock_input_handler_, ScrollEnd()); |
- EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_)) |
- .WillOnce(testing::Return(cc::InputHandler::SCROLL_STARTED)); |
- EXPECT_CALL(mock_input_handler_, ScrollBy(testing::_, testing::_)) |
- .WillOnce(testing::Return(scroll_result_did_scroll_)); |
- EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_)); |
- |
- VERIFY_AND_RESET_MOCKS(); |
-} |
- |
-TEST_P(InputHandlerProxyTest, NoFlingBoostIfFlingInDifferentDirection) { |
- base::TimeDelta dt = base::TimeDelta::FromMilliseconds(10); |
- base::TimeTicks time = base::TimeTicks() + dt; |
- WebFloatPoint fling_delta = WebFloatPoint(1000, 0); |
- WebPoint fling_point = WebPoint(7, 13); |
- StartFling( |
- time, blink::WebGestureDeviceTouchscreen, fling_delta, fling_point); |
- |
- // Cancel the fling. The fling cancellation should be deferred to allow |
- // fling boosting events to arrive. |
- time += dt; |
- CancelFling(time); |
- |
- // If the new fling is orthogonal to the existing fling, no boosting should |
- // take place, with the new fling replacing the old. |
- WebFloatPoint orthogonal_fling_delta = |
- WebFloatPoint(fling_delta.y, -fling_delta.x); |
- gesture_ = CreateFling(time, |
- blink::WebGestureDeviceTouchscreen, |
- orthogonal_fling_delta, |
- fling_point, |
- fling_point, |
- 0); |
- EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_)); |
- |
- VERIFY_AND_RESET_MOCKS(); |
- |
- // Note that the new fling delta uses the orthogonal, unboosted fling |
- // velocity. |
- time += dt; |
- float expected_delta = dt.InSecondsF() * -orthogonal_fling_delta.y; |
- EXPECT_SET_NEEDS_ANIMATE_INPUT(1); |
- EXPECT_CALL(mock_input_handler_, |
- ScrollBy(testing::_, |
- testing::Property(&gfx::Vector2dF::y, |
- testing::Eq(expected_delta)))) |
- .WillOnce(testing::Return(scroll_result_did_scroll_)); |
- Animate(time); |
- |
- VERIFY_AND_RESET_MOCKS(); |
-} |
- |
-TEST_P(InputHandlerProxyTest, NoFlingBoostIfScrollInDifferentDirection) { |
- base::TimeDelta dt = base::TimeDelta::FromMilliseconds(10); |
- base::TimeTicks time = base::TimeTicks() + dt; |
- WebFloatPoint fling_delta = WebFloatPoint(1000, 0); |
- WebPoint fling_point = WebPoint(7, 13); |
- StartFling( |
- time, blink::WebGestureDeviceTouchscreen, fling_delta, fling_point); |
- |
- // Cancel the fling. The fling cancellation should be deferred to allow |
- // fling boosting events to arrive. |
- time += dt; |
- CancelFling(time); |
- |
- // The GestureScrollBegin should be swallowed by the fling if it hits the same |
- // scrolling layer. |
- EXPECT_CALL(mock_input_handler_, |
- IsCurrentlyScrollingLayerAt(testing::_, testing::_)) |
- .WillOnce(testing::Return(true)); |
- |
- time += dt; |
- gesture_.timeStampSeconds = InSecondsF(time); |
- gesture_.type = WebInputEvent::GestureScrollBegin; |
- EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_)); |
- |
- VERIFY_AND_RESET_MOCKS(); |
- |
- // If the GestureScrollUpdate is in a different direction than the fling, |
- // the fling should be cancelled and scrolling should resume. |
- time += dt; |
- gesture_.timeStampSeconds = InSecondsF(time); |
- gesture_.type = WebInputEvent::GestureScrollUpdate; |
- gesture_.data.scrollUpdate.deltaX = -fling_delta.x; |
- EXPECT_CALL(mock_input_handler_, ScrollEnd()); |
- EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_)) |
- .WillOnce(testing::Return(cc::InputHandler::SCROLL_STARTED)); |
- EXPECT_CALL(mock_input_handler_, |
- ScrollBy(testing::_, |
- testing::Property(&gfx::Vector2dF::x, |
- testing::Eq(fling_delta.x)))) |
- .WillOnce(testing::Return(scroll_result_did_scroll_)); |
- EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_)); |
- |
- VERIFY_AND_RESET_MOCKS(); |
-} |
- |
-TEST_P(InputHandlerProxyTest, NoFlingBoostIfFlingTooSlow) { |
- base::TimeDelta dt = base::TimeDelta::FromMilliseconds(10); |
- base::TimeTicks time = base::TimeTicks() + dt; |
- WebFloatPoint fling_delta = WebFloatPoint(1000, 0); |
- WebPoint fling_point = WebPoint(7, 13); |
- StartFling( |
- time, blink::WebGestureDeviceTouchscreen, fling_delta, fling_point); |
- |
- // Cancel the fling. The fling cancellation should be deferred to allow |
- // fling boosting events to arrive. |
- time += dt; |
- CancelFling(time); |
- |
- // If the new fling is too slow, no boosting should take place, with the new |
- // fling replacing the old. |
- WebFloatPoint small_fling_delta = WebFloatPoint(100, 0); |
- gesture_ = CreateFling(time, |
- blink::WebGestureDeviceTouchscreen, |
- small_fling_delta, |
- fling_point, |
- fling_point, |
- 0); |
- EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_)); |
- |
- VERIFY_AND_RESET_MOCKS(); |
- |
- // Note that the new fling delta uses the *slow*, unboosted fling velocity. |
- time += dt; |
- float expected_delta = dt.InSecondsF() * -small_fling_delta.x; |
- EXPECT_SET_NEEDS_ANIMATE_INPUT(1); |
- EXPECT_CALL(mock_input_handler_, |
- ScrollBy(testing::_, |
- testing::Property(&gfx::Vector2dF::x, |
- testing::Eq(expected_delta)))) |
- .WillOnce(testing::Return(scroll_result_did_scroll_)); |
- Animate(time); |
- |
- VERIFY_AND_RESET_MOCKS(); |
-} |
- |
-TEST_P(InputHandlerProxyTest, NoFlingBoostIfPreventBoostingFlagIsSet) { |
- base::TimeDelta dt = base::TimeDelta::FromMilliseconds(10); |
- base::TimeTicks time = base::TimeTicks() + dt; |
- WebFloatPoint fling_delta = WebFloatPoint(1000, 0); |
- WebPoint fling_point = WebPoint(7, 13); |
- |
- StartFling( |
- time, blink::WebGestureDeviceTouchscreen, fling_delta, fling_point); |
- |
- EXPECT_CALL(mock_input_handler_, ScrollEnd()); |
- |
- // Cancel the fling. The fling cancellation should not be deferred because of |
- // prevent boosting flag set. |
- gesture_.data.flingCancel.preventBoosting = true; |
- time += dt; |
- CancelFling(time); |
- |
- // VERIFY_AND_RESET_MOCKS already called by CancelFling |
-} |
- |
-TEST_P(InputHandlerProxyTest, FlingBoostTerminatedDuringScrollSequence) { |
- base::TimeDelta dt = base::TimeDelta::FromMilliseconds(10); |
- base::TimeTicks time = base::TimeTicks() + dt; |
- base::TimeTicks last_animate_time = time; |
- WebFloatPoint fling_delta = WebFloatPoint(1000, 0); |
- WebPoint fling_point = WebPoint(7, 13); |
- StartFling( |
- time, blink::WebGestureDeviceTouchscreen, fling_delta, fling_point); |
- |
- // Now cancel the fling. The fling cancellation should be deferred to allow |
- // fling boosting events to arrive. |
- time += dt; |
- CancelFling(time); |
- |
- // The GestureScrollBegin should be swallowed by the fling. |
- time += dt; |
- gesture_.timeStampSeconds = InSecondsF(time); |
- gesture_.type = WebInputEvent::GestureScrollBegin; |
- EXPECT_CALL(mock_input_handler_, |
- IsCurrentlyScrollingLayerAt(testing::_, testing::_)) |
- .WillOnce(testing::Return(true)); |
- EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_)); |
- |
- VERIFY_AND_RESET_MOCKS(); |
- |
- // Now animate the fling to completion (in this case, the fling should |
- // terminate because the input handler reports a failed scroll). As the fling |
- // was cancelled during an active scroll sequence, a synthetic |
- // GestureScrollBegin should be processed, resuming the scroll. |
- time += dt; |
- float expected_delta = |
- (time - last_animate_time).InSecondsF() * -fling_delta.x; |
- EXPECT_CALL(mock_input_handler_, |
- ScrollBy(testing::_, |
- testing::Property(&gfx::Vector2dF::x, |
- testing::Eq(expected_delta)))) |
- .WillOnce(testing::Return(scroll_result_did_not_scroll_)); |
- EXPECT_CALL(mock_input_handler_, ScrollEnd()); |
- EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_)) |
- .WillOnce(testing::Return(cc::InputHandler::SCROLL_STARTED)); |
- Animate(time); |
- |
- VERIFY_AND_RESET_MOCKS(); |
- |
- // Subsequent GestureScrollUpdates after the cancelled, boosted fling should |
- // cause scrolling as usual. |
- time += dt; |
- expected_delta = 7.3f; |
- gesture_.timeStampSeconds = InSecondsF(time); |
- gesture_.type = WebInputEvent::GestureScrollUpdate; |
- gesture_.data.scrollUpdate.deltaX = -expected_delta; |
- EXPECT_CALL(mock_input_handler_, |
- ScrollBy(testing::_, |
- testing::Property(&gfx::Vector2dF::x, |
- testing::Eq(expected_delta)))) |
- .WillOnce(testing::Return(scroll_result_did_scroll_)); |
- EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_)); |
- |
- VERIFY_AND_RESET_MOCKS(); |
- |
- // GestureScrollEnd should terminate the resumed scroll properly. |
- time += dt; |
- gesture_.timeStampSeconds = InSecondsF(time); |
- gesture_.type = WebInputEvent::GestureScrollEnd; |
- EXPECT_CALL(mock_input_handler_, ScrollEnd()); |
- EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_)); |
- |
- VERIFY_AND_RESET_MOCKS(); |
-} |
- |
-TEST_P(InputHandlerProxyTest, DidReceiveInputEvent_ForFling) { |
- testing::StrictMock<MockInputHandlerProxyClientWithDidAnimateForInput> |
- mock_client; |
- input_handler_.reset( |
- new content::InputHandlerProxy(&mock_input_handler_, &mock_client)); |
- if (install_synchronous_handler_) { |
- EXPECT_CALL(mock_input_handler_, RequestUpdateForSynchronousInputHandler()) |
- .Times(1); |
- input_handler_->SetOnlySynchronouslyAnimateRootFlings( |
- &mock_synchronous_input_handler_); |
- } |
- mock_input_handler_.set_is_scrolling_root(synchronous_root_scroll_); |
- |
- gesture_.type = WebInputEvent::GestureFlingStart; |
- WebFloatPoint fling_delta = WebFloatPoint(100, 100); |
- gesture_.data.flingStart.velocityX = fling_delta.x; |
- gesture_.data.flingStart.velocityY = fling_delta.y; |
- EXPECT_SET_NEEDS_ANIMATE_INPUT(1); |
- EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_)) |
- .WillOnce(testing::Return(cc::InputHandler::SCROLL_STARTED)); |
- EXPECT_CALL(mock_input_handler_, ScrollEnd()); |
- EXPECT_EQ(InputHandlerProxy::DID_HANDLE, |
- input_handler_->HandleInputEvent(gesture_)); |
- VERIFY_AND_RESET_MOCKS(); |
- |
- EXPECT_SET_NEEDS_ANIMATE_INPUT(1); |
- EXPECT_CALL(mock_client, DidAnimateForInput()); |
- base::TimeTicks time = base::TimeTicks() + base::TimeDelta::FromSeconds(10); |
- Animate(time); |
- |
- VERIFY_AND_RESET_MOCKS(); |
-} |
- |
-TEST(SynchronousInputHandlerProxyTest, StartupShutdown) { |
- testing::StrictMock<MockInputHandler> mock_input_handler; |
- testing::StrictMock<MockInputHandlerProxyClient> mock_client; |
- testing::StrictMock<MockSynchronousInputHandler> |
- mock_synchronous_input_handler; |
- content::InputHandlerProxy proxy(&mock_input_handler, &mock_client); |
- |
- // When adding a SynchronousInputHandler, immediately request an |
- // UpdateRootLayerStateForSynchronousInputHandler() call. |
- EXPECT_CALL(mock_input_handler, RequestUpdateForSynchronousInputHandler()) |
- .Times(1); |
- proxy.SetOnlySynchronouslyAnimateRootFlings(&mock_synchronous_input_handler); |
- |
- testing::Mock::VerifyAndClearExpectations(&mock_input_handler); |
- testing::Mock::VerifyAndClearExpectations(&mock_client); |
- testing::Mock::VerifyAndClearExpectations(&mock_synchronous_input_handler); |
- |
- EXPECT_CALL(mock_input_handler, RequestUpdateForSynchronousInputHandler()) |
- .Times(0); |
- proxy.SetOnlySynchronouslyAnimateRootFlings(nullptr); |
- |
- testing::Mock::VerifyAndClearExpectations(&mock_input_handler); |
- testing::Mock::VerifyAndClearExpectations(&mock_client); |
- testing::Mock::VerifyAndClearExpectations(&mock_synchronous_input_handler); |
-} |
- |
-TEST(SynchronousInputHandlerProxyTest, UpdateRootLayerState) { |
- testing::NiceMock<MockInputHandler> mock_input_handler; |
- testing::StrictMock<MockInputHandlerProxyClient> mock_client; |
- testing::StrictMock<MockSynchronousInputHandler> |
- mock_synchronous_input_handler; |
- content::InputHandlerProxy proxy(&mock_input_handler, &mock_client); |
- |
- proxy.SetOnlySynchronouslyAnimateRootFlings(&mock_synchronous_input_handler); |
- |
- // When adding a SynchronousInputHandler, immediately request an |
- // UpdateRootLayerStateForSynchronousInputHandler() call. |
- EXPECT_CALL( |
- mock_synchronous_input_handler, |
- UpdateRootLayerState(gfx::ScrollOffset(1, 2), gfx::ScrollOffset(3, 4), |
- gfx::SizeF(5, 6), 7, 8, 9)) |
- .Times(1); |
- proxy.UpdateRootLayerStateForSynchronousInputHandler( |
- gfx::ScrollOffset(1, 2), gfx::ScrollOffset(3, 4), gfx::SizeF(5, 6), 7, 8, |
- 9); |
- |
- testing::Mock::VerifyAndClearExpectations(&mock_input_handler); |
- testing::Mock::VerifyAndClearExpectations(&mock_client); |
- testing::Mock::VerifyAndClearExpectations(&mock_synchronous_input_handler); |
-} |
- |
-TEST(SynchronousInputHandlerProxyTest, SetOffset) { |
- testing::NiceMock<MockInputHandler> mock_input_handler; |
- testing::StrictMock<MockInputHandlerProxyClient> mock_client; |
- testing::StrictMock<MockSynchronousInputHandler> |
- mock_synchronous_input_handler; |
- content::InputHandlerProxy proxy(&mock_input_handler, &mock_client); |
- |
- proxy.SetOnlySynchronouslyAnimateRootFlings(&mock_synchronous_input_handler); |
- |
- EXPECT_CALL(mock_input_handler, SetSynchronousInputHandlerRootScrollOffset( |
- gfx::ScrollOffset(5, 6))); |
- proxy.SynchronouslySetRootScrollOffset(gfx::ScrollOffset(5, 6)); |
- |
- testing::Mock::VerifyAndClearExpectations(&mock_input_handler); |
- testing::Mock::VerifyAndClearExpectations(&mock_client); |
- testing::Mock::VerifyAndClearExpectations(&mock_synchronous_input_handler); |
-} |
- |
-INSTANTIATE_TEST_CASE_P(AnimateInput, |
- InputHandlerProxyTest, |
- testing::ValuesIn(test_types)); |
-} // namespace test |
-} // namespace content |