| // Copyright 2018 The Chromium Authors |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "components/input/touchpad_pinch_event_queue.h" |
| |
| #include <string> |
| |
| #include "base/functional/bind.h" |
| #include "base/functional/callback_helpers.h" |
| #include "components/input/event_with_latency_info.h" |
| #include "testing/gmock/include/gmock/gmock.h" |
| #include "testing/gtest/include/gtest/gtest.h" |
| #include "third_party/blink/public/mojom/input/input_event_result.mojom-shared.h" |
| #include "ui/gfx/geometry/point_f.h" |
| #include "ui/latency/latency_info.h" |
| |
| namespace input { |
| |
| class MockTouchpadPinchEventQueueClient { |
| public: |
| MockTouchpadPinchEventQueueClient() = default; |
| ~MockTouchpadPinchEventQueueClient() = default; |
| |
| // TouchpadPinchEventQueueClient |
| MOCK_METHOD1(SendMouseWheelEventForPinchImmediately, |
| void(const MouseWheelEventWithLatencyInfo& event)); |
| MOCK_METHOD3(OnGestureEventForPinchAck, |
| void(const GestureEventWithLatencyInfo& event, |
| blink::mojom::InputEventResultSource ack_source, |
| blink::mojom::InputEventResultState ack_result)); |
| }; |
| |
| class TouchpadPinchEventQueueTest : public testing::TestWithParam<bool>, |
| public TouchpadPinchEventQueueClient { |
| protected: |
| TouchpadPinchEventQueueTest() { |
| queue_ = std::make_unique<TouchpadPinchEventQueue>(this); |
| } |
| ~TouchpadPinchEventQueueTest() = default; |
| |
| void QueueEvent(const blink::WebGestureEvent& event) { |
| ScopedDispatchToRendererCallback dispatch_callback(base::DoNothing()); |
| queue_->QueueEvent(GestureEventWithLatencyInfo(event), |
| dispatch_callback.callback); |
| } |
| |
| void QueuePinchBegin() { |
| blink::WebGestureEvent event( |
| blink::WebInputEvent::Type::kGesturePinchBegin, |
| blink::WebInputEvent::kNoModifiers, |
| blink::WebInputEvent::GetStaticTimeStampForTests(), |
| blink::WebGestureDevice::kTouchpad); |
| event.SetPositionInWidget(gfx::PointF(1, 1)); |
| event.SetPositionInScreen(gfx::PointF(1, 1)); |
| event.SetNeedsWheelEvent(true); |
| QueueEvent(event); |
| } |
| |
| void QueuePinchEnd() { |
| blink::WebGestureEvent event( |
| blink::WebInputEvent::Type::kGesturePinchEnd, |
| blink::WebInputEvent::kNoModifiers, |
| blink::WebInputEvent::GetStaticTimeStampForTests(), |
| blink::WebGestureDevice::kTouchpad); |
| event.SetPositionInWidget(gfx::PointF(1, 1)); |
| event.SetPositionInScreen(gfx::PointF(1, 1)); |
| event.SetNeedsWheelEvent(true); |
| QueueEvent(event); |
| } |
| |
| void QueuePinchUpdate(float scale, bool zoom_disabled) { |
| blink::WebGestureEvent event( |
| blink::WebInputEvent::Type::kGesturePinchUpdate, |
| blink::WebInputEvent::kNoModifiers, |
| blink::WebInputEvent::GetStaticTimeStampForTests(), |
| blink::WebGestureDevice::kTouchpad); |
| event.SetPositionInWidget(gfx::PointF(1, 1)); |
| event.SetPositionInScreen(gfx::PointF(1, 1)); |
| event.SetNeedsWheelEvent(true); |
| event.data.pinch_update.zoom_disabled = zoom_disabled; |
| event.data.pinch_update.scale = scale; |
| QueueEvent(event); |
| } |
| |
| void QueueDoubleTap() { |
| blink::WebGestureEvent event( |
| blink::WebInputEvent::Type::kGestureDoubleTap, |
| blink::WebInputEvent::kNoModifiers, |
| blink::WebInputEvent::GetStaticTimeStampForTests(), |
| blink::WebGestureDevice::kTouchpad); |
| event.SetPositionInWidget(gfx::PointF(1, 1)); |
| event.SetPositionInScreen(gfx::PointF(1, 1)); |
| event.data.tap.tap_count = 1; |
| event.SetNeedsWheelEvent(true); |
| QueueEvent(event); |
| } |
| |
| using HandleEventCallback = |
| base::OnceCallback<void(blink::mojom::InputEventResultSource ack_source, |
| blink::mojom::InputEventResultState ack_result)>; |
| |
| void SendWheelEventAck(blink::mojom::InputEventResultSource ack_source, |
| blink::mojom::InputEventResultState ack_result) { |
| std::move(callbacks_.front()).Run(ack_source, ack_result); |
| callbacks_.pop_front(); |
| } |
| |
| void SendMouseWheelEventForPinchImmediately( |
| const blink::WebGestureEvent& pinch_event, |
| const MouseWheelEventWithLatencyInfo& event, |
| MouseWheelEventHandledCallback callback, |
| DispatchToRendererCallback& dispatch_callback) override { |
| mock_client_.SendMouseWheelEventForPinchImmediately(event); |
| callbacks_.emplace_back(base::BindOnce( |
| [](MouseWheelEventHandledCallback callback, |
| const MouseWheelEventWithLatencyInfo& event, |
| blink::mojom::InputEventResultSource ack_source, |
| blink::mojom::InputEventResultState ack_result) { |
| std::move(callback).Run(event, ack_source, ack_result); |
| }, |
| std::move(callback), event)); |
| } |
| |
| void OnGestureEventForPinchAck( |
| const GestureEventWithLatencyInfo& event, |
| blink::mojom::InputEventResultSource ack_source, |
| blink::mojom::InputEventResultState ack_result) override { |
| mock_client_.OnGestureEventForPinchAck(event, ack_source, ack_result); |
| } |
| |
| testing::StrictMock<MockTouchpadPinchEventQueueClient> mock_client_; |
| std::unique_ptr<TouchpadPinchEventQueue> queue_; |
| base::circular_deque<HandleEventCallback> callbacks_; |
| }; |
| |
| MATCHER_P(EventHasType, |
| type, |
| std::string(negation ? "does not have" : "has") + " type " + |
| ::testing::PrintToString(type)) { |
| return arg.event.GetType() == type; |
| } |
| |
| MATCHER_P(EventHasPhase, |
| phase, |
| std::string(negation ? "does not have" : "has") + " phase " + |
| ::testing::PrintToString(phase)) { |
| return arg.event.phase == phase; |
| } |
| |
| MATCHER_P(EventHasScale, |
| expected_scale, |
| std::string(negation ? "does not have" : "has") + " scale " + |
| ::testing::PrintToString(expected_scale)) { |
| const float actual_scale = exp(arg.event.delta_y / 100.0f); |
| return ::testing::Matches(::testing::FloatEq(expected_scale))(actual_scale); |
| } |
| |
| MATCHER(EventHasCtrlModifier, |
| std::string(negation ? "does not have" : "has") + " control modifier") { |
| return (arg.event.GetModifiers() & blink::WebInputEvent::kControlKey) != 0; |
| } |
| |
| MATCHER(EventIsBlocking, |
| std::string(negation ? "is not" : "is") + " blocking") { |
| return arg.event.dispatch_type == |
| blink::WebInputEvent::DispatchType::kBlocking; |
| } |
| |
| // Ensure that when the queue receives a touchpad pinch sequence, it sends a |
| // synthetic mouse wheel event and acks the pinch events back to the client. |
| TEST_F(TouchpadPinchEventQueueTest, Basic) { |
| ::testing::InSequence sequence; |
| EXPECT_CALL(mock_client_, |
| OnGestureEventForPinchAck( |
| EventHasType(blink::WebInputEvent::Type::kGesturePinchBegin), |
| blink::mojom::InputEventResultSource::kBrowser, |
| blink::mojom::InputEventResultState::kIgnored)); |
| EXPECT_CALL(mock_client_, |
| SendMouseWheelEventForPinchImmediately( |
| ::testing::AllOf(EventHasCtrlModifier(), EventIsBlocking()))); |
| EXPECT_CALL(mock_client_, |
| OnGestureEventForPinchAck( |
| EventHasType(blink::WebInputEvent::Type::kGesturePinchUpdate), |
| blink::mojom::InputEventResultSource::kCompositorThread, |
| blink::mojom::InputEventResultState::kNoConsumerExists)); |
| EXPECT_CALL(mock_client_, |
| SendMouseWheelEventForPinchImmediately(::testing::AllOf( |
| EventHasCtrlModifier(), ::testing::Not(EventIsBlocking())))); |
| EXPECT_CALL(mock_client_, |
| OnGestureEventForPinchAck( |
| EventHasType(blink::WebInputEvent::Type::kGesturePinchEnd), |
| blink::mojom::InputEventResultSource::kBrowser, |
| blink::mojom::InputEventResultState::kIgnored)); |
| |
| QueuePinchBegin(); |
| QueuePinchUpdate(1.23, false); |
| SendWheelEventAck(blink::mojom::InputEventResultSource::kCompositorThread, |
| blink::mojom::InputEventResultState::kNoConsumerExists); |
| QueuePinchEnd(); |
| SendWheelEventAck(blink::mojom::InputEventResultSource::kBrowser, |
| blink::mojom::InputEventResultState::kIgnored); |
| } |
| |
| // Ensure the queue sends the wheel events with phase information. |
| TEST_F(TouchpadPinchEventQueueTest, MouseWheelPhase) { |
| ::testing::InSequence sequence; |
| EXPECT_CALL(mock_client_, |
| OnGestureEventForPinchAck( |
| EventHasType(blink::WebInputEvent::Type::kGesturePinchBegin), |
| blink::mojom::InputEventResultSource::kBrowser, |
| blink::mojom::InputEventResultState::kIgnored)); |
| EXPECT_CALL(mock_client_, |
| SendMouseWheelEventForPinchImmediately( |
| EventHasPhase(blink::WebMouseWheelEvent::kPhaseBegan))); |
| EXPECT_CALL(mock_client_, |
| OnGestureEventForPinchAck( |
| EventHasType(blink::WebInputEvent::Type::kGesturePinchUpdate), |
| blink::mojom::InputEventResultSource::kCompositorThread, |
| blink::mojom::InputEventResultState::kNoConsumerExists)); |
| EXPECT_CALL(mock_client_, |
| SendMouseWheelEventForPinchImmediately( |
| EventHasPhase(blink::WebMouseWheelEvent::kPhaseChanged))); |
| EXPECT_CALL(mock_client_, |
| OnGestureEventForPinchAck( |
| EventHasType(blink::WebInputEvent::Type::kGesturePinchUpdate), |
| testing::_, testing::_)); |
| EXPECT_CALL(mock_client_, |
| SendMouseWheelEventForPinchImmediately( |
| EventHasPhase(blink::WebMouseWheelEvent::kPhaseEnded))); |
| EXPECT_CALL(mock_client_, |
| OnGestureEventForPinchAck( |
| EventHasType(blink::WebInputEvent::Type::kGesturePinchEnd), |
| blink::mojom::InputEventResultSource::kBrowser, |
| blink::mojom::InputEventResultState::kIgnored)); |
| |
| QueuePinchBegin(); |
| QueuePinchUpdate(1.23, false); |
| SendWheelEventAck(blink::mojom::InputEventResultSource::kCompositorThread, |
| blink::mojom::InputEventResultState::kNoConsumerExists); |
| QueuePinchUpdate(1.23, false); |
| SendWheelEventAck(blink::mojom::InputEventResultSource::kBrowser, |
| blink::mojom::InputEventResultState::kIgnored); |
| QueuePinchEnd(); |
| SendWheelEventAck(blink::mojom::InputEventResultSource::kBrowser, |
| blink::mojom::InputEventResultState::kIgnored); |
| } |
| |
| // Ensure that if the renderer consumes the synthetic wheel event, the ack of |
| // the GesturePinchUpdate reflects this. |
| TEST_F(TouchpadPinchEventQueueTest, Consumed) { |
| ::testing::InSequence sequence; |
| EXPECT_CALL(mock_client_, |
| OnGestureEventForPinchAck( |
| EventHasType(blink::WebInputEvent::Type::kGesturePinchBegin), |
| blink::mojom::InputEventResultSource::kBrowser, |
| blink::mojom::InputEventResultState::kIgnored)); |
| EXPECT_CALL(mock_client_, |
| SendMouseWheelEventForPinchImmediately( |
| ::testing::AllOf(EventHasCtrlModifier(), EventIsBlocking()))); |
| EXPECT_CALL(mock_client_, |
| OnGestureEventForPinchAck( |
| EventHasType(blink::WebInputEvent::Type::kGesturePinchUpdate), |
| blink::mojom::InputEventResultSource::kMainThread, |
| blink::mojom::InputEventResultState::kConsumed)); |
| |
| EXPECT_CALL(mock_client_, |
| SendMouseWheelEventForPinchImmediately(::testing::AllOf( |
| EventHasCtrlModifier(), ::testing::Not(EventIsBlocking())))); |
| |
| EXPECT_CALL(mock_client_, |
| OnGestureEventForPinchAck( |
| EventHasType(blink::WebInputEvent::Type::kGesturePinchEnd), |
| blink::mojom::InputEventResultSource::kBrowser, |
| blink::mojom::InputEventResultState::kIgnored)); |
| |
| QueuePinchBegin(); |
| QueuePinchUpdate(1.23, false); |
| SendWheelEventAck(blink::mojom::InputEventResultSource::kMainThread, |
| blink::mojom::InputEventResultState::kConsumed); |
| QueuePinchEnd(); |
| SendWheelEventAck(blink::mojom::InputEventResultSource::kBrowser, |
| blink::mojom::InputEventResultState::kIgnored); |
| } |
| |
| // Ensure that the queue sends wheel events for updates with |zoom_disabled| as |
| // well. |
| TEST_F(TouchpadPinchEventQueueTest, ZoomDisabled) { |
| ::testing::InSequence sequence; |
| EXPECT_CALL(mock_client_, |
| OnGestureEventForPinchAck( |
| EventHasType(blink::WebInputEvent::Type::kGesturePinchBegin), |
| blink::mojom::InputEventResultSource::kBrowser, |
| blink::mojom::InputEventResultState::kIgnored)); |
| EXPECT_CALL(mock_client_, |
| SendMouseWheelEventForPinchImmediately( |
| ::testing::AllOf(EventHasCtrlModifier(), EventIsBlocking()))); |
| EXPECT_CALL(mock_client_, |
| OnGestureEventForPinchAck( |
| EventHasType(blink::WebInputEvent::Type::kGesturePinchUpdate), |
| blink::mojom::InputEventResultSource::kCompositorThread, |
| blink::mojom::InputEventResultState::kNoConsumerExists)); |
| |
| EXPECT_CALL(mock_client_, |
| SendMouseWheelEventForPinchImmediately(::testing::AllOf( |
| EventHasCtrlModifier(), ::testing::Not(EventIsBlocking())))); |
| |
| EXPECT_CALL(mock_client_, |
| OnGestureEventForPinchAck( |
| EventHasType(blink::WebInputEvent::Type::kGesturePinchEnd), |
| blink::mojom::InputEventResultSource::kBrowser, |
| blink::mojom::InputEventResultState::kIgnored)); |
| |
| QueuePinchBegin(); |
| QueuePinchUpdate(1.23, true); |
| SendWheelEventAck(blink::mojom::InputEventResultSource::kCompositorThread, |
| blink::mojom::InputEventResultState::kNoConsumerExists); |
| QueuePinchEnd(); |
| SendWheelEventAck(blink::mojom::InputEventResultSource::kBrowser, |
| blink::mojom::InputEventResultState::kIgnored); |
| } |
| |
| TEST_F(TouchpadPinchEventQueueTest, MultipleSequences) { |
| EXPECT_CALL(mock_client_, |
| OnGestureEventForPinchAck( |
| EventHasType(blink::WebInputEvent::Type::kGesturePinchBegin), |
| blink::mojom::InputEventResultSource::kBrowser, |
| blink::mojom::InputEventResultState::kIgnored)) |
| .Times(2); |
| EXPECT_CALL(mock_client_, SendMouseWheelEventForPinchImmediately(testing::_)) |
| .Times(4); |
| EXPECT_CALL(mock_client_, |
| OnGestureEventForPinchAck( |
| EventHasType(blink::WebInputEvent::Type::kGesturePinchUpdate), |
| blink::mojom::InputEventResultSource::kCompositorThread, |
| blink::mojom::InputEventResultState::kNoConsumerExists)) |
| .Times(2); |
| EXPECT_CALL(mock_client_, |
| OnGestureEventForPinchAck( |
| EventHasType(blink::WebInputEvent::Type::kGesturePinchEnd), |
| blink::mojom::InputEventResultSource::kBrowser, |
| blink::mojom::InputEventResultState::kIgnored)) |
| .Times(2); |
| |
| QueuePinchBegin(); |
| QueuePinchUpdate(1.23, false); |
| SendWheelEventAck(blink::mojom::InputEventResultSource::kCompositorThread, |
| blink::mojom::InputEventResultState::kNoConsumerExists); |
| QueuePinchEnd(); |
| SendWheelEventAck(blink::mojom::InputEventResultSource::kBrowser, |
| blink::mojom::InputEventResultState::kIgnored); |
| |
| QueuePinchBegin(); |
| QueuePinchUpdate(1.23, false); |
| SendWheelEventAck(blink::mojom::InputEventResultSource::kCompositorThread, |
| blink::mojom::InputEventResultState::kNoConsumerExists); |
| QueuePinchEnd(); |
| SendWheelEventAck(blink::mojom::InputEventResultSource::kBrowser, |
| blink::mojom::InputEventResultState::kIgnored); |
| } |
| |
| // Ensure we can queue additional pinch event sequences while the queue is |
| // waiting for a wheel event ack. |
| TEST_F(TouchpadPinchEventQueueTest, MultipleQueuedSequences) { |
| EXPECT_CALL(mock_client_, |
| OnGestureEventForPinchAck( |
| EventHasType(blink::WebInputEvent::Type::kGesturePinchBegin), |
| blink::mojom::InputEventResultSource::kBrowser, |
| blink::mojom::InputEventResultState::kIgnored)); |
| EXPECT_CALL(mock_client_, SendMouseWheelEventForPinchImmediately(testing::_)); |
| QueuePinchBegin(); |
| QueuePinchUpdate(1.23, false); |
| |
| testing::Mock::VerifyAndClearExpectations(&mock_client_); |
| |
| QueuePinchEnd(); |
| |
| QueuePinchBegin(); |
| QueuePinchUpdate(1.23, false); |
| QueuePinchEnd(); |
| |
| // No calls since we're still waiting on the ack for the first wheel event. |
| testing::Mock::VerifyAndClearExpectations(&mock_client_); |
| |
| EXPECT_CALL(mock_client_, |
| OnGestureEventForPinchAck( |
| EventHasType(blink::WebInputEvent::Type::kGesturePinchUpdate), |
| blink::mojom::InputEventResultSource::kCompositorThread, |
| blink::mojom::InputEventResultState::kNoConsumerExists)); |
| EXPECT_CALL(mock_client_, |
| OnGestureEventForPinchAck( |
| EventHasType(blink::WebInputEvent::Type::kGesturePinchEnd), |
| blink::mojom::InputEventResultSource::kBrowser, |
| blink::mojom::InputEventResultState::kIgnored)); |
| EXPECT_CALL(mock_client_, |
| OnGestureEventForPinchAck( |
| EventHasType(blink::WebInputEvent::Type::kGesturePinchBegin), |
| blink::mojom::InputEventResultSource::kBrowser, |
| blink::mojom::InputEventResultState::kIgnored)); |
| EXPECT_CALL(mock_client_, SendMouseWheelEventForPinchImmediately(testing::_)) |
| .Times(2); |
| SendWheelEventAck(blink::mojom::InputEventResultSource::kCompositorThread, |
| blink::mojom::InputEventResultState::kNoConsumerExists); |
| // ACK for end event. |
| SendWheelEventAck(blink::mojom::InputEventResultSource::kBrowser, |
| blink::mojom::InputEventResultState::kIgnored); |
| |
| // After acking the first wheel event, the queue continues. |
| testing::Mock::VerifyAndClearExpectations(&mock_client_); |
| |
| EXPECT_CALL(mock_client_, |
| OnGestureEventForPinchAck( |
| EventHasType(blink::WebInputEvent::Type::kGesturePinchUpdate), |
| blink::mojom::InputEventResultSource::kCompositorThread, |
| blink::mojom::InputEventResultState::kNoConsumerExists)); |
| EXPECT_CALL(mock_client_, |
| OnGestureEventForPinchAck( |
| EventHasType(blink::WebInputEvent::Type::kGesturePinchEnd), |
| blink::mojom::InputEventResultSource::kBrowser, |
| blink::mojom::InputEventResultState::kIgnored)); |
| EXPECT_CALL(mock_client_, SendMouseWheelEventForPinchImmediately(testing::_)); |
| SendWheelEventAck(blink::mojom::InputEventResultSource::kCompositorThread, |
| blink::mojom::InputEventResultState::kNoConsumerExists); |
| // ACK for end event. |
| SendWheelEventAck(blink::mojom::InputEventResultSource::kBrowser, |
| blink::mojom::InputEventResultState::kIgnored); |
| } |
| |
| // Ensure the queue handles pinch event sequences with multiple updates. |
| TEST_F(TouchpadPinchEventQueueTest, MultipleUpdatesInSequence) { |
| EXPECT_CALL(mock_client_, |
| OnGestureEventForPinchAck( |
| EventHasType(blink::WebInputEvent::Type::kGesturePinchBegin), |
| blink::mojom::InputEventResultSource::kBrowser, |
| blink::mojom::InputEventResultState::kIgnored)); |
| // Only first wheel event is cancelable. |
| // Here the second and the third wheel events are not blocking because we |
| // ack the first wheel event as unconsumed. |
| EXPECT_CALL(mock_client_, |
| SendMouseWheelEventForPinchImmediately( |
| ::testing::AllOf(EventHasCtrlModifier(), EventIsBlocking()))); |
| EXPECT_CALL(mock_client_, |
| SendMouseWheelEventForPinchImmediately(::testing::AllOf( |
| EventHasCtrlModifier(), ::testing::Not(EventIsBlocking())))) |
| .Times(3); |
| EXPECT_CALL(mock_client_, |
| OnGestureEventForPinchAck( |
| EventHasType(blink::WebInputEvent::Type::kGesturePinchUpdate), |
| blink::mojom::InputEventResultSource::kCompositorThread, |
| blink::mojom::InputEventResultState::kNoConsumerExists)); |
| EXPECT_CALL(mock_client_, |
| OnGestureEventForPinchAck( |
| EventHasType(blink::WebInputEvent::Type::kGesturePinchUpdate), |
| blink::mojom::InputEventResultSource::kBrowser, |
| blink::mojom::InputEventResultState::kIgnored)) |
| .Times(2); |
| EXPECT_CALL(mock_client_, |
| OnGestureEventForPinchAck( |
| EventHasType(blink::WebInputEvent::Type::kGesturePinchEnd), |
| blink::mojom::InputEventResultSource::kBrowser, |
| blink::mojom::InputEventResultState::kIgnored)); |
| |
| QueuePinchBegin(); |
| QueuePinchUpdate(1.23, false); |
| SendWheelEventAck(blink::mojom::InputEventResultSource::kCompositorThread, |
| blink::mojom::InputEventResultState::kNoConsumerExists); |
| QueuePinchUpdate(1.23, false); |
| SendWheelEventAck(blink::mojom::InputEventResultSource::kBrowser, |
| blink::mojom::InputEventResultState::kIgnored); |
| QueuePinchUpdate(1.23, false); |
| SendWheelEventAck(blink::mojom::InputEventResultSource::kBrowser, |
| blink::mojom::InputEventResultState::kIgnored); |
| QueuePinchEnd(); |
| SendWheelEventAck(blink::mojom::InputEventResultSource::kBrowser, |
| blink::mojom::InputEventResultState::kIgnored); |
| } |
| |
| // Ensure the queue coalesces pinch update events. |
| TEST_F(TouchpadPinchEventQueueTest, MultipleUpdatesCoalesced) { |
| EXPECT_CALL(mock_client_, |
| OnGestureEventForPinchAck( |
| EventHasType(blink::WebInputEvent::Type::kGesturePinchBegin), |
| blink::mojom::InputEventResultSource::kBrowser, |
| blink::mojom::InputEventResultState::kIgnored)); |
| // Only the first wheel event is cancelable. |
| // Here the second wheel is not blocking because we ack the first wheel |
| // event as unconsumed. |
| EXPECT_CALL(mock_client_, |
| SendMouseWheelEventForPinchImmediately( |
| ::testing::AllOf(EventHasCtrlModifier(), EventIsBlocking()))); |
| EXPECT_CALL(mock_client_, |
| SendMouseWheelEventForPinchImmediately(::testing::AllOf( |
| EventHasCtrlModifier(), ::testing::Not(EventIsBlocking())))) |
| .Times(2); |
| EXPECT_CALL(mock_client_, |
| OnGestureEventForPinchAck( |
| EventHasType(blink::WebInputEvent::Type::kGesturePinchUpdate), |
| blink::mojom::InputEventResultSource::kCompositorThread, |
| blink::mojom::InputEventResultState::kNoConsumerExists)); |
| EXPECT_CALL(mock_client_, |
| OnGestureEventForPinchAck( |
| EventHasType(blink::WebInputEvent::Type::kGesturePinchUpdate), |
| blink::mojom::InputEventResultSource::kBrowser, |
| blink::mojom::InputEventResultState::kIgnored)); |
| EXPECT_CALL(mock_client_, |
| OnGestureEventForPinchAck( |
| EventHasType(blink::WebInputEvent::Type::kGesturePinchEnd), |
| blink::mojom::InputEventResultSource::kBrowser, |
| blink::mojom::InputEventResultState::kIgnored)); |
| |
| QueuePinchBegin(); |
| // The queue will send the first wheel event for this first update. |
| QueuePinchUpdate(1.23, false); |
| // Before the first wheel event is acked, queue another update. |
| QueuePinchUpdate(1.23, false); |
| // Queue a third update. This will be coalesced with the second update which |
| // is currently in the queue. |
| QueuePinchUpdate(1.23, false); |
| QueuePinchEnd(); |
| |
| // Ack for the wheel event corresponding to the first update. |
| SendWheelEventAck(blink::mojom::InputEventResultSource::kCompositorThread, |
| blink::mojom::InputEventResultState::kNoConsumerExists); |
| // Ack for the wheel event corresponding to the second and third updates. |
| SendWheelEventAck(blink::mojom::InputEventResultSource::kBrowser, |
| blink::mojom::InputEventResultState::kIgnored); |
| // ACK for end event. |
| SendWheelEventAck(blink::mojom::InputEventResultSource::kBrowser, |
| blink::mojom::InputEventResultState::kIgnored); |
| EXPECT_FALSE(queue_->has_pending()); |
| } |
| |
| // Ensure the queue handles pinch event sequences with multiple canceled |
| // updates. |
| TEST_F(TouchpadPinchEventQueueTest, MultipleCanceledUpdatesInSequence) { |
| EXPECT_CALL(mock_client_, |
| OnGestureEventForPinchAck( |
| EventHasType(blink::WebInputEvent::Type::kGesturePinchBegin), |
| blink::mojom::InputEventResultSource::kBrowser, |
| blink::mojom::InputEventResultState::kIgnored)); |
| EXPECT_CALL(mock_client_, |
| SendMouseWheelEventForPinchImmediately( |
| ::testing::AllOf(EventHasCtrlModifier(), EventIsBlocking()))) |
| .Times(3); |
| EXPECT_CALL(mock_client_, |
| OnGestureEventForPinchAck( |
| EventHasType(blink::WebInputEvent::Type::kGesturePinchUpdate), |
| blink::mojom::InputEventResultSource::kMainThread, |
| blink::mojom::InputEventResultState::kConsumed)) |
| .Times(3); |
| EXPECT_CALL(mock_client_, |
| SendMouseWheelEventForPinchImmediately(::testing::AllOf( |
| EventHasCtrlModifier(), ::testing::Not(EventIsBlocking())))); |
| EXPECT_CALL(mock_client_, |
| OnGestureEventForPinchAck( |
| EventHasType(blink::WebInputEvent::Type::kGesturePinchEnd), |
| blink::mojom::InputEventResultSource::kBrowser, |
| blink::mojom::InputEventResultState::kIgnored)); |
| |
| QueuePinchBegin(); |
| QueuePinchUpdate(1.23, false); |
| SendWheelEventAck(blink::mojom::InputEventResultSource::kMainThread, |
| blink::mojom::InputEventResultState::kConsumed); |
| QueuePinchUpdate(1.23, false); |
| SendWheelEventAck(blink::mojom::InputEventResultSource::kMainThread, |
| blink::mojom::InputEventResultState::kConsumed); |
| QueuePinchUpdate(1.23, false); |
| SendWheelEventAck(blink::mojom::InputEventResultSource::kMainThread, |
| blink::mojom::InputEventResultState::kConsumed); |
| QueuePinchEnd(); |
| SendWheelEventAck(blink::mojom::InputEventResultSource::kBrowser, |
| blink::mojom::InputEventResultState::kIgnored); |
| } |
| |
| // Ensure that when the queue receives a touchpad double tap, it sends a |
| // synthetic mouse wheel event and acks the double tap back to the client. |
| TEST_F(TouchpadPinchEventQueueTest, DoubleTap) { |
| ::testing::InSequence sequence; |
| EXPECT_CALL(mock_client_, |
| SendMouseWheelEventForPinchImmediately(::testing::AllOf( |
| EventHasCtrlModifier(), EventIsBlocking(), |
| EventHasPhase(blink::WebMouseWheelEvent::kPhaseNone), |
| EventHasScale(1.0f)))); |
| EXPECT_CALL(mock_client_, |
| OnGestureEventForPinchAck( |
| EventHasType(blink::WebInputEvent::Type::kGestureDoubleTap), |
| blink::mojom::InputEventResultSource::kMainThread, |
| blink::mojom::InputEventResultState::kConsumed)); |
| |
| QueueDoubleTap(); |
| SendWheelEventAck(blink::mojom::InputEventResultSource::kMainThread, |
| blink::mojom::InputEventResultState::kConsumed); |
| } |
| |
| // Ensure that ACKs are only processed when they match the event that is |
| // currently awaiting an ACK. |
| TEST_F(TouchpadPinchEventQueueTest, IgnoreNonMatchingEvents) { |
| ::testing::InSequence sequence; |
| EXPECT_CALL(mock_client_, |
| OnGestureEventForPinchAck( |
| EventHasType(blink::WebInputEvent::Type::kGesturePinchBegin), |
| blink::mojom::InputEventResultSource::kBrowser, |
| blink::mojom::InputEventResultState::kIgnored)); |
| EXPECT_CALL(mock_client_, |
| SendMouseWheelEventForPinchImmediately( |
| ::testing::AllOf(EventHasCtrlModifier(), EventIsBlocking()))); |
| EXPECT_CALL(mock_client_, |
| OnGestureEventForPinchAck( |
| EventHasType(blink::WebInputEvent::Type::kGesturePinchUpdate), |
| blink::mojom::InputEventResultSource::kMainThread, |
| blink::mojom::InputEventResultState::kConsumed)); |
| |
| EXPECT_CALL(mock_client_, |
| SendMouseWheelEventForPinchImmediately(::testing::AllOf( |
| EventHasCtrlModifier(), ::testing::Not(EventIsBlocking())))); |
| |
| EXPECT_CALL(mock_client_, |
| OnGestureEventForPinchAck( |
| EventHasType(blink::WebInputEvent::Type::kGesturePinchEnd), |
| blink::mojom::InputEventResultSource::kBrowser, |
| blink::mojom::InputEventResultState::kIgnored)); |
| |
| QueuePinchBegin(); |
| QueuePinchUpdate(1.23, false); |
| QueuePinchEnd(); |
| |
| SendWheelEventAck(blink::mojom::InputEventResultSource::kMainThread, |
| blink::mojom::InputEventResultState::kConsumed); |
| SendWheelEventAck(blink::mojom::InputEventResultSource::kBrowser, |
| blink::mojom::InputEventResultState::kIgnored); |
| } |
| |
| } // namespace input |
