Chromium Code Reviews Chromium Code Reviews
Issue 2715623002:
Add a passthrough touch event queue. (Closed)
| Index: content/browser/renderer_host/input/passthrough_touch_event_queue_unittest.cc |
| diff --git a/content/browser/renderer_host/input/touch_event_queue_unittest.cc b/content/browser/renderer_host/input/passthrough_touch_event_queue_unittest.cc |
| similarity index 56% |
| rename from content/browser/renderer_host/input/touch_event_queue_unittest.cc |
| rename to content/browser/renderer_host/input/passthrough_touch_event_queue_unittest.cc |
| index b20f692127df31e16d458d601004a5bfbefca442..039f996a50e8f949f8f23c0ac392a23db6493f9a 100644 |
| --- a/content/browser/renderer_host/input/touch_event_queue_unittest.cc |
| +++ b/content/browser/renderer_host/input/passthrough_touch_event_queue_unittest.cc |
| @@ -1,8 +1,8 @@ |
| -// Copyright 2013 The Chromium Authors. All rights reserved. |
| +// Copyright 2017 The Chromium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| -#include "content/browser/renderer_host/input/touch_event_queue.h" |
| +#include "content/browser/renderer_host/input/passthrough_touch_event_queue.h" |
| #include <stddef.h> |
| @@ -15,7 +15,6 @@ |
| #include "base/run_loop.h" |
| #include "base/single_thread_task_runner.h" |
| #include "base/threading/thread_task_runner_handle.h" |
| -#include "content/browser/renderer_host/input/legacy_touch_event_queue.h" |
| #include "content/browser/renderer_host/input/timeout_monitor.h" |
| #include "content/common/input/synthetic_web_input_event_builders.h" |
| #include "content/common/input/web_touch_event_traits.h" |
| @@ -40,15 +39,15 @@ base::TimeDelta DefaultTouchTimeoutDelay() { |
| } |
| } // namespace |
| -class TouchEventQueueTest : public testing::Test, |
| - public TouchEventQueueClient { |
| +class PassthroughTouchEventQueueTest : public testing::Test, |
| + public TouchEventQueueClient { |
| public: |
| - TouchEventQueueTest() |
| + PassthroughTouchEventQueueTest() |
| : acked_event_count_(0), |
| last_acked_event_state_(INPUT_EVENT_ACK_STATE_UNKNOWN), |
| slop_length_dips_(0) {} |
| - ~TouchEventQueueTest() override {} |
| + ~PassthroughTouchEventQueueTest() override {} |
| // testing::Test |
| void SetUp() override { |
| @@ -82,9 +81,8 @@ class TouchEventQueueTest : public testing::Test, |
| if (followup_gesture_event_) { |
| std::unique_ptr<WebGestureEvent> followup_gesture_event = |
| std::move(followup_gesture_event_); |
| - queue_->OnGestureScrollEvent( |
| - GestureEventWithLatencyInfo(*followup_gesture_event, |
| - ui::LatencyInfo())); |
| + queue_->OnGestureScrollEvent(GestureEventWithLatencyInfo( |
| + *followup_gesture_event, ui::LatencyInfo())); |
| } |
| } |
| @@ -140,6 +138,13 @@ class TouchEventQueueTest : public testing::Test, |
| sent_events_ids_.pop_front(); |
| } |
| + void SendTouchEventAckLast(InputEventAckState ack_result) { |
| + DCHECK(!sent_events_ids_.empty()); |
| + queue_->ProcessTouchAck(ack_result, ui::LatencyInfo(), |
| + sent_events_ids_.back()); |
| + sent_events_ids_.pop_back(); |
| + } |
| + |
| void SendTouchEventAckWithID(InputEventAckState ack_result, |
| int unique_event_id) { |
| queue_->ProcessTouchAck(ack_result, ui::LatencyInfo(), unique_event_id); |
| @@ -247,9 +252,7 @@ class TouchEventQueueTest : public testing::Test, |
| touch_event_.setTimeStampSeconds(touch_event_.timeStampSeconds() + seconds); |
| } |
| - void ResetTouchEvent() { |
| - touch_event_ = SyntheticWebTouchEvent(); |
| - } |
| + void ResetTouchEvent() { touch_event_ = SyntheticWebTouchEvent(); } |
| size_t GetAndResetAckedEventCount() { |
| size_t count = acked_event_count_; |
| @@ -279,21 +282,13 @@ class TouchEventQueueTest : public testing::Test, |
| bool IsTimeoutRunning() const { return queue_->IsTimeoutRunningForTesting(); } |
| - bool HasPendingAsyncTouchMove() const { |
| - return queue_->HasPendingAsyncTouchMoveForTesting(); |
| - } |
| - |
| - size_t queued_event_count() const { |
| - return queue_->size(); |
| - } |
| + size_t queued_event_count() const { return queue_->SizeForTesting(); } |
| const WebTouchEvent& latest_event() const { |
| return queue_->GetLatestEventForTesting().event; |
| } |
| - const WebTouchEvent& acked_event() const { |
| - return last_acked_event_; |
| - } |
| + const WebTouchEvent& acked_event() const { return last_acked_event_; } |
| const WebTouchEvent& sent_event() const { |
| DCHECK(!sent_events_.empty()); |
| @@ -314,24 +309,20 @@ class TouchEventQueueTest : public testing::Test, |
| base::RunLoop().Run(); |
| } |
| - size_t uncancelable_touch_moves_pending_ack_count() const { |
| - return queue_->uncancelable_touch_moves_pending_ack_count(); |
| - } |
| - |
| int GetUniqueTouchEventID() { return sent_events_ids_.back(); } |
| - private: |
| + protected: |
|
tdresser
2017/02/23 15:10:45
Why not private?
dtapuska
2017/02/23 16:52:12
Fixed. I was originally trying to merge the two un
|
| void SendTouchEvent() { |
| SendTouchEvent(touch_event_); |
| touch_event_.ResetPoints(); |
| } |
| void ResetQueueWithConfig(const TouchEventQueue::Config& config) { |
| - queue_.reset(new LegacyTouchEventQueue(this, config)); |
| + queue_.reset(new PassthroughTouchEventQueue(this, config)); |
| queue_->OnHasTouchEventHandlers(true); |
| } |
| - std::unique_ptr<LegacyTouchEventQueue> queue_; |
| + std::unique_ptr<PassthroughTouchEventQueue> queue_; |
| size_t acked_event_count_; |
| WebTouchEvent last_acked_event_; |
| std::vector<WebTouchEvent> sent_events_; |
| @@ -346,22 +337,22 @@ class TouchEventQueueTest : public testing::Test, |
| std::deque<int> sent_events_ids_; |
| }; |
| - |
| // Tests that touch-events are queued properly. |
| -TEST_F(TouchEventQueueTest, Basic) { |
| +TEST_F(PassthroughTouchEventQueueTest, Basic) { |
| PressTouchPoint(1, 1); |
| EXPECT_EQ(1U, queued_event_count()); |
| EXPECT_EQ(1U, GetAndResetSentEventCount()); |
| - // The second touch should not be sent since one is already in queue. |
| + // The second touch should be sent right away even though |
| + // we haven't received an ack for the touch start. |
| MoveTouchPoint(0, 5, 5); |
| EXPECT_EQ(2U, queued_event_count()); |
| - EXPECT_EQ(0U, GetAndResetSentEventCount()); |
| + EXPECT_EQ(1U, GetAndResetSentEventCount()); |
| // Receive an ACK for the first touch-event. |
| SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED); |
| EXPECT_EQ(1U, queued_event_count()); |
| - EXPECT_EQ(1U, GetAndResetSentEventCount()); |
| + EXPECT_EQ(0U, GetAndResetSentEventCount()); |
| EXPECT_EQ(1U, GetAndResetAckedEventCount()); |
| EXPECT_EQ(WebInputEvent::TouchStart, acked_event().type()); |
| EXPECT_EQ(WebInputEvent::Blocking, acked_event().dispatchType); |
| @@ -376,53 +367,56 @@ TEST_F(TouchEventQueueTest, Basic) { |
| } |
| // Tests that touch-events with multiple points are queued properly. |
| -TEST_F(TouchEventQueueTest, BasicMultiTouch) { |
| +TEST_F(PassthroughTouchEventQueueTest, BasicMultiTouch) { |
| const size_t kPointerCount = 10; |
| for (float i = 0; i < kPointerCount; ++i) |
| PressTouchPoint(i, i); |
| - EXPECT_EQ(1U, GetAndResetSentEventCount()); |
| + EXPECT_EQ(kPointerCount, GetAndResetSentEventCount()); |
| EXPECT_EQ(0U, GetAndResetAckedEventCount()); |
| EXPECT_EQ(kPointerCount, queued_event_count()); |
| for (int i = 0; i < static_cast<int>(kPointerCount); ++i) |
| MoveTouchPoint(i, 1.f + i, 2.f + i); |
| - EXPECT_EQ(0U, GetAndResetSentEventCount()); |
| + EXPECT_EQ(kPointerCount, GetAndResetSentEventCount()); |
| EXPECT_EQ(0U, GetAndResetAckedEventCount()); |
| - // All moves should coalesce. |
| - EXPECT_EQ(kPointerCount + 1, queued_event_count()); |
| + // No coalescing happens in the queue since they are all |
| + // sent immediately. |
|
tdresser
2017/02/23 15:10:45
Sent
dtapuska
2017/02/23 16:52:12
I've collapsed it into a single line.
|
| + EXPECT_EQ(2 * kPointerCount, queued_event_count()); |
| for (int i = 0; i < static_cast<int>(kPointerCount); ++i) |
| ReleaseTouchPoint(kPointerCount - 1 - i); |
| - EXPECT_EQ(0U, GetAndResetSentEventCount()); |
| + EXPECT_EQ(kPointerCount, GetAndResetSentEventCount()); |
| EXPECT_EQ(0U, GetAndResetAckedEventCount()); |
| - EXPECT_EQ(kPointerCount * 2 + 1, queued_event_count()); |
| + EXPECT_EQ(kPointerCount * 3, queued_event_count()); |
| // Ack all presses. |
| for (size_t i = 0; i < kPointerCount; ++i) |
| SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED); |
| EXPECT_EQ(kPointerCount, GetAndResetAckedEventCount()); |
| - EXPECT_EQ(kPointerCount, GetAndResetSentEventCount()); |
| + EXPECT_EQ(0U, GetAndResetSentEventCount()); |
| - // Ack the coalesced move. |
| - SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED); |
| + // Ack the touch moves move. |
|
tdresser
2017/02/23 15:10:45
This comment is confusing.
dtapuska
2017/02/23 16:52:12
Done.
|
| + for (size_t i = 0; i < kPointerCount; ++i) |
| + SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED); |
| EXPECT_EQ(kPointerCount, GetAndResetAckedEventCount()); |
| - EXPECT_EQ(1U, GetAndResetSentEventCount()); |
| + EXPECT_EQ(0U, GetAndResetSentEventCount()); |
| // Ack all releases. |
| for (size_t i = 0; i < kPointerCount; ++i) |
| SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED); |
| EXPECT_EQ(kPointerCount, GetAndResetAckedEventCount()); |
| - EXPECT_EQ(kPointerCount - 1, GetAndResetSentEventCount()); |
| + EXPECT_EQ(0U, GetAndResetSentEventCount()); |
| } |
| // Tests that the touch-queue continues delivering events for an active touch |
| // sequence after all handlers are removed. |
| -TEST_F(TouchEventQueueTest, TouchesForwardedIfHandlerRemovedDuringSequence) { |
| +TEST_F(PassthroughTouchEventQueueTest, |
| + TouchesForwardedIfHandlerRemovedDuringSequence) { |
| OnHasTouchEventHandlers(true); |
| EXPECT_EQ(0U, queued_event_count()); |
| EXPECT_EQ(0U, GetAndResetSentEventCount()); |
| @@ -455,10 +449,10 @@ TEST_F(TouchEventQueueTest, TouchesForwardedIfHandlerRemovedDuringSequence) { |
| // reported no consumer. |
| MoveTouchPoint(1, 3, 3); |
| ReleaseTouchPoint(1); |
| - EXPECT_EQ(1U, GetAndResetSentEventCount()); |
| + EXPECT_EQ(2U, GetAndResetSentEventCount()); |
| EXPECT_EQ(0U, GetAndResetAckedEventCount()); |
| SendTouchEventAck(INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS); |
| - EXPECT_EQ(1U, GetAndResetSentEventCount()); |
| + EXPECT_EQ(0U, GetAndResetSentEventCount()); |
| EXPECT_EQ(1U, GetAndResetAckedEventCount()); |
| SendTouchEventAck(INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS); |
| EXPECT_EQ(0U, GetAndResetSentEventCount()); |
| @@ -467,12 +461,12 @@ TEST_F(TouchEventQueueTest, TouchesForwardedIfHandlerRemovedDuringSequence) { |
| // Events for the first pointer, that had a handler, should be forwarded. |
| MoveTouchPoint(0, 4, 4); |
| ReleaseTouchPoint(0); |
| - EXPECT_EQ(1U, GetAndResetSentEventCount()); |
| + EXPECT_EQ(2U, GetAndResetSentEventCount()); |
| EXPECT_EQ(2U, queued_event_count()); |
| SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED); |
| EXPECT_EQ(1U, GetAndResetAckedEventCount()); |
| - EXPECT_EQ(1U, GetAndResetSentEventCount()); |
| + EXPECT_EQ(0U, GetAndResetSentEventCount()); |
| EXPECT_EQ(1U, queued_event_count()); |
| EXPECT_EQ(INPUT_EVENT_ACK_STATE_CONSUMED, acked_event_state()); |
| @@ -485,7 +479,8 @@ TEST_F(TouchEventQueueTest, TouchesForwardedIfHandlerRemovedDuringSequence) { |
| // Tests that addition of a touch handler during a touch sequence will not cause |
| // the remaining sequence to be forwarded. |
| -TEST_F(TouchEventQueueTest, ActiveSequenceNotForwardedWhenHandlersAdded) { |
| +TEST_F(PassthroughTouchEventQueueTest, |
| + ActiveSequenceNotForwardedWhenHandlersAdded) { |
| OnHasTouchEventHandlers(false); |
| // Send a touch-press event while there is no handler. |
| @@ -512,7 +507,8 @@ TEST_F(TouchEventQueueTest, ActiveSequenceNotForwardedWhenHandlersAdded) { |
| // Tests that removal of a touch handler during a touch sequence will prevent |
| // the remaining sequence from being forwarded, even if another touch handler is |
| // registered during the same touch sequence. |
| -TEST_F(TouchEventQueueTest, ActiveSequenceDroppedWhenHandlersRemoved) { |
| +TEST_F(PassthroughTouchEventQueueTest, |
| + ActiveSequenceDroppedWhenHandlersRemoved) { |
| // Send a touch-press event. |
| PressTouchPoint(1, 1); |
| EXPECT_EQ(1U, GetAndResetSentEventCount()); |
| @@ -522,7 +518,7 @@ TEST_F(TouchEventQueueTest, ActiveSequenceDroppedWhenHandlersRemoved) { |
| MoveTouchPoint(0, 5, 5); |
| EXPECT_EQ(2U, queued_event_count()); |
| EXPECT_EQ(0U, GetAndResetAckedEventCount()); |
| - EXPECT_EQ(0U, GetAndResetSentEventCount()); |
| + EXPECT_EQ(1U, GetAndResetSentEventCount()); |
| // Unregister all touch handlers. |
| OnHasTouchEventHandlers(false); |
| @@ -538,7 +534,8 @@ TEST_F(TouchEventQueueTest, ActiveSequenceDroppedWhenHandlersRemoved) { |
| EXPECT_EQ(0U, GetAndResetAckedEventCount()); |
| EXPECT_EQ(2U, queued_event_count()); |
| - // The ack should be flush the queue. |
| + // clear the queue . |
| + SendTouchEventAck(INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS); |
| SendTouchEventAck(INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS); |
| EXPECT_EQ(2U, GetAndResetAckedEventCount()); |
| EXPECT_EQ(0U, queued_event_count()); |
| @@ -566,7 +563,7 @@ TEST_F(TouchEventQueueTest, ActiveSequenceDroppedWhenHandlersRemoved) { |
| // Tests that removal/addition of a touch handler without any intervening |
| // touch activity has no affect on touch forwarding. |
| -TEST_F(TouchEventQueueTest, |
| +TEST_F(PassthroughTouchEventQueueTest, |
| ActiveSequenceUnaffectedByRepeatedHandlerRemovalAndAddition) { |
| // Send a touch-press event. |
| PressTouchPoint(1, 1); |
| @@ -578,123 +575,22 @@ TEST_F(TouchEventQueueTest, |
| OnHasTouchEventHandlers(false); |
| OnHasTouchEventHandlers(true); |
| - // Queue a touch-move event. |
| + // Queue a touch-move event, should be sent right away. |
| MoveTouchPoint(0, 5, 5); |
| EXPECT_EQ(2U, queued_event_count()); |
| EXPECT_EQ(0U, GetAndResetAckedEventCount()); |
| - EXPECT_EQ(0U, GetAndResetSentEventCount()); |
| + EXPECT_EQ(1U, GetAndResetSentEventCount()); |
| // The ack should trigger forwarding of the touchmove, as if no touch |
| // handler registration changes have occurred. |
| SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
| EXPECT_EQ(1U, GetAndResetAckedEventCount()); |
| - EXPECT_EQ(1U, GetAndResetSentEventCount()); |
| - EXPECT_EQ(1U, queued_event_count()); |
| -} |
| - |
| -// Tests that touch-events are coalesced properly in the queue. |
| -TEST_F(TouchEventQueueTest, Coalesce) { |
| - // Send a touch-press event. |
| - PressTouchPoint(1, 1); |
| - EXPECT_EQ(1U, GetAndResetSentEventCount()); |
| - |
| - // Send a few touch-move events, followed by a touch-release event. All the |
| - // touch-move events should be coalesced into a single event. |
| - for (float i = 5; i < 15; ++i) |
| - MoveTouchPoint(0, i, i); |
| - |
| - EXPECT_EQ(0U, GetAndResetSentEventCount()); |
| - ReleaseTouchPoint(0); |
| - EXPECT_EQ(0U, GetAndResetSentEventCount()); |
| - EXPECT_EQ(3U, queued_event_count()); |
| - |
| - // ACK the press. Coalesced touch-move events should be sent. |
| - SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED); |
| - EXPECT_EQ(2U, queued_event_count()); |
| - EXPECT_EQ(1U, GetAndResetSentEventCount()); |
| - EXPECT_EQ(1U, GetAndResetAckedEventCount()); |
| - EXPECT_EQ(WebInputEvent::TouchStart, acked_event().type()); |
| - EXPECT_EQ(INPUT_EVENT_ACK_STATE_CONSUMED, acked_event_state()); |
| - |
| - // ACK the moves. |
| - SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED); |
| - EXPECT_EQ(1U, queued_event_count()); |
| - EXPECT_EQ(1U, GetAndResetSentEventCount()); |
| - EXPECT_EQ(10U, GetAndResetAckedEventCount()); |
| - EXPECT_EQ(WebInputEvent::TouchMove, acked_event().type()); |
| - |
| - // ACK the release. |
| - SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED); |
| - EXPECT_EQ(0U, queued_event_count()); |
| - EXPECT_EQ(0U, GetAndResetSentEventCount()); |
| - EXPECT_EQ(1U, GetAndResetAckedEventCount()); |
| - EXPECT_EQ(WebInputEvent::TouchEnd, acked_event().type()); |
| -} |
| - |
| -// Tests that an event that has already been sent but hasn't been ack'ed yet |
| -// doesn't get coalesced with newer events. |
| -TEST_F(TouchEventQueueTest, SentTouchEventDoesNotCoalesce) { |
| - // Send a touch-press event. |
| - PressTouchPoint(1, 1); |
| - EXPECT_EQ(1U, GetAndResetSentEventCount()); |
| - |
| - // Send a few touch-move events, followed by a touch-release event. All the |
| - // touch-move events should be coalesced into a single event. |
| - for (float i = 5; i < 15; ++i) |
| - MoveTouchPoint(0, i, i); |
| - |
| EXPECT_EQ(0U, GetAndResetSentEventCount()); |
| - EXPECT_EQ(2U, queued_event_count()); |
| - |
| - SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
| - EXPECT_EQ(1U, GetAndResetSentEventCount()); |
| EXPECT_EQ(1U, queued_event_count()); |
| - |
| - // The coalesced touch-move event has been sent to the renderer. Any new |
| - // touch-move event should not be coalesced with the sent event. |
| - MoveTouchPoint(0, 5, 5); |
| - EXPECT_EQ(2U, queued_event_count()); |
| - |
| - MoveTouchPoint(0, 7, 7); |
| - EXPECT_EQ(2U, queued_event_count()); |
| -} |
| - |
| -// Tests that coalescing works correctly for multi-touch events. |
| -TEST_F(TouchEventQueueTest, MultiTouch) { |
| - // Press the first finger. |
| - PressTouchPoint(1, 1); |
| - EXPECT_EQ(1U, GetAndResetSentEventCount()); |
| - |
| - // Move the finger. |
| - MoveTouchPoint(0, 5, 5); |
| - EXPECT_EQ(2U, queued_event_count()); |
| - |
| - // Now press a second finger. |
| - PressTouchPoint(2, 2); |
| - EXPECT_EQ(3U, queued_event_count()); |
| - |
| - // Move both fingers. |
| - MoveTouchPoints(0, 10, 10, 1, 20, 20); |
| - MoveTouchPoint(1, 20, 20); |
| - EXPECT_EQ(4U, queued_event_count()); |
| - |
| - // Move only one finger now. |
| - MoveTouchPoint(0, 15, 15); |
| - EXPECT_EQ(4U, queued_event_count()); |
| - |
| - // Move the other finger. |
| - MoveTouchPoint(1, 25, 25); |
| - EXPECT_EQ(4U, queued_event_count()); |
| - |
| - // Make sure both fingers are marked as having been moved in the coalesced |
| - // event. |
| - const WebTouchEvent& event = latest_event(); |
| - EXPECT_EQ(WebTouchPoint::StateMoved, event.touches[0].state); |
| - EXPECT_EQ(WebTouchPoint::StateMoved, event.touches[1].state); |
| } |
| // Tests that the touch-event queue is robust to redundant acks. |
| -TEST_F(TouchEventQueueTest, SpuriousAcksIgnored) { |
| +TEST_F(PassthroughTouchEventQueueTest, SpuriousAcksIgnored) { |
| // Trigger a spurious ack. |
| SendTouchEventAckWithID(INPUT_EVENT_ACK_STATE_CONSUMED, 0); |
| EXPECT_EQ(0U, GetAndResetAckedEventCount()); |
| @@ -714,24 +610,22 @@ TEST_F(TouchEventQueueTest, SpuriousAcksIgnored) { |
| // Tests that touch-move events are not sent to the renderer if the preceding |
| // touch-press event did not have a consumer (and consequently, did not hit the |
| -// main thread in the renderer). Also tests that all queued/coalesced touch |
| -// events are flushed immediately when the ACK for the touch-press comes back |
| -// with NO_CONSUMER status. |
| -TEST_F(TouchEventQueueTest, NoConsumer) { |
| +// main thread in the renderer). |
| +TEST_F(PassthroughTouchEventQueueTest, NoConsumer) { |
| // The first touch-press should reach the renderer. |
| PressTouchPoint(1, 1); |
| EXPECT_EQ(1U, GetAndResetSentEventCount()); |
| - // The second touch should not be sent since one is already in queue. |
| + // The second touch should be sent since we don't know if there is |
| + // a consumer or not. |
| MoveTouchPoint(0, 5, 5); |
| - EXPECT_EQ(0U, GetAndResetSentEventCount()); |
| + EXPECT_EQ(1U, GetAndResetSentEventCount()); |
| EXPECT_EQ(2U, queued_event_count()); |
| - // Receive an ACK for the first touch-event. This should release the queued |
| - // touch-event, but it should not be sent to the renderer. |
| + // Receive an ACK for the first touch-event and the first touch-move |
| + SendTouchEventAck(INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS); |
| SendTouchEventAck(INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS); |
| EXPECT_EQ(0U, queued_event_count()); |
| - EXPECT_EQ(WebInputEvent::TouchMove, acked_event().type()); |
| EXPECT_EQ(2U, GetAndResetAckedEventCount()); |
| EXPECT_EQ(0U, GetAndResetSentEventCount()); |
| @@ -741,101 +635,55 @@ TEST_F(TouchEventQueueTest, NoConsumer) { |
| EXPECT_EQ(WebInputEvent::TouchEnd, acked_event().type()); |
| EXPECT_EQ(1U, GetAndResetAckedEventCount()); |
| - // Send a press-event, followed by move and release events, and another press |
| - // event, before the ACK for the first press event comes back. All of the |
| - // events should be queued first. After the NO_CONSUMER ack for the first |
| - // touch-press, all events upto the second touch-press should be flushed. |
| + // Send a press-event, followed by move. Ack the touch move as no consumer |
| + // and further queued touch moves should be ack'd right away. |
| PressTouchPoint(10, 10); |
| - EXPECT_EQ(1U, GetAndResetSentEventCount()); |
| - |
| MoveTouchPoint(0, 5, 5); |
| MoveTouchPoint(0, 6, 5); |
| - ReleaseTouchPoint(0); |
| - |
| - PressTouchPoint(6, 5); |
| - EXPECT_EQ(0U, GetAndResetSentEventCount()); |
| - // The queue should hold the first sent touch-press event, the coalesced |
| - // touch-move event, the touch-end event and the second touch-press event. |
| - EXPECT_EQ(4U, queued_event_count()); |
| - |
| - SendTouchEventAck(INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS); |
| - EXPECT_EQ(1U, GetAndResetSentEventCount()); |
| - EXPECT_EQ(WebInputEvent::TouchEnd, acked_event().type()); |
| - EXPECT_EQ(4U, GetAndResetAckedEventCount()); |
| - EXPECT_EQ(1U, queued_event_count()); |
| + EXPECT_EQ(3U, GetAndResetSentEventCount()); |
| + EXPECT_EQ(3U, queued_event_count()); |
| - // ACK the second press event as NO_CONSUMER too. |
| SendTouchEventAck(INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS); |
| - EXPECT_EQ(0U, GetAndResetSentEventCount()); |
| EXPECT_EQ(WebInputEvent::TouchStart, acked_event().type()); |
| + EXPECT_EQ(0U, GetAndResetSentEventCount()); |
| EXPECT_EQ(1U, GetAndResetAckedEventCount()); |
| - EXPECT_EQ(0U, queued_event_count()); |
| - // Send a second press event. Even though the first touch press had |
| - // NO_CONSUMER, this press event should reach the renderer. |
| - PressTouchPoint(1, 1); |
| - EXPECT_EQ(1U, GetAndResetSentEventCount()); |
| - EXPECT_EQ(1U, queued_event_count()); |
| - SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED); |
| - EXPECT_EQ(WebInputEvent::TouchStart, acked_event().type()); |
| + MoveTouchPoint(0, 6, 5); |
| + EXPECT_EQ(WebInputEvent::TouchMove, acked_event().type()); |
| + EXPECT_EQ(0U, GetAndResetSentEventCount()); |
| EXPECT_EQ(1U, GetAndResetAckedEventCount()); |
| } |
| -TEST_F(TouchEventQueueTest, ConsumerIgnoreMultiFinger) { |
| - // Interleave three pointer press, move and release events. |
| +TEST_F(PassthroughTouchEventQueueTest, AckTouchEventInReverse) { |
| PressTouchPoint(1, 1); |
| MoveTouchPoint(0, 5, 5); |
| - PressTouchPoint(10, 10); |
| - MoveTouchPoint(1, 15, 15); |
| - PressTouchPoint(20, 20); |
| - MoveTouchPoint(2, 25, 25); |
| - ReleaseTouchPoint(2); |
| - MoveTouchPoint(1, 20, 20); |
| - ReleaseTouchPoint(1); |
| - MoveTouchPoint(0, 10, 10); |
| + MoveTouchPoint(0, 15, 15); |
| ReleaseTouchPoint(0); |
| - // Since the first touch-press is still pending ACK, no other event should |
| - // have been sent to the renderer. |
| - EXPECT_EQ(1U, GetAndResetSentEventCount()); |
| - EXPECT_EQ(0U, GetAndResetSentEventCount()); |
| - EXPECT_EQ(11U, queued_event_count()); |
| + EXPECT_EQ(4U, GetAndResetSentEventCount()); |
| + EXPECT_EQ(4U, queued_event_count()); |
| - // ACK the first press as CONSUMED. This should cause the first touch-move of |
| - // the first touch-point to be dispatched. |
| - SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED); |
| - EXPECT_EQ(1U, GetAndResetSentEventCount()); |
| - EXPECT_EQ(10U, queued_event_count()); |
| + SendTouchEventAckLast(INPUT_EVENT_ACK_STATE_CONSUMED); |
| + EXPECT_EQ(0U, GetAndResetAckedEventCount()); |
| + EXPECT_EQ(4U, queued_event_count()); |
| - // ACK the first move as CONSUMED. |
| SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED); |
| - EXPECT_EQ(1U, GetAndResetSentEventCount()); |
| - EXPECT_EQ(9U, queued_event_count()); |
| - |
| - // ACK the second press as NO_CONSUMER_EXISTS. The second pointer's touchmove |
| - // should still be forwarded, despite lacking a direct consumer. |
| - SendTouchEventAck(INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS); |
| - EXPECT_EQ(1U, GetAndResetSentEventCount()); |
| - EXPECT_EQ(8U, queued_event_count()); |
| - |
| - // ACK the coalesced move as NOT_CONSUMED. |
| - SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
| - EXPECT_EQ(1U, GetAndResetSentEventCount()); |
| - EXPECT_EQ(7U, queued_event_count()); |
| - |
| - // All remaining touch events should be forwarded, even if the third pointer |
| - // press also reports no consumer. |
| - SendTouchEventAck(INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS); |
| - EXPECT_EQ(6U, queued_event_count()); |
| + EXPECT_EQ(WebInputEvent::TouchStart, acked_event().type()); |
| + EXPECT_EQ(1U, GetAndResetAckedEventCount()); |
| + EXPECT_EQ(3U, queued_event_count()); |
| - while (queued_event_count()) |
| - SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
| + SendTouchEventAckLast(INPUT_EVENT_ACK_STATE_CONSUMED); |
| + EXPECT_EQ(0U, GetAndResetAckedEventCount()); |
| + EXPECT_EQ(3U, queued_event_count()); |
| - EXPECT_EQ(6U, GetAndResetSentEventCount()); |
| + SendTouchEventAckLast(INPUT_EVENT_ACK_STATE_CONSUMED); |
| + EXPECT_EQ(WebInputEvent::TouchEnd, acked_event().type()); |
| + EXPECT_EQ(3U, GetAndResetAckedEventCount()); |
| + EXPECT_EQ(0U, queued_event_count()); |
| } |
| // Tests that touch-event's enqueued via a touch ack are properly handled. |
| -TEST_F(TouchEventQueueTest, AckWithFollowupEvents) { |
| +TEST_F(PassthroughTouchEventQueueTest, AckWithFollowupEvents) { |
| // Queue a touch down. |
| PressTouchPoint(1, 1); |
| EXPECT_EQ(1U, queued_event_count()); |
| @@ -874,7 +722,7 @@ TEST_F(TouchEventQueueTest, AckWithFollowupEvents) { |
| } |
| // Tests that touch-events can be synchronously ack'ed. |
| -TEST_F(TouchEventQueueTest, SynchronousAcks) { |
| +TEST_F(PassthroughTouchEventQueueTest, SynchronousAcks) { |
| // TouchStart |
| SetSyncAckResult(INPUT_EVENT_ACK_STATE_CONSUMED); |
| PressTouchPoint(1, 1); |
| @@ -912,7 +760,7 @@ TEST_F(TouchEventQueueTest, SynchronousAcks) { |
| // Tests that followup events triggered by an immediate ack from |
| // TouchEventQueue::QueueEvent() are properly handled. |
| -TEST_F(TouchEventQueueTest, ImmediateAckWithFollowupEvents) { |
| +TEST_F(PassthroughTouchEventQueueTest, ImmediateAckWithFollowupEvents) { |
| // Create a touch event that will be queued synchronously by a touch ack. |
| WebTouchEvent followup_event( |
| WebInputEvent::TouchStart, WebInputEvent::NoModifiers, |
| @@ -942,7 +790,7 @@ TEST_F(TouchEventQueueTest, ImmediateAckWithFollowupEvents) { |
| } |
| // Tests basic TouchEvent forwarding suppression. |
| -TEST_F(TouchEventQueueTest, NoTouchBasic) { |
| +TEST_F(PassthroughTouchEventQueueTest, NoTouchBasic) { |
| // Disable TouchEvent forwarding. |
| OnHasTouchEventHandlers(false); |
| PressTouchPoint(30, 5); |
| @@ -979,8 +827,7 @@ TEST_F(TouchEventQueueTest, NoTouchBasic) { |
| } |
| // Tests that IsTouchStartPendingAck works correctly. |
| -TEST_F(TouchEventQueueTest, PendingStart) { |
| - |
| +TEST_F(PassthroughTouchEventQueueTest, PendingStart) { |
| EXPECT_FALSE(IsPendingAckTouchStart()); |
| // Send the touchstart for one point (#1). |
| @@ -1025,7 +872,7 @@ TEST_F(TouchEventQueueTest, PendingStart) { |
| } |
| // Tests that the touch timeout is started when sending certain touch types. |
| -TEST_F(TouchEventQueueTest, TouchTimeoutTypes) { |
| +TEST_F(PassthroughTouchEventQueueTest, TouchTimeoutTypes) { |
| SetUpForTimeoutTesting(); |
| // Sending a TouchStart will start the timeout. |
| @@ -1059,7 +906,7 @@ TEST_F(TouchEventQueueTest, TouchTimeoutTypes) { |
| // Tests that a delayed TouchEvent ack will trigger a TouchCancel timeout, |
| // disabling touch forwarding until the next TouchStart is received after |
| // the timeout events are ack'ed. |
| -TEST_F(TouchEventQueueTest, TouchTimeoutBasic) { |
| +TEST_F(PassthroughTouchEventQueueTest, TouchTimeoutBasic) { |
| SetUpForTimeoutTesting(); |
| // Queue a TouchStart. |
| @@ -1113,7 +960,8 @@ TEST_F(TouchEventQueueTest, TouchTimeoutBasic) { |
| // Tests that the timeout is never started if the renderer consumes |
| // a TouchEvent from the current touch sequence. |
| -TEST_F(TouchEventQueueTest, NoTouchTimeoutIfRendererIsConsumingGesture) { |
| +TEST_F(PassthroughTouchEventQueueTest, |
| + NoTouchTimeoutIfRendererIsConsumingGesture) { |
| SetUpForTimeoutTesting(); |
| // Queue a TouchStart. |
| @@ -1147,7 +995,8 @@ TEST_F(TouchEventQueueTest, NoTouchTimeoutIfRendererIsConsumingGesture) { |
| // Tests that the timeout is never started if the renderer consumes |
| // a TouchEvent from the current touch sequence. |
| -TEST_F(TouchEventQueueTest, NoTouchTimeoutIfDisabledAfterTouchStart) { |
| +TEST_F(PassthroughTouchEventQueueTest, |
| + NoTouchTimeoutIfDisabledAfterTouchStart) { |
| SetUpForTimeoutTesting(); |
| // Queue a TouchStart. |
| @@ -1173,7 +1022,7 @@ TEST_F(TouchEventQueueTest, NoTouchTimeoutIfDisabledAfterTouchStart) { |
| } |
| // Tests that the timeout is never started if the ack is synchronous. |
| -TEST_F(TouchEventQueueTest, NoTouchTimeoutIfAckIsSynchronous) { |
| +TEST_F(PassthroughTouchEventQueueTest, NoTouchTimeoutIfAckIsSynchronous) { |
| SetUpForTimeoutTesting(); |
| // Queue a TouchStart. |
| @@ -1185,7 +1034,8 @@ TEST_F(TouchEventQueueTest, NoTouchTimeoutIfAckIsSynchronous) { |
| // Tests that the timeout does not fire if explicitly disabled while an event |
| // is in-flight. |
| -TEST_F(TouchEventQueueTest, NoTouchTimeoutIfDisabledWhileTimerIsActive) { |
| +TEST_F(PassthroughTouchEventQueueTest, |
| + NoTouchTimeoutIfDisabledWhileTimerIsActive) { |
| SetUpForTimeoutTesting(); |
| // Queue a TouchStart. |
| @@ -1200,7 +1050,7 @@ TEST_F(TouchEventQueueTest, NoTouchTimeoutIfDisabledWhileTimerIsActive) { |
| } |
| // Tests that the timeout does not fire if the delay is zero. |
| -TEST_F(TouchEventQueueTest, NoTouchTimeoutIfTimeoutDelayIsZero) { |
| +TEST_F(PassthroughTouchEventQueueTest, NoTouchTimeoutIfTimeoutDelayIsZero) { |
| SetUpForTimeoutTesting(base::TimeDelta(), base::TimeDelta()); |
| // As the delay is zero, timeout behavior should be disabled. |
| @@ -1211,7 +1061,7 @@ TEST_F(TouchEventQueueTest, NoTouchTimeoutIfTimeoutDelayIsZero) { |
| } |
| // Tests that timeout delays for mobile sites take effect when appropriate. |
| -TEST_F(TouchEventQueueTest, TouchTimeoutConfiguredForMobile) { |
| +TEST_F(PassthroughTouchEventQueueTest, TouchTimeoutConfiguredForMobile) { |
| base::TimeDelta desktop_delay = DefaultTouchTimeoutDelay(); |
| base::TimeDelta mobile_delay = base::TimeDelta(); |
| SetUpForTimeoutTesting(desktop_delay, mobile_delay); |
| @@ -1238,7 +1088,7 @@ TEST_F(TouchEventQueueTest, TouchTimeoutConfiguredForMobile) { |
| // Tests that a TouchCancel timeout plays nice when the timed out touch stream |
| // turns into a scroll gesture sequence. |
| -TEST_F(TouchEventQueueTest, TouchTimeoutWithFollowupGesture) { |
| +TEST_F(PassthroughTouchEventQueueTest, TouchTimeoutWithFollowupGesture) { |
| SetUpForTimeoutTesting(); |
| // Queue a TouchStart. |
| @@ -1294,7 +1144,8 @@ TEST_F(TouchEventQueueTest, TouchTimeoutWithFollowupGesture) { |
| // Tests that a TouchCancel timeout plays nice when the timed out touch stream |
| // turns into a scroll gesture sequence, but the original event acks are |
| // significantly delayed. |
| -TEST_F(TouchEventQueueTest, TouchTimeoutWithFollowupGestureAndDelayedAck) { |
| +TEST_F(PassthroughTouchEventQueueTest, |
| + TouchTimeoutWithFollowupGestureAndDelayedAck) { |
| SetUpForTimeoutTesting(); |
| // Queue a TouchStart. |
| @@ -1351,7 +1202,7 @@ TEST_F(TouchEventQueueTest, TouchTimeoutWithFollowupGestureAndDelayedAck) { |
| // Tests that a delayed TouchEvent ack will not trigger a TouchCancel timeout if |
| // the timed-out event had no consumer. |
| -TEST_F(TouchEventQueueTest, NoCancelOnTouchTimeoutWithoutConsumer) { |
| +TEST_F(PassthroughTouchEventQueueTest, NoCancelOnTouchTimeoutWithoutConsumer) { |
| SetUpForTimeoutTesting(); |
| // Queue a TouchStart. |
| @@ -1390,7 +1241,7 @@ TEST_F(TouchEventQueueTest, NoCancelOnTouchTimeoutWithoutConsumer) { |
| // Tests that TouchMove's movedBeyondSlopRegion is set to false if within the |
| // boundary-inclusive slop region for an unconsumed TouchStart. |
| -TEST_F(TouchEventQueueTest, TouchMovedBeyondSlopRegionCheck) { |
| +TEST_F(PassthroughTouchEventQueueTest, TouchMovedBeyondSlopRegionCheck) { |
| SetUpForTouchMoveSlopTesting(kSlopLengthDips); |
| // Queue a TouchStart. |
| @@ -1440,7 +1291,7 @@ TEST_F(TouchEventQueueTest, TouchMovedBeyondSlopRegionCheck) { |
| const float kFortyFiveDegreeSlopLengthXY = |
| kSlopLengthDips * std::sqrt(2.f) / 2; |
| MoveTouchPoint(0, kFortyFiveDegreeSlopLengthXY + .2f, |
| - kFortyFiveDegreeSlopLengthXY + .2f); |
| + kFortyFiveDegreeSlopLengthXY + .2f); |
| EXPECT_EQ(1U, queued_event_count()); |
| EXPECT_EQ(1U, GetAndResetSentEventCount()); |
| EXPECT_EQ(0U, GetAndResetAckedEventCount()); |
| @@ -1451,7 +1302,8 @@ TEST_F(TouchEventQueueTest, TouchMovedBeyondSlopRegionCheck) { |
| // Tests that even very small TouchMove's movedBeyondSlopRegion is set to true |
| // when the slop region's dimension is 0. |
| -TEST_F(TouchEventQueueTest, MovedBeyondSlopRegionAlwaysTrueIfDimensionZero) { |
| +TEST_F(PassthroughTouchEventQueueTest, |
| + MovedBeyondSlopRegionAlwaysTrueIfDimensionZero) { |
| // Queue a TouchStart. |
| PressTouchPoint(0, 0); |
| SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
| @@ -1470,7 +1322,8 @@ TEST_F(TouchEventQueueTest, MovedBeyondSlopRegionAlwaysTrueIfDimensionZero) { |
| // Tests that secondary touch points can be forwarded even if the primary touch |
| // point had no consumer. |
| -TEST_F(TouchEventQueueTest, SecondaryTouchForwardedAfterPrimaryHadNoConsumer) { |
| +TEST_F(PassthroughTouchEventQueueTest, |
| + SecondaryTouchForwardedAfterPrimaryHadNoConsumer) { |
| // Queue a TouchStart. |
| PressTouchPoint(0, 0); |
| SendTouchEventAck(INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS); |
| @@ -1499,7 +1352,8 @@ TEST_F(TouchEventQueueTest, SecondaryTouchForwardedAfterPrimaryHadNoConsumer) { |
| // Tests that secondary touch points can be forwarded after scrolling begins |
| // while first touch point has no consumer. |
| -TEST_F(TouchEventQueueTest, NoForwardingAfterScrollWithNoTouchConsumers) { |
| +TEST_F(PassthroughTouchEventQueueTest, |
| + NoForwardingAfterScrollWithNoTouchConsumers) { |
| // Queue a TouchStart. |
| PressTouchPoint(0, 0); |
| SendTouchEventAck(INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS); |
| @@ -1529,818 +1383,73 @@ TEST_F(TouchEventQueueTest, NoForwardingAfterScrollWithNoTouchConsumers) { |
| EXPECT_EQ(1U, GetAndResetAckedEventCount()); |
| } |
| -TEST_F(TouchEventQueueTest, AsyncTouch) { |
| +TEST_F(PassthroughTouchEventQueueTest, TouchAbsorptionWithConsumedFirstMove) { |
| // Queue a TouchStart. |
| PressTouchPoint(0, 1); |
| - EXPECT_EQ(1U, GetAndResetSentEventCount()); |
| SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
| + EXPECT_EQ(0U, queued_event_count()); |
| EXPECT_EQ(1U, GetAndResetAckedEventCount()); |
| - for (int i = 0; i < 3; ++i) { |
| - SendGestureEventAck(WebInputEvent::GestureScrollUpdate, |
| - INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
| - |
| - MoveTouchPoint(0, 10, 5+i); |
| - SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
| - EXPECT_FALSE(HasPendingAsyncTouchMove()); |
| - EXPECT_EQ(WebInputEvent::Blocking, sent_event().dispatchType); |
| - EXPECT_EQ(0U, queued_event_count()); |
| - EXPECT_EQ(1U, GetAndResetSentEventCount()); |
| - |
| - // Consuming a scroll event will throttle subsequent touchmoves. |
| - SendGestureEventAck(WebInputEvent::GestureScrollUpdate, |
| - INPUT_EVENT_ACK_STATE_CONSUMED); |
| - MoveTouchPoint(0, 10, 7+i); |
| - EXPECT_TRUE(HasPendingAsyncTouchMove()); |
| - EXPECT_EQ(0U, queued_event_count()); |
| - EXPECT_EQ(0U, GetAndResetSentEventCount()); |
| - } |
| -} |
| + MoveTouchPoint(0, 20, 5); |
| + SendGestureEvent(blink::WebInputEvent::GestureScrollBegin); |
| + SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED); |
| + EXPECT_EQ(0U, queued_event_count()); |
| + EXPECT_EQ(2U, GetAndResetSentEventCount()); |
| -// Ensure that touchmove's are appropriately throttled during a typical |
| -// scroll sequences that transitions between scrolls consumed and unconsumed. |
| -TEST_F(TouchEventQueueTest, AsyncTouchThrottledAfterScroll) { |
| - // Process a TouchStart |
| - PressTouchPoint(0, 1); |
| + // Even if the first touchmove event was consumed, subsequent unconsumed |
| + // touchmove events should trigger scrolling. |
| + MoveTouchPoint(0, 60, 5); |
| + SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED); |
| + EXPECT_EQ(0U, queued_event_count()); |
| + EXPECT_EQ(WebInputEvent::Blocking, sent_event().dispatchType); |
| EXPECT_EQ(1U, GetAndResetSentEventCount()); |
| - SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
| - EXPECT_EQ(1U, GetAndResetAckedEventCount()); |
| - // Now send the first touch move and associated GestureScrollBegin. |
| - MoveTouchPoint(0, 0, 5); |
| - WebGestureEvent followup_scroll(WebInputEvent::GestureScrollBegin, |
| + MoveTouchPoint(0, 20, 5); |
| + WebGestureEvent followup_scroll(WebInputEvent::GestureScrollUpdate, |
| WebInputEvent::NoModifiers, |
| WebInputEvent::TimeStampForTesting); |
| SetFollowupEvent(followup_scroll); |
| SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
| - EXPECT_EQ(1U, GetAndResetSentEventCount()); |
| - EXPECT_EQ(1U, GetAndResetAckedEventCount()); |
| - SendGestureEventAck(WebInputEvent::GestureScrollBegin, |
| - INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
| - |
| - // Send the second touch move and associated GestureScrollUpdate, but don't |
| - // ACK the gesture event yet. |
| - MoveTouchPoint(0, 0, 50); |
| - followup_scroll.setType(WebInputEvent::GestureScrollUpdate); |
| - SetFollowupEvent(followup_scroll); |
| - SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
| - EXPECT_EQ(1U, GetAndResetSentEventCount()); |
| - EXPECT_EQ(1U, GetAndResetAckedEventCount()); |
| - |
| - // Now queue a second touchmove and verify it's not (yet) dispatched. |
| - MoveTouchPoint(0, 0, 100); |
| - SetFollowupEvent(followup_scroll); |
| - EXPECT_TRUE(HasPendingAsyncTouchMove()); |
| + SendGestureEventAck(WebInputEvent::GestureScrollUpdate, |
| + INPUT_EVENT_ACK_STATE_CONSUMED); |
| EXPECT_EQ(0U, queued_event_count()); |
| - EXPECT_EQ(0U, GetAndResetSentEventCount()); |
| - EXPECT_EQ(1U, GetAndResetAckedEventCount()); |
| + EXPECT_EQ(WebInputEvent::Blocking, sent_event().dispatchType); |
| + EXPECT_EQ(1U, GetAndResetSentEventCount()); |
| - // Queuing the final touchend should flush the pending async touchmove. In |
| - // this case, we will first dispatch an async touchmove and then a touchend. |
| - // For the async touchmove, we will not send ack again. |
| - ReleaseTouchPoint(0); |
| - followup_scroll.setType(WebInputEvent::GestureScrollEnd); |
| - SetFollowupEvent(followup_scroll); |
| - EXPECT_FALSE(HasPendingAsyncTouchMove()); |
| - EXPECT_EQ(2U, all_sent_events().size()); |
| - EXPECT_EQ(WebInputEvent::TouchMove, all_sent_events()[0].type()); |
| - EXPECT_NE(WebInputEvent::Blocking, all_sent_events()[0].dispatchType); |
| - EXPECT_EQ(WebInputEvent::TouchEnd, all_sent_events()[1].type()); |
| - EXPECT_NE(WebInputEvent::Blocking, all_sent_events()[1].dispatchType); |
| - EXPECT_EQ(2U, GetAndResetSentEventCount()); |
| - EXPECT_EQ(0U, GetAndResetAckedEventCount()); |
| + // Touch moves are sent right away. |
| + MoveTouchPoint(0, 60, 5); |
| EXPECT_EQ(1U, queued_event_count()); |
| + EXPECT_EQ(1U, GetAndResetSentEventCount()); |
| +} |
| - // Ack the touchend. |
| - SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
| +TEST_F(PassthroughTouchEventQueueTest, TouchStartCancelableDuringScroll) { |
| + // Queue a touchstart and touchmove that go unconsumed, transitioning to an |
| + // active scroll sequence. |
| + PressTouchPoint(0, 1); |
| SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
| - EXPECT_EQ(0U, queued_event_count()); |
| - EXPECT_EQ(0U, GetAndResetSentEventCount()); |
| - EXPECT_EQ(1U, GetAndResetAckedEventCount()); |
| - |
| - // Now mark the scrolls as not consumed (which would cause future touchmoves |
| - // in the active sequence to be sent if there was one). |
| - SendGestureEventAck(WebInputEvent::GestureScrollUpdate, |
| - INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
| - SendGestureEventAck(WebInputEvent::GestureScrollUpdate, |
| - INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
| + EXPECT_EQ(WebInputEvent::Blocking, sent_event().dispatchType); |
| + ASSERT_EQ(1U, GetAndResetSentEventCount()); |
| - // Start a new touch sequence and verify that throttling has been reset. |
| - // Touch moves after the start of scrolling will again be throttled. |
| - PressTouchPoint(0, 0); |
| - EXPECT_EQ(1U, GetAndResetSentEventCount()); |
| - SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
| - EXPECT_EQ(1U, GetAndResetAckedEventCount()); |
| - MoveTouchPoint(0, 0, 5); |
| - followup_scroll.setType(WebInputEvent::GestureScrollBegin); |
| - SetFollowupEvent(followup_scroll); |
| + MoveTouchPoint(0, 20, 5); |
| + EXPECT_EQ(WebInputEvent::Blocking, sent_event().dispatchType); |
| + SendGestureEvent(blink::WebInputEvent::GestureScrollBegin); |
| + SendGestureEvent(blink::WebInputEvent::GestureScrollUpdate); |
| SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
| - EXPECT_EQ(1U, GetAndResetSentEventCount()); |
| - EXPECT_EQ(1U, GetAndResetAckedEventCount()); |
| + EXPECT_EQ(WebInputEvent::Blocking, sent_event().dispatchType); |
| + ASSERT_EQ(1U, GetAndResetSentEventCount()); |
| - MoveTouchPoint(0, 0, 6); |
| - followup_scroll.setType(WebInputEvent::GestureScrollUpdate); |
| - SetFollowupEvent(followup_scroll); |
| - SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
| - EXPECT_FALSE(HasPendingAsyncTouchMove()); |
| - EXPECT_EQ(1U, GetAndResetSentEventCount()); |
| - EXPECT_EQ(1U, GetAndResetAckedEventCount()); |
| + // Even though scrolling has begun, touchstart events should be cancelable, |
| + // allowing, for example, customized pinch processing. |
| + PressTouchPoint(10, 11); |
| + SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED); |
| + EXPECT_EQ(WebInputEvent::Blocking, sent_event().dispatchType); |
| + ASSERT_EQ(1U, GetAndResetSentEventCount()); |
| - MoveTouchPoint(0, 0, 10); |
| - EXPECT_TRUE(HasPendingAsyncTouchMove()); |
| - EXPECT_EQ(0U, queued_event_count()); |
| - EXPECT_EQ(0U, GetAndResetSentEventCount()); |
| - EXPECT_EQ(1U, GetAndResetAckedEventCount()); |
| - |
| - // Subsequent touchmove's should be deferred. |
| - MoveTouchPoint(0, 0, 25); |
| - EXPECT_TRUE(HasPendingAsyncTouchMove()); |
| - EXPECT_EQ(0U, queued_event_count()); |
| - EXPECT_EQ(0U, GetAndResetSentEventCount()); |
| - EXPECT_EQ(1U, GetAndResetAckedEventCount()); |
| - EXPECT_EQ(0U, uncancelable_touch_moves_pending_ack_count()); |
| - |
| - // The pending touchmove should be flushed with the the new touchmove if |
| - // sufficient time has passed and ack to the client. |
| - AdvanceTouchTime(kMinSecondsBetweenThrottledTouchmoves + 0.1); |
| - MoveTouchPoint(0, 0, 15); |
| - SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
| - EXPECT_FALSE(HasPendingAsyncTouchMove()); |
| - EXPECT_NE(WebInputEvent::Blocking, sent_event().dispatchType); |
| - EXPECT_EQ(0U, queued_event_count()); |
| - EXPECT_EQ(1U, GetAndResetSentEventCount()); |
| - EXPECT_EQ(1U, GetAndResetAckedEventCount()); |
| - |
| - // Non-touchmove events should always flush any pending touchmove events. In |
| - // this case, we will first dispatch an async touchmove and then a |
| - // touchstart. For the async touchmove, we will not send ack again. |
| - MoveTouchPoint(0, 0, 25); |
| - EXPECT_TRUE(HasPendingAsyncTouchMove()); |
| - EXPECT_EQ(0U, queued_event_count()); |
| - EXPECT_EQ(0U, GetAndResetSentEventCount()); |
| - EXPECT_EQ(1U, GetAndResetAckedEventCount()); |
| - PressTouchPoint(30, 30); |
| - EXPECT_FALSE(HasPendingAsyncTouchMove()); |
| - EXPECT_EQ(2U, all_sent_events().size()); |
| - EXPECT_EQ(WebInputEvent::TouchMove, all_sent_events()[0].type()); |
| - EXPECT_NE(WebInputEvent::Blocking, all_sent_events()[0].dispatchType); |
| - EXPECT_EQ(WebInputEvent::TouchStart, all_sent_events()[1].type()); |
| - EXPECT_EQ(WebInputEvent::Blocking, all_sent_events()[1].dispatchType); |
| - EXPECT_EQ(2U, GetAndResetSentEventCount()); |
| - EXPECT_EQ(0U, GetAndResetAckedEventCount()); |
| - EXPECT_EQ(1U, queued_event_count()); |
| - |
| - // Ack the touchstart. |
| - SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
| - SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
| - EXPECT_EQ(0U, queued_event_count()); |
| - EXPECT_EQ(0U, GetAndResetSentEventCount()); |
| - EXPECT_EQ(1U, GetAndResetAckedEventCount()); |
| - |
| - // Send a secondary touchmove. |
| - MoveTouchPoint(1, 0, 25); |
| - EXPECT_TRUE(HasPendingAsyncTouchMove()); |
| - EXPECT_EQ(0U, queued_event_count()); |
| - EXPECT_EQ(0U, GetAndResetSentEventCount()); |
| - EXPECT_EQ(1U, GetAndResetAckedEventCount()); |
| - |
| - // An unconsumed scroll should resume synchronous touch handling. |
| - SendGestureEventAck(WebInputEvent::GestureScrollUpdate, |
| - INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
| - |
| - // The pending touchmove should be coalesced with the next (now synchronous) |
| - // touchmove. |
| - MoveTouchPoint(0, 0, 26); |
| - EXPECT_EQ(WebInputEvent::Blocking, sent_event().dispatchType); |
| - EXPECT_FALSE(HasPendingAsyncTouchMove()); |
| - EXPECT_EQ(WebInputEvent::TouchMove, sent_event().type()); |
| - EXPECT_EQ(WebTouchPoint::StateMoved, sent_event().touches[0].state); |
| - EXPECT_EQ(WebTouchPoint::StateMoved, sent_event().touches[1].state); |
| - EXPECT_EQ(1U, queued_event_count()); |
| - EXPECT_EQ(1U, GetAndResetSentEventCount()); |
| - EXPECT_EQ(0U, GetAndResetAckedEventCount()); |
| - |
| - // Subsequent touches will queue until the preceding, synchronous touches are |
| - // ack'ed. |
| - ReleaseTouchPoint(1); |
| - EXPECT_EQ(2U, queued_event_count()); |
| - ReleaseTouchPoint(0); |
| - EXPECT_EQ(3U, queued_event_count()); |
| - SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
| - EXPECT_EQ(WebInputEvent::Blocking, sent_event().dispatchType); |
| - EXPECT_EQ(WebInputEvent::TouchEnd, sent_event().type()); |
| - EXPECT_EQ(2U, queued_event_count()); |
| - EXPECT_EQ(1U, GetAndResetSentEventCount()); |
| - EXPECT_EQ(1U, GetAndResetAckedEventCount()); |
| - |
| - SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
| - EXPECT_EQ(WebInputEvent::Blocking, sent_event().dispatchType); |
| - EXPECT_EQ(WebInputEvent::TouchEnd, sent_event().type()); |
| - EXPECT_EQ(1U, queued_event_count()); |
| - EXPECT_EQ(1U, GetAndResetSentEventCount()); |
| - EXPECT_EQ(1U, GetAndResetAckedEventCount()); |
| - |
| - SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
| - EXPECT_EQ(0U, queued_event_count()); |
| - EXPECT_EQ(0U, GetAndResetSentEventCount()); |
| - EXPECT_EQ(1U, GetAndResetAckedEventCount()); |
| -} |
| - |
| -TEST_F(TouchEventQueueTest, AsyncTouchFlushedByTouchEnd) { |
| - PressTouchPoint(0, 0); |
| - SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
| - EXPECT_EQ(1U, GetAndResetSentEventCount()); |
| - EXPECT_EQ(1U, GetAndResetAckedEventCount()); |
| - |
| - // Initiate async touchmove dispatch after the start of a scroll sequence. |
| - MoveTouchPoint(0, 0, 5); |
| - WebGestureEvent followup_scroll(WebInputEvent::GestureScrollBegin, |
| - WebInputEvent::NoModifiers, |
| - WebInputEvent::TimeStampForTesting); |
| - SetFollowupEvent(followup_scroll); |
| - SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
| - EXPECT_EQ(1U, GetAndResetSentEventCount()); |
| - EXPECT_EQ(1U, GetAndResetAckedEventCount()); |
| - |
| - MoveTouchPoint(0, 0, 10); |
| - followup_scroll.setType(WebInputEvent::GestureScrollUpdate); |
| - SetFollowupEvent(followup_scroll); |
| - SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
| - EXPECT_EQ(1U, GetAndResetSentEventCount()); |
| - EXPECT_EQ(1U, GetAndResetAckedEventCount()); |
| - |
| - // Now queue a second touchmove and verify it's not (yet) dispatched. |
| - MoveTouchPoint(0, 0, 100); |
| - EXPECT_TRUE(HasPendingAsyncTouchMove()); |
| - EXPECT_EQ(0U, queued_event_count()); |
| - EXPECT_EQ(0U, GetAndResetSentEventCount()); |
| - EXPECT_EQ(1U, GetAndResetAckedEventCount()); |
| - |
| - // Return the touch sequence to the original touchstart position. Note that |
| - // this (0, 0) touchmove will coalesce with the previous (0, 100) touchmove. |
| - MoveTouchPoint(0, 0, 0); |
| - EXPECT_TRUE(HasPendingAsyncTouchMove()); |
| - EXPECT_EQ(0U, queued_event_count()); |
| - EXPECT_EQ(0U, GetAndResetSentEventCount()); |
| - EXPECT_EQ(1U, GetAndResetAckedEventCount()); |
| - |
| - // Queuing the final touchend should flush the pending, async touchmove. In |
| - // this case, we will first dispatch an async touchmove and then a touchend. |
| - // For the async touchmove, we will not send ack again. |
| - ReleaseTouchPoint(0); |
| - EXPECT_FALSE(HasPendingAsyncTouchMove()); |
| - EXPECT_EQ(2U, all_sent_events().size()); |
| - EXPECT_EQ(WebInputEvent::TouchMove, all_sent_events()[0].type()); |
| - EXPECT_NE(WebInputEvent::Blocking, all_sent_events()[0].dispatchType); |
| - EXPECT_EQ(0, all_sent_events()[0].touches[0].position.x); |
| - EXPECT_EQ(0, all_sent_events()[0].touches[0].position.y); |
| - EXPECT_EQ(WebInputEvent::TouchEnd, all_sent_events()[1].type()); |
| - EXPECT_NE(WebInputEvent::Blocking, all_sent_events()[1].dispatchType); |
| - EXPECT_EQ(2U, GetAndResetSentEventCount()); |
| - EXPECT_EQ(0U, GetAndResetAckedEventCount()); |
| -} |
| - |
| -// Ensure that async touch dispatch and touch ack timeout interactions work |
| -// appropriately. |
| -TEST_F(TouchEventQueueTest, AsyncTouchWithAckTimeout) { |
| - SetUpForTimeoutTesting(); |
| - |
| - // The touchstart should start the timeout. |
| - PressTouchPoint(0, 0); |
| - EXPECT_EQ(1U, GetAndResetSentEventCount()); |
| - EXPECT_TRUE(IsTimeoutRunning()); |
| - SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
| - EXPECT_EQ(1U, GetAndResetAckedEventCount()); |
| - EXPECT_FALSE(IsTimeoutRunning()); |
| - |
| - // The start of a scroll gesture should trigger async touch event dispatch. |
| - MoveTouchPoint(0, 1, 1); |
| - EXPECT_EQ(1U, GetAndResetSentEventCount()); |
| - EXPECT_TRUE(IsTimeoutRunning()); |
| - WebGestureEvent followup_scroll(WebInputEvent::GestureScrollBegin, |
| - WebInputEvent::NoModifiers, |
| - WebInputEvent::TimeStampForTesting); |
| - SetFollowupEvent(followup_scroll); |
| - SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
| - EXPECT_FALSE(IsTimeoutRunning()); |
| - EXPECT_EQ(1U, GetAndResetAckedEventCount()); |
| - |
| - SendGestureEventAck(WebInputEvent::GestureScrollUpdate, |
| - INPUT_EVENT_ACK_STATE_CONSUMED); |
| - |
| - // An async touch should fire after the throttling interval has expired, but |
| - // it should not start the touch ack timeout. |
| - MoveTouchPoint(0, 5, 5); |
| - EXPECT_TRUE(HasPendingAsyncTouchMove()); |
| - EXPECT_EQ(1U, GetAndResetAckedEventCount()); |
| - |
| - AdvanceTouchTime(kMinSecondsBetweenThrottledTouchmoves + 0.1); |
| - MoveTouchPoint(0, 5, 5); |
| - EXPECT_FALSE(IsTimeoutRunning()); |
| - EXPECT_FALSE(HasPendingAsyncTouchMove()); |
| - EXPECT_NE(WebInputEvent::Blocking, sent_event().dispatchType); |
| - EXPECT_EQ(1U, GetAndResetAckedEventCount()); |
| - EXPECT_EQ(1U, GetAndResetSentEventCount()); |
| - |
| - // An unconsumed scroll event will resume synchronous touchmoves, which are |
| - // subject to the ack timeout. |
| - SendGestureEventAck(WebInputEvent::GestureScrollUpdate, |
| - INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
| - MoveTouchPoint(0, 20, 5); |
| - EXPECT_TRUE(IsTimeoutRunning()); |
| - EXPECT_EQ(WebInputEvent::Blocking, sent_event().dispatchType); |
| - EXPECT_EQ(1U, GetAndResetSentEventCount()); |
| - |
| - // The timeout should fire, disabling touch forwarding until both acks are |
| - // received and acking the timed out event. |
| - RunTasksAndWait(DefaultTouchTimeoutDelay() * 2); |
| - EXPECT_FALSE(IsTimeoutRunning()); |
| - EXPECT_EQ(1U, GetAndResetAckedEventCount()); |
| - EXPECT_EQ(0U, GetAndResetSentEventCount()); |
| - |
| - // Ack'ing the original event should trigger a cancel event. |
| - SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
| - SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
| - EXPECT_NE(WebInputEvent::Blocking, sent_event().dispatchType); |
| - EXPECT_EQ(0U, GetAndResetAckedEventCount()); |
| - EXPECT_EQ(1U, GetAndResetSentEventCount()); |
| - |
| - // Subsequent touchmove's should not be forwarded, even as the scroll gesture |
| - // goes from unconsumed to consumed. |
| - SendGestureEventAck(WebInputEvent::GestureScrollUpdate, |
| - INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
| - MoveTouchPoint(0, 20, 5); |
| - EXPECT_FALSE(HasPendingAsyncTouchMove()); |
| - EXPECT_EQ(1U, GetAndResetAckedEventCount()); |
| - EXPECT_EQ(0U, GetAndResetSentEventCount()); |
| - |
| - SendGestureEventAck(WebInputEvent::GestureScrollUpdate, |
| - INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
| - MoveTouchPoint(0, 25, 5); |
| - EXPECT_FALSE(HasPendingAsyncTouchMove()); |
| - EXPECT_EQ(1U, GetAndResetAckedEventCount()); |
| - EXPECT_EQ(0U, GetAndResetSentEventCount()); |
| -} |
| - |
| -// Ensure that if the touch ack for an async touchmove triggers a follow-up |
| -// touch event, that follow-up touch will be forwarded appropriately. |
| -TEST_F(TouchEventQueueTest, AsyncTouchWithTouchCancelAfterAck) { |
| - PressTouchPoint(0, 0); |
| - EXPECT_EQ(1U, GetAndResetSentEventCount()); |
| - SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
| - EXPECT_EQ(1U, GetAndResetAckedEventCount()); |
| - |
| - // The start of a scroll gesture should trigger async touch event dispatch. |
| - MoveTouchPoint(0, 1, 1); |
| - EXPECT_EQ(1U, GetAndResetSentEventCount()); |
| - WebGestureEvent followup_scroll(WebInputEvent::GestureScrollBegin, |
| - WebInputEvent::NoModifiers, |
| - WebInputEvent::TimeStampForTesting); |
| - SetFollowupEvent(followup_scroll); |
| - SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
| - EXPECT_EQ(1U, GetAndResetAckedEventCount()); |
| - EXPECT_EQ(0U, queued_event_count()); |
| - |
| - SendGestureEvent(WebInputEvent::GestureScrollUpdate); |
| - |
| - // The async touchmove should be ack'ed immediately, but not forwarded. |
| - // However, because the ack triggers a touchcancel, both the pending touch and |
| - // the queued touchcancel should be flushed. |
| - WebTouchEvent followup_cancel(WebInputEvent::TouchCancel, |
| - WebInputEvent::NoModifiers, |
| - WebInputEvent::TimeStampForTesting); |
| - followup_cancel.touchesLength = 1; |
| - followup_cancel.touches[0].state = WebTouchPoint::StateCancelled; |
| - SetFollowupEvent(followup_cancel); |
| - MoveTouchPoint(0, 5, 5); |
| - EXPECT_EQ(1U, queued_event_count()); |
| - EXPECT_EQ(2U, all_sent_events().size()); |
| - EXPECT_EQ(WebInputEvent::TouchMove, all_sent_events()[0].type()); |
| - EXPECT_NE(WebInputEvent::Blocking, all_sent_events()[0].dispatchType); |
| - EXPECT_EQ(WebInputEvent::TouchCancel, all_sent_events()[1].type()); |
| - EXPECT_NE(WebInputEvent::Blocking, all_sent_events()[1].dispatchType); |
| - EXPECT_EQ(2U, GetAndResetSentEventCount()); |
| - // Sending the ack is because the async touchmove is not ready for |
| - // dispatching send the ack immediately. |
| - EXPECT_EQ(1U, GetAndResetAckedEventCount()); |
| - EXPECT_EQ(WebInputEvent::TouchMove, acked_event().type()); |
| - |
| - SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
| - SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
| - EXPECT_EQ(0U, queued_event_count()); |
| - EXPECT_EQ(WebInputEvent::TouchCancel, acked_event().type()); |
| - EXPECT_EQ(1U, GetAndResetAckedEventCount()); |
| - EXPECT_EQ(0U, GetAndResetSentEventCount()); |
| -} |
| - |
| -// Ensure that the async touch is fully reset if the touch sequence restarts |
| -// without properly terminating. |
| -TEST_F(TouchEventQueueTest, AsyncTouchWithHardTouchStartReset) { |
| - PressTouchPoint(0, 0); |
| - EXPECT_EQ(1U, GetAndResetSentEventCount()); |
| - SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
| - EXPECT_EQ(1U, GetAndResetAckedEventCount()); |
| - |
| - // Trigger async touchmove dispatch. |
| - MoveTouchPoint(0, 1, 1); |
| - EXPECT_EQ(1U, GetAndResetSentEventCount()); |
| - WebGestureEvent followup_scroll(WebInputEvent::GestureScrollBegin, |
| - WebInputEvent::NoModifiers, |
| - WebInputEvent::TimeStampForTesting); |
| - SetFollowupEvent(followup_scroll); |
| - SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
| - EXPECT_EQ(1U, GetAndResetAckedEventCount()); |
| - EXPECT_EQ(0U, queued_event_count()); |
| - SendGestureEvent(WebInputEvent::GestureScrollUpdate); |
| - |
| - // The async touchmove should be immediately ack'ed but delivery is deferred. |
| - MoveTouchPoint(0, 2, 2); |
| - EXPECT_EQ(0U, GetAndResetSentEventCount()); |
| - EXPECT_EQ(1U, GetAndResetAckedEventCount()); |
| - EXPECT_EQ(0U, queued_event_count()); |
| - EXPECT_EQ(WebInputEvent::TouchMove, acked_event().type()); |
| - |
| - // The queue should be robust to hard touch restarts with a new touch |
| - // sequence. In this case, the deferred async touch should not be flushed |
| - // by the new touch sequence. |
| - SendGestureEvent(WebInputEvent::GestureScrollEnd); |
| - ResetTouchEvent(); |
| - |
| - PressTouchPoint(0, 0); |
| - EXPECT_EQ(WebInputEvent::TouchStart, sent_event().type()); |
| - EXPECT_EQ(1U, GetAndResetSentEventCount()); |
| - SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
| - EXPECT_EQ(1U, GetAndResetAckedEventCount()); |
| -} |
| - |
| -// Ensure that even when the interval expires, we still need to wait for the |
| -// ack sent back from render to send the next async touchmove once the scroll |
| -// starts. |
| -TEST_F(TouchEventQueueTest, SendNextThrottledAsyncTouchMoveAfterAck) { |
| - // Process a TouchStart |
| - PressTouchPoint(0, 1); |
| - EXPECT_EQ(1U, GetAndResetSentEventCount()); |
| - SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
| - EXPECT_EQ(1U, GetAndResetAckedEventCount()); |
| - |
| - // Initiate async touchmove dispatch after the start of a scroll sequence. |
| - MoveTouchPoint(0, 0, 5); |
| - WebGestureEvent followup_scroll(WebInputEvent::GestureScrollBegin, |
| - WebInputEvent::NoModifiers, |
| - WebInputEvent::TimeStampForTesting); |
| - SetFollowupEvent(followup_scroll); |
| - SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
| - EXPECT_EQ(1U, GetAndResetSentEventCount()); |
| - EXPECT_EQ(1U, GetAndResetAckedEventCount()); |
| - |
| - MoveTouchPoint(0, 0, 10); |
| - followup_scroll.setType(WebInputEvent::GestureScrollUpdate); |
| - SetFollowupEvent(followup_scroll); |
| - SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
| - EXPECT_FALSE(HasPendingAsyncTouchMove()); |
| - EXPECT_EQ(1U, GetAndResetSentEventCount()); |
| - EXPECT_EQ(1U, GetAndResetAckedEventCount()); |
| - |
| - // We set the next touch event time to be after the throttled interval. |
| - AdvanceTouchTime(kMinSecondsBetweenThrottledTouchmoves + 0.1); |
| - // Dispatch the touch move event when sufficient time has passed. |
| - MoveTouchPoint(0, 0, 40); |
| - EXPECT_FALSE(HasPendingAsyncTouchMove()); |
| - EXPECT_NE(WebInputEvent::Blocking, sent_event().dispatchType); |
| - // When we dispatch an async touchmove, we do not put it back to the queue |
| - // any more and we will ack to client right away. |
| - EXPECT_EQ(0U, queued_event_count()); |
| - EXPECT_EQ(1U, GetAndResetSentEventCount()); |
| - EXPECT_EQ(1U, GetAndResetAckedEventCount()); |
| - EXPECT_EQ(1U, uncancelable_touch_moves_pending_ack_count()); |
| - |
| - // Do not dispatch the event until throttledTouchmoves intervals expires and |
| - // receive an ack from render. |
| - AdvanceTouchTime(kMinSecondsBetweenThrottledTouchmoves + 0.1); |
| - MoveTouchPoint(0, 0, 50); |
| - EXPECT_TRUE(HasPendingAsyncTouchMove()); |
| - EXPECT_EQ(0U, queued_event_count()); |
| - EXPECT_EQ(0U, GetAndResetSentEventCount()); |
| - EXPECT_EQ(1U, GetAndResetAckedEventCount()); |
| - EXPECT_EQ(1U, uncancelable_touch_moves_pending_ack_count()); |
| - |
| - // Send pending_async_touch_move_ when we receive an ack back from render, |
| - // but we will not send an ack for pending_async_touch_move_ becasue it is |
| - // been acked before. |
| - SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
| - EXPECT_FALSE(HasPendingAsyncTouchMove()); |
| - EXPECT_EQ(0U, queued_event_count()); |
| - EXPECT_EQ(1U, GetAndResetSentEventCount()); |
| - EXPECT_EQ(0U, GetAndResetAckedEventCount()); |
| - EXPECT_EQ(1U, uncancelable_touch_moves_pending_ack_count()); |
| -} |
| - |
| -// Ensure that even when we receive the ack from render, we still need to wait |
| -// for the interval expires to send the next async touchmove once the scroll |
| -// starts. |
| -TEST_F(TouchEventQueueTest, SendNextAsyncTouchMoveAfterAckAndTimeExpire) { |
| - // Process a TouchStart |
| - PressTouchPoint(0, 1); |
| - EXPECT_EQ(1U, GetAndResetSentEventCount()); |
| - SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
| - EXPECT_EQ(1U, GetAndResetAckedEventCount()); |
| - |
| - // Initiate async touchmove dispatch after the start of a scroll sequence. |
| - MoveTouchPoint(0, 0, 5); |
| - WebGestureEvent followup_scroll(WebInputEvent::GestureScrollBegin, |
| - WebInputEvent::NoModifiers, |
| - WebInputEvent::TimeStampForTesting); |
| - SetFollowupEvent(followup_scroll); |
| - SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
| - EXPECT_EQ(1U, GetAndResetSentEventCount()); |
| - EXPECT_EQ(1U, GetAndResetAckedEventCount()); |
| - |
| - MoveTouchPoint(0, 0, 10); |
| - followup_scroll.setType(WebInputEvent::GestureScrollUpdate); |
| - SetFollowupEvent(followup_scroll); |
| - SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
| - EXPECT_FALSE(HasPendingAsyncTouchMove()); |
| - EXPECT_EQ(1U, GetAndResetSentEventCount()); |
| - EXPECT_EQ(1U, GetAndResetAckedEventCount()); |
| - |
| - // Dispatch the touch move event when sufficient time has passed. |
| - AdvanceTouchTime(kMinSecondsBetweenThrottledTouchmoves + 0.1); |
| - MoveTouchPoint(0, 0, 40); |
| - EXPECT_FALSE(HasPendingAsyncTouchMove()); |
| - EXPECT_NE(WebInputEvent::Blocking, sent_event().dispatchType); |
| - // When we dispatch an async touchmove, we do not put it back to the queue |
| - // any more and we will ack to client right away. |
| - EXPECT_EQ(0U, queued_event_count()); |
| - EXPECT_EQ(1U, GetAndResetSentEventCount()); |
| - EXPECT_EQ(1U, GetAndResetAckedEventCount()); |
| - EXPECT_EQ(1U, uncancelable_touch_moves_pending_ack_count()); |
| - |
| - // We receive an ack back from render but the time interval is not expired, |
| - // so we do not dispatch the touch move event. |
| - SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
| - EXPECT_EQ(0U, uncancelable_touch_moves_pending_ack_count()); |
| - MoveTouchPoint(0, 0, 50); |
| - EXPECT_TRUE(HasPendingAsyncTouchMove()); |
| - EXPECT_EQ(0U, queued_event_count()); |
| - EXPECT_EQ(0U, GetAndResetSentEventCount()); |
| - EXPECT_EQ(1U, GetAndResetAckedEventCount()); |
| - |
| - // Dispatch the touch move when sufficient time has passed. |
| - AdvanceTouchTime(kMinSecondsBetweenThrottledTouchmoves + 0.1); |
| - MoveTouchPoint(0, 0, 50); |
| - EXPECT_FALSE(HasPendingAsyncTouchMove()); |
| - EXPECT_EQ(WebInputEvent::TouchMove, sent_event().type()); |
| - EXPECT_NE(WebInputEvent::Blocking, sent_event().dispatchType); |
| - EXPECT_EQ(0U, queued_event_count()); |
| - EXPECT_EQ(1U, GetAndResetSentEventCount()); |
| - EXPECT_EQ(1U, GetAndResetAckedEventCount()); |
| - EXPECT_EQ(1U, uncancelable_touch_moves_pending_ack_count()); |
| -} |
| - |
| -TEST_F(TouchEventQueueTest, AsyncTouchFlushedByNonTouchMove) { |
| - // Process a TouchStart |
| - PressTouchPoint(0, 1); |
| - EXPECT_EQ(1U, GetAndResetSentEventCount()); |
| - SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
| - EXPECT_EQ(1U, GetAndResetAckedEventCount()); |
| - |
| - // Initiate async touchmove dispatch after the start of a scroll sequence. |
| - MoveTouchPoint(0, 0, 5); |
| - WebGestureEvent followup_scroll(WebInputEvent::GestureScrollBegin, |
| - WebInputEvent::NoModifiers, |
| - WebInputEvent::TimeStampForTesting); |
| - SetFollowupEvent(followup_scroll); |
| - SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
| - EXPECT_EQ(1U, GetAndResetSentEventCount()); |
| - EXPECT_EQ(1U, GetAndResetAckedEventCount()); |
| - |
| - MoveTouchPoint(0, 0, 10); |
| - followup_scroll.setType(WebInputEvent::GestureScrollUpdate); |
| - SetFollowupEvent(followup_scroll); |
| - SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
| - EXPECT_FALSE(HasPendingAsyncTouchMove()); |
| - EXPECT_EQ(1U, GetAndResetSentEventCount()); |
| - EXPECT_EQ(1U, GetAndResetAckedEventCount()); |
| - |
| - // Dispatch the touch move when sufficient time has passed. |
| - AdvanceTouchTime(kMinSecondsBetweenThrottledTouchmoves + 0.1); |
| - MoveTouchPoint(0, 0, 40); |
| - EXPECT_FALSE(HasPendingAsyncTouchMove()); |
| - EXPECT_NE(WebInputEvent::Blocking, sent_event().dispatchType); |
| - // When we dispatch an async touchmove, we do not put it back to the queue |
| - // any more and we will ack to client right away. |
| - EXPECT_EQ(0U, queued_event_count()); |
| - EXPECT_EQ(1U, GetAndResetSentEventCount()); |
| - EXPECT_EQ(1U, GetAndResetAckedEventCount()); |
| - EXPECT_EQ(1U, uncancelable_touch_moves_pending_ack_count()); |
| - |
| - for (int i = 0; i < 3; ++i) { |
| - // We throttle the touchmoves, put it in the pending_async_touch_move_, |
| - // do not dispatch it. |
| - MoveTouchPoint(0, 10 + 10 * i, 10 + 10 * i); |
| - EXPECT_TRUE(HasPendingAsyncTouchMove()); |
| - EXPECT_EQ(0U, queued_event_count()); |
| - EXPECT_EQ(0U, GetAndResetSentEventCount()); |
| - EXPECT_EQ(1U, GetAndResetAckedEventCount()); |
| - EXPECT_EQ(static_cast<size_t>(i + 1), |
| - uncancelable_touch_moves_pending_ack_count()); |
| - |
| - // Send touchstart will flush pending_async_touch_move_, and increase the |
| - // count. In this case, we will first dispatch an async touchmove and |
| - // then a touchstart. For the async touchmove, we will not send ack again. |
| - PressTouchPoint(30, 30); |
| - EXPECT_FALSE(HasPendingAsyncTouchMove()); |
| - EXPECT_EQ(2U, all_sent_events().size()); |
| - EXPECT_EQ(WebInputEvent::TouchMove, all_sent_events()[0].type()); |
| - EXPECT_NE(WebInputEvent::Blocking, all_sent_events()[0].dispatchType); |
| - EXPECT_EQ(10 + 10 * i, all_sent_events()[0].touches[0].position.x); |
| - EXPECT_EQ(10 + 10 * i, all_sent_events()[0].touches[0].position.y); |
| - EXPECT_EQ(static_cast<size_t>(i + 2), |
| - uncancelable_touch_moves_pending_ack_count()); |
| - EXPECT_EQ(WebInputEvent::TouchStart, all_sent_events()[1].type()); |
| - EXPECT_EQ(WebInputEvent::Blocking, all_sent_events()[1].dispatchType); |
| - EXPECT_EQ(2U, GetAndResetSentEventCount()); |
| - EXPECT_EQ(0U, GetAndResetAckedEventCount()); |
| - |
| - SendTouchEventAckWithID(INPUT_EVENT_ACK_STATE_NOT_CONSUMED, |
| - GetUniqueTouchEventID()); |
| - EXPECT_EQ(0U, queued_event_count()); |
| - EXPECT_FALSE(HasPendingAsyncTouchMove()); |
| - EXPECT_EQ(0U, GetAndResetSentEventCount()); |
| - EXPECT_EQ(1U, GetAndResetAckedEventCount()); |
| - } |
| - |
| - EXPECT_EQ(4U, uncancelable_touch_moves_pending_ack_count()); |
| - |
| - // When we receive an ack from render we decrease the count. |
| - SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
| - EXPECT_EQ(3U, uncancelable_touch_moves_pending_ack_count()); |
| - EXPECT_EQ(0U, queued_event_count()); |
| - EXPECT_FALSE(HasPendingAsyncTouchMove()); |
| - |
| - // Do not dispatch the next uncancelable touchmove when we have not received |
| - // all the acks back from render. |
| - AdvanceTouchTime(kMinSecondsBetweenThrottledTouchmoves + 0.1); |
| - MoveTouchPoint(0, 20, 30); |
| - EXPECT_TRUE(HasPendingAsyncTouchMove()); |
| - EXPECT_EQ(0U, queued_event_count()); |
| - EXPECT_EQ(0U, GetAndResetSentEventCount()); |
| - EXPECT_EQ(1U, GetAndResetAckedEventCount()); |
| - EXPECT_EQ(3U, uncancelable_touch_moves_pending_ack_count()); |
| - |
| - // Once we receive the ack from render, we do not dispatch the |
| - // pending_async_touchmove_ until the count is 0. |
| - SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
| - EXPECT_EQ(2U, uncancelable_touch_moves_pending_ack_count()); |
| - EXPECT_EQ(0U, queued_event_count()); |
| - EXPECT_TRUE(HasPendingAsyncTouchMove()); |
| - |
| - SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
| - |
| - // When we receive this ack from render, and the count is 0, so we can |
| - // dispatch the pending_async_touchmove_. |
| - SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
| - EXPECT_EQ(1U, uncancelable_touch_moves_pending_ack_count()); |
| - EXPECT_FALSE(HasPendingAsyncTouchMove()); |
| - EXPECT_EQ(0U, queued_event_count()); |
| - EXPECT_EQ(WebInputEvent::TouchMove, sent_event().type()); |
| - EXPECT_NE(WebInputEvent::Blocking, sent_event().dispatchType); |
| - EXPECT_EQ(1U, GetAndResetSentEventCount()); |
| - EXPECT_EQ(0U, GetAndResetAckedEventCount()); |
| -} |
| - |
| -// Ensure that even when we receive the ack from render, we still need to wait |
| -// for the interval expires to send the next async touchmove once the scroll |
| -// starts. |
| -TEST_F(TouchEventQueueTest, DoNotIncreaseIfClientConsumeAsyncTouchMove) { |
| - // Process a TouchStart |
| - PressTouchPoint(0, 1); |
| - EXPECT_EQ(1U, GetAndResetSentEventCount()); |
| - SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
| - EXPECT_EQ(1U, GetAndResetAckedEventCount()); |
| - |
| - // Initiate async touchmove dispatch after the start of a scroll sequence. |
| - MoveTouchPoint(0, 0, 5); |
| - WebGestureEvent followup_scroll(WebInputEvent::GestureScrollBegin, |
| - WebInputEvent::NoModifiers, |
| - WebInputEvent::TimeStampForTesting); |
| - SetFollowupEvent(followup_scroll); |
| - SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
| - EXPECT_EQ(1U, GetAndResetSentEventCount()); |
| - EXPECT_EQ(1U, GetAndResetAckedEventCount()); |
| - |
| - MoveTouchPoint(0, 0, 10); |
| - followup_scroll.setType(WebInputEvent::GestureScrollUpdate); |
| - SetFollowupEvent(followup_scroll); |
| - SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
| - EXPECT_FALSE(HasPendingAsyncTouchMove()); |
| - EXPECT_EQ(1U, GetAndResetSentEventCount()); |
| - EXPECT_EQ(1U, GetAndResetAckedEventCount()); |
| - |
| - // Dispatch the touch move event when sufficient time has passed. |
| - AdvanceTouchTime(kMinSecondsBetweenThrottledTouchmoves + 0.1); |
| - MoveTouchPoint(0, 0, 40); |
| - EXPECT_FALSE(HasPendingAsyncTouchMove()); |
| - EXPECT_NE(WebInputEvent::Blocking, sent_event().dispatchType); |
| - // When we dispatch an async touchmove, we do not put it back to the queue |
| - // any more and we will ack to client right away. |
| - EXPECT_EQ(0U, queued_event_count()); |
| - EXPECT_EQ(1U, GetAndResetSentEventCount()); |
| - EXPECT_EQ(1U, GetAndResetAckedEventCount()); |
| - EXPECT_EQ(1U, uncancelable_touch_moves_pending_ack_count()); |
| - |
| - // We receive an ack back from render but the time interval is not expired, |
| - // so we do not dispatch the touch move event. |
| - SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
| - EXPECT_EQ(0U, uncancelable_touch_moves_pending_ack_count()); |
| - MoveTouchPoint(0, 0, 50); |
| - EXPECT_TRUE(HasPendingAsyncTouchMove()); |
| - EXPECT_EQ(0U, queued_event_count()); |
| - EXPECT_EQ(0U, GetAndResetSentEventCount()); |
| - EXPECT_EQ(1U, GetAndResetAckedEventCount()); |
| - |
| - // Dispatch the touch move when sufficient time has passed. Becasue the event |
| - // is consumed by client already, we would not increase the count and ack to |
| - // client again. |
| - AdvanceTouchTime(kMinSecondsBetweenThrottledTouchmoves + 0.1); |
| - SetSyncAckResult(INPUT_EVENT_ACK_STATE_CONSUMED); |
| - MoveTouchPoint(0, 0, 50); |
| - EXPECT_FALSE(HasPendingAsyncTouchMove()); |
| - EXPECT_EQ(WebInputEvent::TouchMove, sent_event().type()); |
| - EXPECT_NE(WebInputEvent::Blocking, sent_event().dispatchType); |
| - EXPECT_EQ(0U, queued_event_count()); |
| - EXPECT_EQ(1U, GetAndResetSentEventCount()); |
| - EXPECT_EQ(1U, GetAndResetAckedEventCount()); |
| - EXPECT_EQ(0U, uncancelable_touch_moves_pending_ack_count()); |
| -} |
| - |
| -TEST_F(TouchEventQueueTest, TouchAbsorptionWithConsumedFirstMove) { |
| - // Queue a TouchStart. |
| - PressTouchPoint(0, 1); |
| - SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
| - EXPECT_EQ(0U, queued_event_count()); |
| - EXPECT_EQ(1U, GetAndResetAckedEventCount()); |
| - |
| - MoveTouchPoint(0, 20, 5); |
| - SendGestureEvent(blink::WebInputEvent::GestureScrollBegin); |
| - SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED); |
| - EXPECT_EQ(0U, queued_event_count()); |
| - EXPECT_EQ(2U, GetAndResetSentEventCount()); |
| - |
| - // Even if the first touchmove event was consumed, subsequent unconsumed |
| - // touchmove events should trigger scrolling. |
| - MoveTouchPoint(0, 60, 5); |
| - SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED); |
| - EXPECT_EQ(0U, queued_event_count()); |
| - EXPECT_EQ(WebInputEvent::Blocking, sent_event().dispatchType); |
| - EXPECT_EQ(1U, GetAndResetSentEventCount()); |
| - |
| - MoveTouchPoint(0, 20, 5); |
| - WebGestureEvent followup_scroll(WebInputEvent::GestureScrollUpdate, |
| - WebInputEvent::NoModifiers, |
| - WebInputEvent::TimeStampForTesting); |
| - SetFollowupEvent(followup_scroll); |
| - SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
| - SendGestureEventAck(WebInputEvent::GestureScrollUpdate, |
| - INPUT_EVENT_ACK_STATE_CONSUMED); |
| - EXPECT_EQ(0U, queued_event_count()); |
| - EXPECT_EQ(WebInputEvent::Blocking, sent_event().dispatchType); |
| - EXPECT_EQ(1U, GetAndResetSentEventCount()); |
| - |
| - // Touch move event is throttled. |
| - MoveTouchPoint(0, 60, 5); |
| - EXPECT_EQ(0U, queued_event_count()); |
| - EXPECT_EQ(0U, GetAndResetSentEventCount()); |
| -} |
| - |
| -TEST_F(TouchEventQueueTest, TouchStartCancelableDuringScroll) { |
| - // Queue a touchstart and touchmove that go unconsumed, transitioning to an |
| - // active scroll sequence. |
| - PressTouchPoint(0, 1); |
| - SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
| - EXPECT_EQ(WebInputEvent::Blocking, sent_event().dispatchType); |
| - ASSERT_EQ(1U, GetAndResetSentEventCount()); |
| - |
| - MoveTouchPoint(0, 20, 5); |
| - EXPECT_EQ(WebInputEvent::Blocking, sent_event().dispatchType); |
| - SendGestureEvent(blink::WebInputEvent::GestureScrollBegin); |
| - SendGestureEvent(blink::WebInputEvent::GestureScrollUpdate); |
| - SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
| - EXPECT_EQ(WebInputEvent::Blocking, sent_event().dispatchType); |
| - ASSERT_EQ(1U, GetAndResetSentEventCount()); |
| - |
| - // Even though scrolling has begun, touchstart events should be cancelable, |
| - // allowing, for example, customized pinch processing. |
| - PressTouchPoint(10, 11); |
| - SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED); |
| - EXPECT_EQ(WebInputEvent::Blocking, sent_event().dispatchType); |
| - ASSERT_EQ(1U, GetAndResetSentEventCount()); |
| - |
| - // As the touch start was consumed, touchmoves should no longer be throttled. |
| - MoveTouchPoint(1, 11, 11); |
| - SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED); |
| - EXPECT_EQ(WebInputEvent::Blocking, sent_event().dispatchType); |
| - ASSERT_EQ(1U, GetAndResetSentEventCount()); |
| + // As the touch start was consumed, touchmoves should no longer be throttled. |
| + MoveTouchPoint(1, 11, 11); |
| + SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED); |
| + EXPECT_EQ(WebInputEvent::Blocking, sent_event().dispatchType); |
| + ASSERT_EQ(1U, GetAndResetSentEventCount()); |
| // With throttling disabled, touchend and touchmove events should also be |
| // cancelable. |
| @@ -2372,7 +1481,7 @@ TEST_F(TouchEventQueueTest, TouchStartCancelableDuringScroll) { |
| ASSERT_EQ(1U, GetAndResetSentEventCount()); |
| } |
| -TEST_F(TouchEventQueueTest, UnseenTouchPointerIdsNotForwarded) { |
| +TEST_F(PassthroughTouchEventQueueTest, UnseenTouchPointerIdsNotForwarded) { |
| SyntheticWebTouchEvent event; |
| event.PressPoint(0, 0); |
| SendTouchEvent(event); |
| @@ -2411,13 +1520,13 @@ TEST_F(TouchEventQueueTest, UnseenTouchPointerIdsNotForwarded) { |
| } |
| // Tests that touch points states are correct in TouchMove events. |
| -TEST_F(TouchEventQueueTest, PointerStatesInTouchMove) { |
| +TEST_F(PassthroughTouchEventQueueTest, PointerStatesInTouchMove) { |
| PressTouchPoint(1, 1); |
| PressTouchPoint(2, 2); |
| PressTouchPoint(3, 3); |
| + EXPECT_EQ(3U, queued_event_count()); |
| + EXPECT_EQ(3U, GetAndResetSentEventCount()); |
| PressTouchPoint(4, 4); |
| - EXPECT_EQ(4U, queued_event_count()); |
| - EXPECT_EQ(1U, GetAndResetSentEventCount()); |
| // Receive ACK for the first three touch-events. |
| SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED); |
| @@ -2468,7 +1577,8 @@ TEST_F(TouchEventQueueTest, PointerStatesInTouchMove) { |
| // Tests that touch point state is correct in TouchMove events |
| // when point properties other than position changed. |
| -TEST_F(TouchEventQueueTest, PointerStatesWhenOtherThanPositionChanged) { |
| +TEST_F(PassthroughTouchEventQueueTest, |
| + PointerStatesWhenOtherThanPositionChanged) { |
| PressTouchPoint(1, 1); |
| SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED); |
| @@ -2509,7 +1619,7 @@ TEST_F(TouchEventQueueTest, PointerStatesWhenOtherThanPositionChanged) { |
| } |
| // Tests that TouchMoves are filtered when none of the points are changed. |
| -TEST_F(TouchEventQueueTest, FilterTouchMovesWhenNoPointerChanged) { |
| +TEST_F(PassthroughTouchEventQueueTest, FilterTouchMovesWhenNoPointerChanged) { |
| PressTouchPoint(1, 1); |
| PressTouchPoint(2, 2); |
| SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED); |
| @@ -2534,18 +1644,20 @@ TEST_F(TouchEventQueueTest, FilterTouchMovesWhenNoPointerChanged) { |
| MoveTouchPoint(0, 10, 10); |
| ChangeTouchPointRadius(1, 1, 1); |
| MoveTouchPoint(1, 2, 2); |
| - EXPECT_EQ(2U, queued_event_count()); |
| + EXPECT_EQ(1U, queued_event_count()); |
| EXPECT_EQ(0U, GetAndResetSentEventCount()); |
| + // The TouchMove but should be filtered |
| + // when none of the touch points have changed. |
| + EXPECT_EQ(3U, GetAndResetAckedEventCount()); |
| + EXPECT_EQ(INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS, acked_event_state()); |
| // Receive an ACK for 1st TouchMove. |
| SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED); |
| - // Tries to forward TouchMove but should be filtered |
| - // when none of the touch points have changed. |
| EXPECT_EQ(0U, queued_event_count()); |
| EXPECT_EQ(0U, GetAndResetSentEventCount()); |
| - EXPECT_EQ(4U, GetAndResetAckedEventCount()); |
| - EXPECT_EQ(INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS, acked_event_state()); |
| + EXPECT_EQ(1U, GetAndResetAckedEventCount()); |
| + EXPECT_EQ(INPUT_EVENT_ACK_STATE_CONSUMED, acked_event_state()); |
| // Move 2nd touch point. |
| MoveTouchPoint(1, 3, 3); |
| @@ -2561,18 +1673,20 @@ TEST_F(TouchEventQueueTest, FilterTouchMovesWhenNoPointerChanged) { |
| EXPECT_EQ(1U, GetAndResetAckedEventCount()); |
| } |
| -// Tests that touch-scroll-notification is not pushed into an empty queue. |
| -TEST_F(TouchEventQueueTest, TouchScrollNotificationOrder_EmptyQueue) { |
| +// Tests that touch-scroll-notification is queued normally. |
| +TEST_F(PassthroughTouchEventQueueTest, |
| + TouchScrollNotificationOrder_EmptyQueue) { |
| PrependTouchScrollNotification(); |
| EXPECT_EQ(0U, GetAndResetAckedEventCount()); |
| - EXPECT_EQ(0U, queued_event_count()); |
| - EXPECT_EQ(0U, GetAndResetSentEventCount()); |
| + EXPECT_EQ(1U, queued_event_count()); |
| + EXPECT_EQ(1U, GetAndResetSentEventCount()); |
| } |
| -// Tests touch-scroll-notification firing order when the event is placed at the |
| -// end of touch queue because of a pending ack for the head of the queue. |
| -TEST_F(TouchEventQueueTest, TouchScrollNotificationOrder_EndOfQueue) { |
| +// Tests touch-scroll-notification firing is appended to the tail of sent |
| +// events since all events are sent right away. |
| +TEST_F(PassthroughTouchEventQueueTest, |
| + TouchScrollNotificationOrder_EndOfQueue) { |
| PressTouchPoint(1, 1); |
| EXPECT_EQ(0U, GetAndResetAckedEventCount()); |
| @@ -2584,77 +1698,22 @@ TEST_F(TouchEventQueueTest, TouchScrollNotificationOrder_EndOfQueue) { |
| EXPECT_EQ(0U, GetAndResetAckedEventCount()); |
| EXPECT_EQ(2U, queued_event_count()); |
| - // Receive an ACK for the touchstart. |
| + // Send ACKs |
|
tdresser
2017/02/23 15:10:45
Missing .
dtapuska
2017/02/23 16:52:12
Done.
|
| SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED); |
| - |
| - EXPECT_EQ(1U, GetAndResetAckedEventCount()); |
| - EXPECT_EQ(WebInputEvent::TouchStart, acked_event().type()); |
| - EXPECT_EQ(1U, queued_event_count()); |
| - |
| - // Receive an ACK for the touch-scroll-notification. |
| SendTouchEventAck(INPUT_EVENT_ACK_STATE_IGNORED); |
| - EXPECT_EQ(0U, GetAndResetAckedEventCount()); |
| - EXPECT_EQ(0U, queued_event_count()); |
| - |
| - EXPECT_EQ(WebInputEvent::TouchStart, all_sent_events()[0].type()); |
| - EXPECT_EQ(WebInputEvent::TouchScrollStarted, all_sent_events()[1].type()); |
| - EXPECT_EQ(2U, GetAndResetSentEventCount()); |
| -} |
| - |
| -// Tests touch-scroll-notification firing order when the event is placed in the |
| -// 2nd position in the touch queue between two events. |
| -TEST_F(TouchEventQueueTest, TouchScrollNotificationOrder_SecondPosition) { |
| - PressTouchPoint(1, 1); |
| - MoveTouchPoint(0, 5, 5); |
| - ReleaseTouchPoint(0); |
| - |
| - EXPECT_EQ(0U, GetAndResetAckedEventCount()); |
| - EXPECT_EQ(3U, queued_event_count()); |
| - |
| - // Send the touch-scroll-notification when 3 events are in the queue. |
| - PrependTouchScrollNotification(); |
| - |
| - EXPECT_EQ(0U, GetAndResetAckedEventCount()); |
| - EXPECT_EQ(4U, queued_event_count()); |
| - |
| - // Receive an ACK for the touchstart. |
| - SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED); |
| - |
| - EXPECT_EQ(1U, GetAndResetAckedEventCount()); |
| - EXPECT_EQ(WebInputEvent::TouchStart, acked_event().type()); |
| - EXPECT_EQ(3U, queued_event_count()); |
| - |
| - // Receive an ACK for the touch-scroll-notification. |
| - SendTouchEventAck(INPUT_EVENT_ACK_STATE_IGNORED); |
| - |
| - EXPECT_EQ(0U, GetAndResetAckedEventCount()); |
| - EXPECT_EQ(2U, queued_event_count()); |
| - |
| - // Receive an ACK for the touchmove. |
| - SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED); |
| - |
| + // touch-scroll-start Ack is not reported to client. |
|
tdresser
2017/02/23 15:10:45
Capitalize.
dtapuska
2017/02/23 16:52:12
Done.
|
| EXPECT_EQ(1U, GetAndResetAckedEventCount()); |
| - EXPECT_EQ(WebInputEvent::TouchMove, acked_event().type()); |
| - EXPECT_EQ(1U, queued_event_count()); |
| - |
| - // Receive an ACK for the touchend. |
| - SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED); |
| - |
| - EXPECT_EQ(1U, GetAndResetAckedEventCount()); |
| - EXPECT_EQ(WebInputEvent::TouchEnd, acked_event().type()); |
| EXPECT_EQ(0U, queued_event_count()); |
| EXPECT_EQ(WebInputEvent::TouchStart, all_sent_events()[0].type()); |
| EXPECT_EQ(WebInputEvent::TouchScrollStarted, all_sent_events()[1].type()); |
| - EXPECT_EQ(WebInputEvent::TouchMove, all_sent_events()[2].type()); |
| - EXPECT_EQ(WebInputEvent::TouchEnd, all_sent_events()[3].type()); |
| - EXPECT_EQ(4U, GetAndResetSentEventCount()); |
| + EXPECT_EQ(2U, GetAndResetSentEventCount()); |
| } |
| // Tests that if touchStartOrFirstTouchMove is correctly set up for touch |
| // events. |
| -TEST_F(TouchEventQueueTest, TouchStartOrFirstTouchMove) { |
| +TEST_F(PassthroughTouchEventQueueTest, TouchStartOrFirstTouchMove) { |
| PressTouchPoint(1, 1); |
| SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED); |
| EXPECT_EQ(WebInputEvent::TouchStart, sent_event().type()); |
