1 // Copyright 2017 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include "content/browser/renderer_host/input/passthrough_touch_event_queue.h"
6
7 #include <stddef.h>
8
9 #include <memory>
10 #include <utility>
11
12 #include "base/check_op.h"
13 #include "base/containers/circular_deque.h"
14 #include "base/location.h"
15 #include "base/run_loop.h"
16 #include "base/single_thread_task_runner.h"
17 #include "base/stl_util.h"
18 #include "base/test/scoped_feature_list.h"
19 #include "base/test/task_environment.h"
20 #include "base/threading/thread_task_runner_handle.h"
21 #include "content/browser/renderer_host/input/timeout_monitor.h"
22 #include "content/common/input/web_touch_event_traits.h"
23 #include "content/public/common/content_features.h"
24 #include "testing/gtest/include/gtest/gtest.h"
25 #include "third_party/blink/public/common/input/synthetic_web_input_event_builders.h"
26 #include "third_party/blink/public/common/input/web_input_event.h"
27 #include "ui/events/base_event_utils.h"
28
29 using blink::SyntheticWebTouchEvent;
30 using blink::WebGestureEvent;
31 using blink::WebInputEvent;
32 using blink::WebTouchEvent;
33 using blink::WebTouchPoint;
34
35 namespace content {
36 namespace {
37
38 const double kMinSecondsBetweenThrottledTouchmoves = 0.2;
39 const float kSlopLengthDips = 10;
40 const float kHalfSlopLengthDips = kSlopLengthDips / 2;
41
DefaultTouchTimeoutDelay()42 base::TimeDelta DefaultTouchTimeoutDelay() {
43 return base::TimeDelta::FromMilliseconds(1);
44 }
45 } // namespace
46
47 class PassthroughTouchEventQueueTest : public testing::Test,
48 public PassthroughTouchEventQueueClient {
49 public:
PassthroughTouchEventQueueTest()50 PassthroughTouchEventQueueTest()
51 : task_environment_(
52 base::test::SingleThreadTaskEnvironment::MainThreadType::UI),
53 acked_event_count_(0),
54 last_acked_event_state_(blink::mojom::InputEventResultState::kUnknown),
55 slop_length_dips_(0) {}
56
~PassthroughTouchEventQueueTest()57 ~PassthroughTouchEventQueueTest() override {}
58
59 // testing::Test
SetUp()60 void SetUp() override {
61 ResetQueueWithConfig(PassthroughTouchEventQueue::Config());
62 sent_events_ids_.clear();
63 }
64
TearDown()65 void TearDown() override { queue_.reset(); }
66
67 // PassthroughTouchEventQueueClient
SendTouchEventImmediately(const TouchEventWithLatencyInfo & event)68 void SendTouchEventImmediately(
69 const TouchEventWithLatencyInfo& event) override {
70 sent_events_.push_back(event.event);
71 sent_events_ids_.push_back(event.event.unique_touch_event_id);
72 if (sync_ack_result_) {
73 auto sync_ack_result = std::move(sync_ack_result_);
74 SendTouchEventAckWithID(*sync_ack_result,
75 event.event.unique_touch_event_id);
76 }
77 }
78
OnTouchEventAck(const TouchEventWithLatencyInfo & event,blink::mojom::InputEventResultSource ack_source,blink::mojom::InputEventResultState ack_result)79 void OnTouchEventAck(
80 const TouchEventWithLatencyInfo& event,
81 blink::mojom::InputEventResultSource ack_source,
82 blink::mojom::InputEventResultState ack_result) override {
83 ++acked_event_count_;
84 if (followup_touch_event_) {
85 std::unique_ptr<WebTouchEvent> followup_touch_event =
86 std::move(followup_touch_event_);
87 SendTouchEvent(*followup_touch_event);
88 }
89 last_acked_event_ = event.event;
90 last_acked_event_state_ = ack_result;
91 }
92
OnFilteringTouchEvent(const blink::WebTouchEvent & touch_event)93 void OnFilteringTouchEvent(const blink::WebTouchEvent& touch_event) override {
94 }
95
FlushDeferredGestureQueue()96 void FlushDeferredGestureQueue() override {}
97
98 protected:
SetUpForTouchMoveSlopTesting(double slop_length_dips)99 void SetUpForTouchMoveSlopTesting(double slop_length_dips) {
100 slop_length_dips_ = slop_length_dips;
101 }
102
SetUpForTimeoutTesting(base::TimeDelta desktop_timeout_delay,base::TimeDelta mobile_timeout_delay)103 void SetUpForTimeoutTesting(base::TimeDelta desktop_timeout_delay,
104 base::TimeDelta mobile_timeout_delay) {
105 PassthroughTouchEventQueue::Config config;
106 config.desktop_touch_ack_timeout_delay = desktop_timeout_delay;
107 config.mobile_touch_ack_timeout_delay = mobile_timeout_delay;
108 config.touch_ack_timeout_supported = true;
109 ResetQueueWithConfig(config);
110 }
111
SetUpForTimeoutTesting()112 void SetUpForTimeoutTesting() {
113 SetUpForTimeoutTesting(DefaultTouchTimeoutDelay(),
114 DefaultTouchTimeoutDelay());
115 }
116
SetUpForSkipFilterTesting(const std::string & events_to_always_forward)117 void SetUpForSkipFilterTesting(const std::string& events_to_always_forward) {
118 base::test::ScopedFeatureList feature_list;
119 feature_list.InitAndEnableFeatureWithParameters(
120 blink::features::kSkipTouchEventFilter,
121 {{blink::features::kSkipTouchEventFilterTypeParamName,
122 events_to_always_forward}});
123 ResetQueueWithConfig(PassthroughTouchEventQueue::Config());
124 }
125
SendTouchEvent(WebTouchEvent event)126 void SendTouchEvent(WebTouchEvent event) {
127 if (slop_length_dips_) {
128 event.moved_beyond_slop_region = false;
129 if (WebTouchEventTraits::IsTouchSequenceStart(event))
130 anchor_ = event.touches[0].PositionInWidget();
131 if (event.GetType() == WebInputEvent::Type::kTouchMove) {
132 gfx::Vector2dF delta = anchor_ - event.touches[0].PositionInWidget();
133 if (delta.LengthSquared() > slop_length_dips_ * slop_length_dips_)
134 event.moved_beyond_slop_region = true;
135 }
136 } else {
137 event.moved_beyond_slop_region =
138 event.GetType() == WebInputEvent::Type::kTouchMove;
139 }
140 queue_->QueueEvent(TouchEventWithLatencyInfo(event, ui::LatencyInfo()));
141 }
142
SendTouchEventAck(blink::mojom::InputEventResultState ack_result)143 void SendTouchEventAck(blink::mojom::InputEventResultState ack_result) {
144 DCHECK(!sent_events_ids_.empty());
145 queue_->ProcessTouchAck(
146 blink::mojom::InputEventResultSource::kCompositorThread, ack_result,
147 ui::LatencyInfo(), sent_events_ids_.front(), true);
148 sent_events_ids_.pop_front();
149 }
150
SendTouchEventAckLast(blink::mojom::InputEventResultState ack_result)151 void SendTouchEventAckLast(blink::mojom::InputEventResultState ack_result) {
152 DCHECK(!sent_events_ids_.empty());
153 queue_->ProcessTouchAck(
154 blink::mojom::InputEventResultSource::kCompositorThread, ack_result,
155 ui::LatencyInfo(), sent_events_ids_.back(), true);
156 sent_events_ids_.pop_back();
157 }
158
SendTouchEventAckWithID(blink::mojom::InputEventResultState ack_result,int unique_event_id)159 void SendTouchEventAckWithID(blink::mojom::InputEventResultState ack_result,
160 int unique_event_id) {
161 queue_->ProcessTouchAck(
162 blink::mojom::InputEventResultSource::kCompositorThread, ack_result,
163 ui::LatencyInfo(), unique_event_id, true);
164 base::Erase(sent_events_ids_, unique_event_id);
165 }
166
SendGestureEventAck(WebInputEvent::Type type,blink::mojom::InputEventResultState ack_result)167 void SendGestureEventAck(WebInputEvent::Type type,
168 blink::mojom::InputEventResultState ack_result) {
169 GestureEventWithLatencyInfo event(type, blink::WebInputEvent::kNoModifiers,
170 ui::EventTimeForNow(), ui::LatencyInfo());
171 queue_->OnGestureEventAck(event, ack_result);
172 }
173
SetFollowupEvent(const WebTouchEvent & event)174 void SetFollowupEvent(const WebTouchEvent& event) {
175 followup_touch_event_.reset(new WebTouchEvent(event));
176 }
177
SetSyncAckResult(blink::mojom::InputEventResultState sync_ack_result)178 void SetSyncAckResult(blink::mojom::InputEventResultState sync_ack_result) {
179 sync_ack_result_.reset(
180 new blink::mojom::InputEventResultState(sync_ack_result));
181 }
182
PressTouchPoint(float x,float y)183 void PressTouchPoint(float x, float y) {
184 touch_event_.PressPoint(x, y, radius_x_, radius_y_);
185 SendTouchEvent();
186 }
187
MoveTouchPoint(int index,float x,float y)188 void MoveTouchPoint(int index, float x, float y) {
189 touch_event_.MovePoint(index, x, y, radius_x_, radius_y_);
190 SendTouchEvent();
191 }
192
MoveTouchPoints(int index0,float x0,float y0,int index1,float x1,float y1)193 void MoveTouchPoints(int index0,
194 float x0,
195 float y0,
196 int index1,
197 float x1,
198 float y1) {
199 touch_event_.MovePoint(index0, x0, y0);
200 touch_event_.MovePoint(index1, x1, y1);
201 SendTouchEvent();
202 }
203
ChangeTouchPointRadius(int index,float radius_x,float radius_y)204 void ChangeTouchPointRadius(int index, float radius_x, float radius_y) {
205 CHECK_GE(index, 0);
206 CHECK_LT(index, touch_event_.kTouchesLengthCap);
207 WebTouchPoint& point = touch_event_.touches[index];
208 point.radius_x = radius_x;
209 point.radius_y = radius_y;
210 touch_event_.touches[index].state = WebTouchPoint::State::kStateMoved;
211 touch_event_.moved_beyond_slop_region = true;
212 WebTouchEventTraits::ResetType(WebInputEvent::Type::kTouchMove,
213 touch_event_.TimeStamp(), &touch_event_);
214 SendTouchEvent();
215 }
216
ChangeTouchPointRotationAngle(int index,float rotation_angle)217 void ChangeTouchPointRotationAngle(int index, float rotation_angle) {
218 CHECK_GE(index, 0);
219 CHECK_LT(index, touch_event_.kTouchesLengthCap);
220 WebTouchPoint& point = touch_event_.touches[index];
221 point.rotation_angle = rotation_angle;
222 touch_event_.touches[index].state = WebTouchPoint::State::kStateMoved;
223 touch_event_.moved_beyond_slop_region = true;
224 WebTouchEventTraits::ResetType(WebInputEvent::Type::kTouchMove,
225 touch_event_.TimeStamp(), &touch_event_);
226 SendTouchEvent();
227 }
228
ChangeTouchPointForce(int index,float force)229 void ChangeTouchPointForce(int index, float force) {
230 CHECK_GE(index, 0);
231 CHECK_LT(index, touch_event_.kTouchesLengthCap);
232 WebTouchPoint& point = touch_event_.touches[index];
233 point.force = force;
234 touch_event_.touches[index].state = WebTouchPoint::State::kStateMoved;
235 touch_event_.moved_beyond_slop_region = true;
236 WebTouchEventTraits::ResetType(WebInputEvent::Type::kTouchMove,
237 touch_event_.TimeStamp(), &touch_event_);
238 SendTouchEvent();
239 }
240
ReleaseTouchPoint(int index)241 void ReleaseTouchPoint(int index) {
242 touch_event_.ReleasePoint(index);
243 SendTouchEvent();
244 }
245
CancelTouchPoint(int index)246 void CancelTouchPoint(int index) {
247 touch_event_.CancelPoint(index);
248 SendTouchEvent();
249 }
250
PrependTouchScrollNotification()251 void PrependTouchScrollNotification() {
252 queue_->PrependTouchScrollNotification();
253 }
254
AdvanceTouchTime(double seconds)255 void AdvanceTouchTime(double seconds) {
256 touch_event_.SetTimeStamp(touch_event_.TimeStamp() +
257 base::TimeDelta::FromSecondsD(seconds));
258 }
259
GetAndResetAckedEventCount()260 size_t GetAndResetAckedEventCount() {
261 size_t count = acked_event_count_;
262 acked_event_count_ = 0;
263 return count;
264 }
265
GetAndResetSentEventCount()266 size_t GetAndResetSentEventCount() {
267 size_t count = sent_events_.size();
268 sent_events_.clear();
269 return count;
270 }
271
IsPendingAckTouchStart() const272 bool IsPendingAckTouchStart() const {
273 return queue_->IsPendingAckTouchStart();
274 }
275
OnHasTouchEventHandlers(bool has_handlers)276 void OnHasTouchEventHandlers(bool has_handlers) {
277 queue_->OnHasTouchEventHandlers(has_handlers);
278 }
279
SetAckTimeoutDisabled()280 void SetAckTimeoutDisabled() { queue_->SetAckTimeoutEnabled(false); }
281
SetIsMobileOptimizedSite(bool is_mobile_optimized)282 void SetIsMobileOptimizedSite(bool is_mobile_optimized) {
283 queue_->SetIsMobileOptimizedSite(is_mobile_optimized);
284 }
285
IsTimeoutRunning() const286 bool IsTimeoutRunning() const { return queue_->IsTimeoutRunningForTesting(); }
287
queued_event_count() const288 size_t queued_event_count() const { return queue_->SizeForTesting(); }
289
acked_event() const290 const WebTouchEvent& acked_event() const { return last_acked_event_; }
291
sent_event() const292 const WebTouchEvent& sent_event() const {
293 DCHECK(!sent_events_.empty());
294 return sent_events_.back();
295 }
296
all_sent_events() const297 const std::vector<WebTouchEvent>& all_sent_events() const {
298 return sent_events_;
299 }
300
acked_event_state() const301 blink::mojom::InputEventResultState acked_event_state() const {
302 return last_acked_event_state_;
303 }
304
RunTasksAndWait(base::TimeDelta delay)305 static void RunTasksAndWait(base::TimeDelta delay) {
306 base::RunLoop run_loop;
307 base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
308 FROM_HERE, run_loop.QuitClosure(), delay);
309 run_loop.Run();
310 }
311
FilterBeforeForwarding(const blink::WebTouchEvent & event)312 PassthroughTouchEventQueue::PreFilterResult FilterBeforeForwarding(
313 const blink::WebTouchEvent& event) {
314 return queue_->FilterBeforeForwarding(event);
315 }
316
GetUniqueTouchEventID()317 int GetUniqueTouchEventID() { return sent_events_ids_.back(); }
318
319 const float radius_x_ = 20.0f;
320 const float radius_y_ = 20.0f;
321
322 private:
SendTouchEvent()323 void SendTouchEvent() {
324 SendTouchEvent(touch_event_);
325 touch_event_.ResetPoints();
326 }
327
ResetQueueWithConfig(const PassthroughTouchEventQueue::Config & config)328 void ResetQueueWithConfig(const PassthroughTouchEventQueue::Config& config) {
329 queue_.reset(new PassthroughTouchEventQueue(this, config));
330 queue_->OnHasTouchEventHandlers(true);
331 }
332
333 base::test::SingleThreadTaskEnvironment task_environment_;
334 std::unique_ptr<PassthroughTouchEventQueue> queue_;
335 size_t acked_event_count_;
336 WebTouchEvent last_acked_event_;
337 std::vector<WebTouchEvent> sent_events_;
338 blink::mojom::InputEventResultState last_acked_event_state_;
339 SyntheticWebTouchEvent touch_event_;
340 std::unique_ptr<WebTouchEvent> followup_touch_event_;
341 std::unique_ptr<blink::mojom::InputEventResultState> sync_ack_result_;
342 double slop_length_dips_;
343 gfx::PointF anchor_;
344 base::circular_deque<int> sent_events_ids_;
345 };
346
347 // Tests that touch-events are queued properly.
TEST_F(PassthroughTouchEventQueueTest,Basic)348 TEST_F(PassthroughTouchEventQueueTest, Basic) {
349 PressTouchPoint(1, 1);
350 EXPECT_EQ(1U, queued_event_count());
351 EXPECT_EQ(1U, GetAndResetSentEventCount());
352
353 // The second touch should be sent right away even though
354 // we haven't received an ack for the touch start.
355 MoveTouchPoint(0, 5, 5);
356 EXPECT_EQ(2U, queued_event_count());
357 EXPECT_EQ(1U, GetAndResetSentEventCount());
358
359 // Receive an ACK for the first touch-event.
360 SendTouchEventAck(blink::mojom::InputEventResultState::kConsumed);
361 EXPECT_EQ(1U, queued_event_count());
362 EXPECT_EQ(0U, GetAndResetSentEventCount());
363 EXPECT_EQ(1U, GetAndResetAckedEventCount());
364 EXPECT_EQ(WebInputEvent::Type::kTouchStart, acked_event().GetType());
365 EXPECT_EQ(WebInputEvent::DispatchType::kBlocking,
366 acked_event().dispatch_type);
367
368 // Receive an ACK for the second touch-event.
369 SendTouchEventAck(blink::mojom::InputEventResultState::kConsumed);
370 EXPECT_EQ(0U, queued_event_count());
371 EXPECT_EQ(0U, GetAndResetSentEventCount());
372 EXPECT_EQ(1U, GetAndResetAckedEventCount());
373 EXPECT_EQ(WebInputEvent::Type::kTouchMove, acked_event().GetType());
374 EXPECT_EQ(WebInputEvent::DispatchType::kBlocking,
375 acked_event().dispatch_type);
376 }
377
378 // Tests that touch-events with multiple points are queued properly.
TEST_F(PassthroughTouchEventQueueTest,BasicMultiTouch)379 TEST_F(PassthroughTouchEventQueueTest, BasicMultiTouch) {
380 const size_t kPointerCount = 10;
381 for (float i = 0; i < kPointerCount; ++i)
382 PressTouchPoint(i, i);
383
384 EXPECT_EQ(kPointerCount, GetAndResetSentEventCount());
385 EXPECT_EQ(0U, GetAndResetAckedEventCount());
386 EXPECT_EQ(kPointerCount, queued_event_count());
387
388 for (int i = 0; i < static_cast<int>(kPointerCount); ++i)
389 MoveTouchPoint(i, 1.f + i, 2.f + i);
390
391 EXPECT_EQ(kPointerCount, GetAndResetSentEventCount());
392 EXPECT_EQ(0U, GetAndResetAckedEventCount());
393 // No coalescing happens in the queue since they are all sent immediately.
394 EXPECT_EQ(2 * kPointerCount, queued_event_count());
395
396 for (int i = 0; i < static_cast<int>(kPointerCount); ++i)
397 ReleaseTouchPoint(kPointerCount - 1 - i);
398
399 EXPECT_EQ(kPointerCount, GetAndResetSentEventCount());
400 EXPECT_EQ(0U, GetAndResetAckedEventCount());
401 EXPECT_EQ(kPointerCount * 3, queued_event_count());
402
403 // Ack all presses.
404 for (size_t i = 0; i < kPointerCount; ++i)
405 SendTouchEventAck(blink::mojom::InputEventResultState::kConsumed);
406
407 EXPECT_EQ(kPointerCount, GetAndResetAckedEventCount());
408 EXPECT_EQ(0U, GetAndResetSentEventCount());
409
410 // Ack the touch moves.
411 for (size_t i = 0; i < kPointerCount; ++i)
412 SendTouchEventAck(blink::mojom::InputEventResultState::kConsumed);
413 EXPECT_EQ(kPointerCount, GetAndResetAckedEventCount());
414 EXPECT_EQ(0U, GetAndResetSentEventCount());
415
416 // Ack all releases.
417 for (size_t i = 0; i < kPointerCount; ++i)
418 SendTouchEventAck(blink::mojom::InputEventResultState::kConsumed);
419
420 EXPECT_EQ(kPointerCount, GetAndResetAckedEventCount());
421 EXPECT_EQ(0U, GetAndResetSentEventCount());
422 }
423
424 // Tests that the touch-queue continues delivering events for an active touch
425 // sequence after all handlers are removed.
TEST_F(PassthroughTouchEventQueueTest,TouchesForwardedIfHandlerRemovedDuringSequence)426 TEST_F(PassthroughTouchEventQueueTest,
427 TouchesForwardedIfHandlerRemovedDuringSequence) {
428 OnHasTouchEventHandlers(true);
429 EXPECT_EQ(0U, queued_event_count());
430 EXPECT_EQ(0U, GetAndResetSentEventCount());
431
432 // Send a touch-press event.
433 PressTouchPoint(1, 1);
434 EXPECT_EQ(1U, GetAndResetSentEventCount());
435 EXPECT_EQ(1U, queued_event_count());
436
437 // Signal that all touch handlers have been removed.
438 OnHasTouchEventHandlers(false);
439 EXPECT_EQ(0U, GetAndResetAckedEventCount());
440 EXPECT_EQ(1U, queued_event_count());
441
442 // Process the ack for the sent touch, ensuring that it is honored (despite
443 // the touch handler having been removed).
444 SendTouchEventAck(blink::mojom::InputEventResultState::kConsumed);
445 EXPECT_EQ(1U, GetAndResetAckedEventCount());
446 EXPECT_EQ(0U, queued_event_count());
447 EXPECT_EQ(blink::mojom::InputEventResultState::kConsumed,
448 acked_event_state());
449
450 // Try forwarding a new pointer. It should be forwarded as usual.
451 PressTouchPoint(2, 2);
452 EXPECT_EQ(1U, GetAndResetSentEventCount());
453 SendTouchEventAck(blink::mojom::InputEventResultState::kNoConsumerExists);
454 EXPECT_EQ(1U, GetAndResetAckedEventCount());
455 EXPECT_EQ(0U, queued_event_count());
456
457 // Further events for any pointer should be forwarded, even for pointers that
458 // reported no consumer.
459 MoveTouchPoint(1, 3, 3);
460 ReleaseTouchPoint(1);
461 EXPECT_EQ(2U, GetAndResetSentEventCount());
462 EXPECT_EQ(0U, GetAndResetAckedEventCount());
463 SendTouchEventAck(blink::mojom::InputEventResultState::kNoConsumerExists);
464 EXPECT_EQ(0U, GetAndResetSentEventCount());
465 EXPECT_EQ(1U, GetAndResetAckedEventCount());
466 SendTouchEventAck(blink::mojom::InputEventResultState::kNoConsumerExists);
467 EXPECT_EQ(0U, GetAndResetSentEventCount());
468 EXPECT_EQ(1U, GetAndResetAckedEventCount());
469
470 // Events for the first pointer, that had a handler, should be forwarded.
471 MoveTouchPoint(0, 4, 4);
472 ReleaseTouchPoint(0);
473 EXPECT_EQ(2U, GetAndResetSentEventCount());
474 EXPECT_EQ(2U, queued_event_count());
475
476 SendTouchEventAck(blink::mojom::InputEventResultState::kConsumed);
477 EXPECT_EQ(1U, GetAndResetAckedEventCount());
478 EXPECT_EQ(0U, GetAndResetSentEventCount());
479 EXPECT_EQ(1U, queued_event_count());
480 EXPECT_EQ(blink::mojom::InputEventResultState::kConsumed,
481 acked_event_state());
482
483 SendTouchEventAck(blink::mojom::InputEventResultState::kConsumed);
484 EXPECT_EQ(1U, GetAndResetAckedEventCount());
485 EXPECT_EQ(0U, GetAndResetSentEventCount());
486 EXPECT_EQ(0U, queued_event_count());
487 EXPECT_EQ(blink::mojom::InputEventResultState::kConsumed,
488 acked_event_state());
489 }
490
491 // Tests that addition of a touch handler during a touch sequence will continue
492 // forwarding events.
TEST_F(PassthroughTouchEventQueueTest,ActiveSequenceStillForwardedWhenHandlersAdded)493 TEST_F(PassthroughTouchEventQueueTest,
494 ActiveSequenceStillForwardedWhenHandlersAdded) {
495 OnHasTouchEventHandlers(false);
496
497 // Send a touch-press event while there is no handler.
498 PressTouchPoint(1, 1);
499 EXPECT_EQ(0U, GetAndResetAckedEventCount());
500 EXPECT_EQ(1U, GetAndResetSentEventCount());
501 EXPECT_EQ(1U, queued_event_count());
502
503 OnHasTouchEventHandlers(true);
504
505 // The remaining touch sequence should be forwarded.
506 MoveTouchPoint(0, 5, 5);
507 ReleaseTouchPoint(0);
508 EXPECT_EQ(0U, GetAndResetAckedEventCount());
509 EXPECT_EQ(1U, GetAndResetSentEventCount());
510 EXPECT_EQ(3U, queued_event_count());
511
512 // A new touch sequence should continue forwarding.
513 PressTouchPoint(1, 1);
514 EXPECT_EQ(4U, queued_event_count());
515 EXPECT_EQ(1U, GetAndResetSentEventCount());
516 }
517
518 // Tests that removal of a touch handler during a touch sequence will not
519 // prevent the remaining sequence from being forwarded, even if another touch
520 // handler is registered during the same touch sequence.
TEST_F(PassthroughTouchEventQueueTest,ActiveSequenceDroppedWhenHandlersRemoved)521 TEST_F(PassthroughTouchEventQueueTest,
522 ActiveSequenceDroppedWhenHandlersRemoved) {
523 // Send a touch-press event.
524 PressTouchPoint(1, 1);
525 EXPECT_EQ(1U, GetAndResetSentEventCount());
526 EXPECT_EQ(1U, queued_event_count());
527
528 // Queue a touch-move event.
529 MoveTouchPoint(0, 5, 5);
530 EXPECT_EQ(2U, queued_event_count());
531 EXPECT_EQ(0U, GetAndResetAckedEventCount());
532 EXPECT_EQ(1U, GetAndResetSentEventCount());
533
534 // Unregister all touch handlers.
535 OnHasTouchEventHandlers(false);
536 EXPECT_EQ(0U, GetAndResetAckedEventCount());
537 EXPECT_EQ(2U, queued_event_count());
538
539 // Repeated registration/unregstration of handlers should have no effect.
540 OnHasTouchEventHandlers(true);
541 EXPECT_EQ(0U, GetAndResetAckedEventCount());
542 EXPECT_EQ(2U, queued_event_count());
543 OnHasTouchEventHandlers(false);
544 EXPECT_EQ(0U, GetAndResetAckedEventCount());
545 EXPECT_EQ(2U, queued_event_count());
546
547 // Clear the queue.
548 SendTouchEventAck(blink::mojom::InputEventResultState::kNoConsumerExists);
549 SendTouchEventAck(blink::mojom::InputEventResultState::kNoConsumerExists);
550 EXPECT_EQ(2U, GetAndResetAckedEventCount());
551 EXPECT_EQ(0U, queued_event_count());
552
553 // TouchMove events should be dropped while there is no touch handler.
554 MoveTouchPoint(0, 10, 10);
555 EXPECT_EQ(0U, queued_event_count());
556 EXPECT_EQ(1U, GetAndResetAckedEventCount());
557 EXPECT_EQ(0U, GetAndResetSentEventCount());
558
559 // Simulate touch handler registration in the middle of a touch sequence.
560 OnHasTouchEventHandlers(true);
561
562 // The touch end for the interrupted sequence should be sent.
563 ReleaseTouchPoint(0);
564 EXPECT_EQ(1U, queued_event_count());
565 EXPECT_EQ(0U, GetAndResetAckedEventCount());
566 EXPECT_EQ(1U, GetAndResetSentEventCount());
567
568 // A new touch sequence should be forwarded properly.
569 PressTouchPoint(1, 1);
570 EXPECT_EQ(2U, queued_event_count());
571 EXPECT_EQ(1U, GetAndResetSentEventCount());
572 }
573
574 // Tests that removal/addition of a touch handler without any intervening
575 // touch activity has no affect on touch forwarding.
TEST_F(PassthroughTouchEventQueueTest,ActiveSequenceUnaffectedByRepeatedHandlerRemovalAndAddition)576 TEST_F(PassthroughTouchEventQueueTest,
577 ActiveSequenceUnaffectedByRepeatedHandlerRemovalAndAddition) {
578 // Send a touch-press event.
579 PressTouchPoint(1, 1);
580 EXPECT_EQ(1U, GetAndResetSentEventCount());
581 EXPECT_EQ(1U, queued_event_count());
582
583 // Simulate the case where the touchstart handler removes itself, and adds a
584 // touchmove handler.
585 OnHasTouchEventHandlers(false);
586 OnHasTouchEventHandlers(true);
587
588 // Queue a touch-move event, should be sent right away.
589 MoveTouchPoint(0, 5, 5);
590 EXPECT_EQ(2U, queued_event_count());
591 EXPECT_EQ(0U, GetAndResetAckedEventCount());
592 EXPECT_EQ(1U, GetAndResetSentEventCount());
593
594 // The ack should trigger forwarding of the touchmove, as if no touch
595 // handler registration changes have occurred.
596 SendTouchEventAck(blink::mojom::InputEventResultState::kNotConsumed);
597 EXPECT_EQ(1U, GetAndResetAckedEventCount());
598 EXPECT_EQ(0U, GetAndResetSentEventCount());
599 EXPECT_EQ(1U, queued_event_count());
600 }
601
602 // Tests that the touch-event queue is robust to redundant acks.
TEST_F(PassthroughTouchEventQueueTest,SpuriousAcksIgnored)603 TEST_F(PassthroughTouchEventQueueTest, SpuriousAcksIgnored) {
604 // Trigger a spurious ack.
605 SendTouchEventAckWithID(blink::mojom::InputEventResultState::kConsumed, 0);
606 EXPECT_EQ(0U, GetAndResetAckedEventCount());
607
608 // Send and ack a touch press.
609 PressTouchPoint(1, 1);
610 EXPECT_EQ(1U, GetAndResetSentEventCount());
611 EXPECT_EQ(1U, queued_event_count());
612 SendTouchEventAck(blink::mojom::InputEventResultState::kConsumed);
613 EXPECT_EQ(1U, GetAndResetAckedEventCount());
614 EXPECT_EQ(0U, queued_event_count());
615
616 // Trigger a spurious ack.
617 SendTouchEventAckWithID(blink::mojom::InputEventResultState::kConsumed, 3);
618 EXPECT_EQ(0U, GetAndResetAckedEventCount());
619 }
620
621 // Tests that touch-move events are not sent to the renderer even if the
622 // preceding touch-press event did not have a consumer.
TEST_F(PassthroughTouchEventQueueTest,NoConsumer)623 TEST_F(PassthroughTouchEventQueueTest, NoConsumer) {
624 // The first touch-press should reach the renderer.
625 PressTouchPoint(1, 1);
626 EXPECT_EQ(1U, GetAndResetSentEventCount());
627
628 // The second touch should be sent too.
629 MoveTouchPoint(0, 5, 5);
630 EXPECT_EQ(1U, GetAndResetSentEventCount());
631 EXPECT_EQ(2U, queued_event_count());
632
633 // Receive an ACK for the first touch-event and the first touch-move
634 SendTouchEventAck(blink::mojom::InputEventResultState::kNoConsumerExists);
635 SendTouchEventAck(blink::mojom::InputEventResultState::kNoConsumerExists);
636 EXPECT_EQ(0U, queued_event_count());
637 EXPECT_EQ(2U, GetAndResetAckedEventCount());
638 EXPECT_EQ(0U, GetAndResetSentEventCount());
639
640 // Send a release event. This should reach the renderer.
641 ReleaseTouchPoint(0);
642 EXPECT_EQ(1U, GetAndResetSentEventCount());
643 EXPECT_EQ(WebInputEvent::Type::kTouchMove, acked_event().GetType());
644 EXPECT_EQ(0U, GetAndResetAckedEventCount());
645
646 // Send a press-event, followed by a move should be sent.
647 PressTouchPoint(10, 10);
648 MoveTouchPoint(0, 5, 5);
649
650 SendTouchEventAck(blink::mojom::InputEventResultState::kNoConsumerExists);
651 EXPECT_EQ(2U, GetAndResetSentEventCount());
652 EXPECT_EQ(1U, GetAndResetAckedEventCount());
653
654 MoveTouchPoint(0, 6, 5);
655 EXPECT_EQ(0U, GetAndResetSentEventCount());
656 EXPECT_EQ(0U, GetAndResetAckedEventCount());
657 EXPECT_EQ(3U, queued_event_count());
658 SendTouchEventAck(blink::mojom::InputEventResultState::kConsumed);
659 EXPECT_EQ(1U, GetAndResetAckedEventCount());
660 }
661
TEST_F(PassthroughTouchEventQueueTest,AckTouchEventInReverse)662 TEST_F(PassthroughTouchEventQueueTest, AckTouchEventInReverse) {
663 PressTouchPoint(1, 1);
664 MoveTouchPoint(0, 5, 5);
665 MoveTouchPoint(0, 15, 15);
666 ReleaseTouchPoint(0);
667
668 EXPECT_EQ(4U, GetAndResetSentEventCount());
669 EXPECT_EQ(4U, queued_event_count());
670
671 SendTouchEventAckLast(blink::mojom::InputEventResultState::kConsumed);
672 EXPECT_EQ(0U, GetAndResetAckedEventCount());
673 EXPECT_EQ(4U, queued_event_count());
674
675 SendTouchEventAck(blink::mojom::InputEventResultState::kConsumed);
676 EXPECT_EQ(WebInputEvent::Type::kTouchStart, acked_event().GetType());
677 EXPECT_EQ(1U, GetAndResetAckedEventCount());
678 EXPECT_EQ(3U, queued_event_count());
679
680 SendTouchEventAckLast(blink::mojom::InputEventResultState::kConsumed);
681 EXPECT_EQ(0U, GetAndResetAckedEventCount());
682 EXPECT_EQ(3U, queued_event_count());
683
684 SendTouchEventAckLast(blink::mojom::InputEventResultState::kConsumed);
685 EXPECT_EQ(WebInputEvent::Type::kTouchEnd, acked_event().GetType());
686 EXPECT_EQ(3U, GetAndResetAckedEventCount());
687 EXPECT_EQ(0U, queued_event_count());
688 }
689
690 // Tests that touch-event's enqueued via a touch ack are properly handled.
TEST_F(PassthroughTouchEventQueueTest,AckWithFollowupEvents)691 TEST_F(PassthroughTouchEventQueueTest, AckWithFollowupEvents) {
692 // Queue a touch down.
693 PressTouchPoint(1, 1);
694 EXPECT_EQ(1U, queued_event_count());
695 EXPECT_EQ(1U, GetAndResetSentEventCount());
696 EXPECT_EQ(0U, GetAndResetAckedEventCount());
697
698 // Create a touch event that will be queued synchronously by a touch ack.
699 // Note, this will be triggered by all subsequent touch acks.
700 WebTouchEvent followup_event(WebInputEvent::Type::kTouchMove,
701 WebInputEvent::kNoModifiers,
702 ui::EventTimeForNow());
703 followup_event.touches_length = 1;
704 followup_event.touches[0].id = 0;
705 followup_event.touches[0].state = WebTouchPoint::State::kStateMoved;
706 SetFollowupEvent(followup_event);
707
708 // Receive an ACK for the press. This should cause the followup touch-move to
709 // be sent to the renderer.
710 SendTouchEventAck(blink::mojom::InputEventResultState::kConsumed);
711 EXPECT_EQ(1U, queued_event_count());
712 EXPECT_EQ(1U, GetAndResetSentEventCount());
713 EXPECT_EQ(1U, GetAndResetAckedEventCount());
714 EXPECT_EQ(blink::mojom::InputEventResultState::kConsumed,
715 acked_event_state());
716 EXPECT_EQ(WebInputEvent::Type::kTouchStart, acked_event().GetType());
717
718 // Queue another event.
719 MoveTouchPoint(0, 2, 2);
720 EXPECT_EQ(2U, queued_event_count());
721
722 // Receive an ACK for the touch-move followup event. This should cause the
723 // subsequent touch move event be sent to the renderer.
724 SendTouchEventAck(blink::mojom::InputEventResultState::kConsumed);
725 EXPECT_EQ(1U, queued_event_count());
726 EXPECT_EQ(1U, GetAndResetSentEventCount());
727 EXPECT_EQ(1U, GetAndResetAckedEventCount());
728 }
729
730 // Tests that touch-events can be synchronously ack'ed.
TEST_F(PassthroughTouchEventQueueTest,SynchronousAcks)731 TEST_F(PassthroughTouchEventQueueTest, SynchronousAcks) {
732 // TouchStart
733 SetSyncAckResult(blink::mojom::InputEventResultState::kConsumed);
734 PressTouchPoint(1, 1);
735 EXPECT_EQ(0U, queued_event_count());
736 EXPECT_EQ(1U, GetAndResetSentEventCount());
737 EXPECT_EQ(1U, GetAndResetAckedEventCount());
738
739 // TouchMove
740 SetSyncAckResult(blink::mojom::InputEventResultState::kConsumed);
741 MoveTouchPoint(0, 2, 2);
742 EXPECT_EQ(0U, queued_event_count());
743 EXPECT_EQ(1U, GetAndResetSentEventCount());
744 EXPECT_EQ(1U, GetAndResetAckedEventCount());
745
746 // TouchEnd
747 SetSyncAckResult(blink::mojom::InputEventResultState::kConsumed);
748 ReleaseTouchPoint(0);
749 EXPECT_EQ(0U, queued_event_count());
750 EXPECT_EQ(1U, GetAndResetSentEventCount());
751 EXPECT_EQ(1U, GetAndResetAckedEventCount());
752
753 // TouchCancel (first inserting a TouchStart so the TouchCancel will be sent)
754 PressTouchPoint(1, 1);
755 SendTouchEventAck(blink::mojom::InputEventResultState::kConsumed);
756 EXPECT_EQ(0U, queued_event_count());
757 EXPECT_EQ(1U, GetAndResetSentEventCount());
758 EXPECT_EQ(1U, GetAndResetAckedEventCount());
759
760 SetSyncAckResult(blink::mojom::InputEventResultState::kConsumed);
761 CancelTouchPoint(0);
762 EXPECT_EQ(0U, queued_event_count());
763 EXPECT_EQ(1U, GetAndResetSentEventCount());
764 EXPECT_EQ(1U, GetAndResetAckedEventCount());
765 }
766
767 // Tests that touch-events acks are in order even with synchronous acks.
TEST_F(PassthroughTouchEventQueueTest,SynchronousAcksInOrder)768 TEST_F(PassthroughTouchEventQueueTest, SynchronousAcksInOrder) {
769 // TouchStart
770 PressTouchPoint(1, 1);
771 EXPECT_EQ(1U, queued_event_count());
772 EXPECT_EQ(1U, GetAndResetSentEventCount());
773 EXPECT_EQ(0U, GetAndResetAckedEventCount());
774
775 // TouchMove
776 MoveTouchPoint(0, 2, 3);
777 EXPECT_EQ(2U, queued_event_count());
778 EXPECT_EQ(1U, GetAndResetSentEventCount());
779 EXPECT_EQ(0U, GetAndResetAckedEventCount());
780
781 // Ack the TouchMove
782 SendTouchEventAckLast(blink::mojom::InputEventResultState::kConsumed);
783 EXPECT_EQ(2U, queued_event_count());
784 EXPECT_EQ(0U, GetAndResetSentEventCount());
785 EXPECT_EQ(0U, GetAndResetAckedEventCount());
786
787 // Create a touch event that will be queued synchronously by a touch ack.
788 WebTouchEvent followup_event(WebInputEvent::Type::kTouchMove,
789 WebInputEvent::kNoModifiers,
790 ui::EventTimeForNow());
791 followup_event.touches_length = 1;
792 followup_event.touches[0].id = 0;
793 followup_event.unique_touch_event_id = 100;
794 followup_event.touches[0].state = WebTouchPoint::State::kStateMoved;
795 SetFollowupEvent(followup_event);
796 SetSyncAckResult(blink::mojom::InputEventResultState::kConsumed);
797
798 // Ack the touch start, should release the |follow_up| event (and its ack).
799 SendTouchEventAck(blink::mojom::InputEventResultState::kConsumed);
800
801 EXPECT_EQ(0U, queued_event_count());
802 EXPECT_EQ(1U, GetAndResetSentEventCount());
803 EXPECT_EQ(3U, GetAndResetAckedEventCount());
804 EXPECT_EQ(100U, acked_event().unique_touch_event_id);
805 }
806
807 // Tests that followup events triggered by an immediate ack from
808 // TouchEventQueue::QueueEvent() are properly handled.
TEST_F(PassthroughTouchEventQueueTest,ImmediateAckWithFollowupEvents)809 TEST_F(PassthroughTouchEventQueueTest, ImmediateAckWithFollowupEvents) {
810 // Create a touch event that will be queued synchronously by a touch ack.
811 WebTouchEvent followup_event(WebInputEvent::Type::kTouchStart,
812 WebInputEvent::kNoModifiers,
813 ui::EventTimeForNow());
814 followup_event.touches_length = 1;
815 followup_event.touches[0].id = 1;
816 followup_event.touches[0].state = WebTouchPoint::State::kStatePressed;
817 SetFollowupEvent(followup_event);
818
819 // Now, enqueue a stationary touch that will not be forwarded. This should be
820 // immediately ack'ed with "NO_CONSUMER_EXISTS". The followup event should
821 // then be enqueued and immediately sent to the renderer.
822 WebTouchEvent stationary_event(WebInputEvent::Type::kTouchMove,
823 WebInputEvent::kNoModifiers,
824 ui::EventTimeForNow());
825 stationary_event.touches_length = 1;
826 stationary_event.touches[0].id = 1;
827 stationary_event.touches[0].state = WebTouchPoint::State::kStateStationary;
828 SendTouchEvent(stationary_event);
829
830 EXPECT_EQ(1U, queued_event_count());
831 EXPECT_EQ(1U, GetAndResetSentEventCount());
832 EXPECT_EQ(1U, GetAndResetAckedEventCount());
833 EXPECT_EQ(blink::mojom::InputEventResultState::kNoConsumerExists,
834 acked_event_state());
835 EXPECT_EQ(WebInputEvent::Type::kTouchMove, acked_event().GetType());
836 }
837
838 // Tests that basic TouchEvent forwarding suppression has been disabled.
TEST_F(PassthroughTouchEventQueueTest,NoTouchBasic)839 TEST_F(PassthroughTouchEventQueueTest, NoTouchBasic) {
840 // The old behaviour was to suppress events when there were no handlers.
841 // Signal the no-handler case and test that events still get forwarded.
842 OnHasTouchEventHandlers(false);
843 PressTouchPoint(30, 5);
844 EXPECT_EQ(1U, GetAndResetSentEventCount());
845 EXPECT_EQ(0U, GetAndResetAckedEventCount());
846
847 // TouchMove should not be sent to renderer.
848 MoveTouchPoint(0, 65, 10);
849 EXPECT_EQ(0U, GetAndResetSentEventCount());
850 EXPECT_EQ(0U, GetAndResetAckedEventCount());
851
852 // TouchEnd should be sent to renderer.
853 ReleaseTouchPoint(0);
854 EXPECT_EQ(1U, GetAndResetSentEventCount());
855 EXPECT_EQ(0U, GetAndResetAckedEventCount());
856
857 // Signal handlers-present and make sure events are still getting forwarded.
858 OnHasTouchEventHandlers(true);
859
860 PressTouchPoint(80, 10);
861 EXPECT_EQ(1U, GetAndResetSentEventCount());
862 SendTouchEventAck(blink::mojom::InputEventResultState::kNotConsumed);
863 EXPECT_EQ(2U, GetAndResetAckedEventCount());
864
865 MoveTouchPoint(0, 80, 20);
866 EXPECT_EQ(1U, GetAndResetSentEventCount());
867 SendTouchEventAck(blink::mojom::InputEventResultState::kNotConsumed);
868 EXPECT_EQ(1U, GetAndResetAckedEventCount());
869
870 ReleaseTouchPoint(0);
871 EXPECT_EQ(1U, GetAndResetSentEventCount());
872 SendTouchEventAck(blink::mojom::InputEventResultState::kNotConsumed);
873 EXPECT_EQ(1U, GetAndResetAckedEventCount());
874 }
875
876 // Tests that IsTouchStartPendingAck works correctly.
TEST_F(PassthroughTouchEventQueueTest,PendingStart)877 TEST_F(PassthroughTouchEventQueueTest, PendingStart) {
878 EXPECT_FALSE(IsPendingAckTouchStart());
879
880 // Send the touchstart for one point (#1).
881 PressTouchPoint(1, 1);
882 EXPECT_EQ(1U, queued_event_count());
883 EXPECT_TRUE(IsPendingAckTouchStart());
884
885 // Send a touchmove for that point (#2).
886 MoveTouchPoint(0, 5, 5);
887 EXPECT_EQ(2U, queued_event_count());
888 EXPECT_TRUE(IsPendingAckTouchStart());
889
890 // Ack the touchstart (#1).
891 SendTouchEventAck(blink::mojom::InputEventResultState::kNotConsumed);
892 EXPECT_EQ(1U, queued_event_count());
893 EXPECT_FALSE(IsPendingAckTouchStart());
894
895 // Send a touchstart for another point (#3).
896 PressTouchPoint(10, 10);
897 EXPECT_EQ(2U, queued_event_count());
898 EXPECT_TRUE(IsPendingAckTouchStart());
899
900 // Ack the touchmove (#2).
901 SendTouchEventAck(blink::mojom::InputEventResultState::kNotConsumed);
902 EXPECT_EQ(1U, queued_event_count());
903 EXPECT_TRUE(IsPendingAckTouchStart());
904
905 // Send a touchstart for a third point (#4).
906 PressTouchPoint(15, 15);
907 EXPECT_EQ(2U, queued_event_count());
908 EXPECT_TRUE(IsPendingAckTouchStart());
909
910 // Ack the touchstart for the second point (#3).
911 SendTouchEventAck(blink::mojom::InputEventResultState::kNotConsumed);
912 EXPECT_EQ(1U, queued_event_count());
913 EXPECT_TRUE(IsPendingAckTouchStart());
914
915 // Ack the touchstart for the third point (#4).
916 SendTouchEventAck(blink::mojom::InputEventResultState::kNotConsumed);
917 EXPECT_EQ(0U, queued_event_count());
918 EXPECT_FALSE(IsPendingAckTouchStart());
919 }
920
921 // Tests that the touch timeout is started when sending certain touch types.
TEST_F(PassthroughTouchEventQueueTest,TouchTimeoutTypes)922 TEST_F(PassthroughTouchEventQueueTest, TouchTimeoutTypes) {
923 SetUpForTimeoutTesting();
924
925 // Sending a TouchStart will start the timeout.
926 PressTouchPoint(0, 1);
927 EXPECT_TRUE(IsTimeoutRunning());
928 SendTouchEventAck(blink::mojom::InputEventResultState::kNotConsumed);
929 EXPECT_FALSE(IsTimeoutRunning());
930
931 // A TouchMove should start the timeout.
932 MoveTouchPoint(0, 5, 5);
933 EXPECT_TRUE(IsTimeoutRunning());
934 SendTouchEventAck(blink::mojom::InputEventResultState::kNotConsumed);
935 EXPECT_FALSE(IsTimeoutRunning());
936
937 // A TouchEnd should not start the timeout.
938 ReleaseTouchPoint(0);
939 EXPECT_FALSE(IsTimeoutRunning());
940 SendTouchEventAck(blink::mojom::InputEventResultState::kNotConsumed);
941 EXPECT_FALSE(IsTimeoutRunning());
942
943 // A TouchCancel should not start the timeout.
944 PressTouchPoint(0, 1);
945 SendTouchEventAck(blink::mojom::InputEventResultState::kNotConsumed);
946 ASSERT_FALSE(IsTimeoutRunning());
947 CancelTouchPoint(0);
948 EXPECT_FALSE(IsTimeoutRunning());
949 SendTouchEventAck(blink::mojom::InputEventResultState::kNotConsumed);
950 EXPECT_FALSE(IsTimeoutRunning());
951 }
952
953 // Tests that a delayed TouchEvent ack will trigger a TouchCancel timeout,
954 // disabling touch forwarding until the next TouchStart is received after
955 // the timeout events are ack'ed.
TEST_F(PassthroughTouchEventQueueTest,TouchTimeoutBasic)956 TEST_F(PassthroughTouchEventQueueTest, TouchTimeoutBasic) {
957 SetUpForTimeoutTesting();
958
959 // Queue a TouchStart.
960 GetAndResetSentEventCount();
961 GetAndResetAckedEventCount();
962 PressTouchPoint(0, 1);
963 ASSERT_EQ(1U, GetAndResetSentEventCount());
964 ASSERT_EQ(0U, GetAndResetAckedEventCount());
965 EXPECT_TRUE(IsTimeoutRunning());
966
967 // Delay the ack.
968 RunTasksAndWait(DefaultTouchTimeoutDelay() * 2);
969
970 // The timeout should have fired, synthetically ack'ing the timed-out event.
971 // TouchEvent forwarding is disabled until the ack is received for the
972 // timed-out event and the future cancel event.
973 EXPECT_FALSE(IsTimeoutRunning());
974 EXPECT_EQ(0U, GetAndResetSentEventCount());
975 EXPECT_EQ(1U, GetAndResetAckedEventCount());
976
977 // Ack'ing the original event should trigger a cancel event.
978 SendTouchEventAck(blink::mojom::InputEventResultState::kNotConsumed);
979 EXPECT_FALSE(IsTimeoutRunning());
980 EXPECT_EQ(WebInputEvent::Type::kTouchCancel, sent_event().GetType());
981 EXPECT_NE(WebInputEvent::DispatchType::kBlocking, sent_event().dispatch_type);
982 EXPECT_EQ(0U, GetAndResetAckedEventCount());
983 EXPECT_EQ(1U, GetAndResetSentEventCount());
984
985 // Touch events should not be forwarded until we receive the cancel acks.
986 MoveTouchPoint(0, 1, 1);
987 ASSERT_EQ(0U, GetAndResetSentEventCount());
988 ASSERT_EQ(1U, GetAndResetAckedEventCount());
989
990 ReleaseTouchPoint(0);
991 ASSERT_EQ(0U, GetAndResetSentEventCount());
992 ASSERT_EQ(1U, GetAndResetAckedEventCount());
993
994 // The synthetic TouchCancel ack should not reach the client, but should
995 // resume touch forwarding.
996 SendTouchEventAck(blink::mojom::InputEventResultState::kNotConsumed);
997 EXPECT_EQ(0U, GetAndResetSentEventCount());
998 EXPECT_EQ(0U, GetAndResetAckedEventCount());
999
1000 // Subsequent events should be handled normally.
1001 PressTouchPoint(0, 1);
1002 EXPECT_EQ(WebInputEvent::Type::kTouchStart, sent_event().GetType());
1003 EXPECT_EQ(WebInputEvent::DispatchType::kBlocking, sent_event().dispatch_type);
1004 EXPECT_EQ(1U, GetAndResetSentEventCount());
1005 EXPECT_EQ(0U, GetAndResetAckedEventCount());
1006 }
1007
1008 // Tests that the timeout is never started if the renderer consumes
1009 // a TouchEvent from the current touch sequence.
TEST_F(PassthroughTouchEventQueueTest,NoTouchTimeoutIfRendererIsConsumingGesture)1010 TEST_F(PassthroughTouchEventQueueTest,
1011 NoTouchTimeoutIfRendererIsConsumingGesture) {
1012 SetUpForTimeoutTesting();
1013
1014 // Queue a TouchStart.
1015 PressTouchPoint(0, 1);
1016 ASSERT_TRUE(IsTimeoutRunning());
1017
1018 // Mark the event as consumed. This should prevent the timeout from
1019 // being activated on subsequent TouchEvents in this gesture.
1020 SendTouchEventAck(blink::mojom::InputEventResultState::kConsumed);
1021 EXPECT_FALSE(IsTimeoutRunning());
1022
1023 // A TouchMove should not start the timeout.
1024 MoveTouchPoint(0, 5, 5);
1025 EXPECT_FALSE(IsTimeoutRunning());
1026 SendTouchEventAck(blink::mojom::InputEventResultState::kNotConsumed);
1027
1028 // A secondary TouchStart should not start the timeout.
1029 PressTouchPoint(1, 0);
1030 EXPECT_FALSE(IsTimeoutRunning());
1031 SendTouchEventAck(blink::mojom::InputEventResultState::kNotConsumed);
1032
1033 // A TouchEnd should not start the timeout.
1034 ReleaseTouchPoint(1);
1035 EXPECT_FALSE(IsTimeoutRunning());
1036 SendTouchEventAck(blink::mojom::InputEventResultState::kNotConsumed);
1037
1038 // A TouchCancel should not start the timeout.
1039 CancelTouchPoint(0);
1040 EXPECT_FALSE(IsTimeoutRunning());
1041 }
1042
1043 // Tests that the timeout is never started if the renderer consumes
1044 // a TouchEvent from the current touch sequence.
TEST_F(PassthroughTouchEventQueueTest,NoTouchTimeoutIfDisabledAfterTouchStart)1045 TEST_F(PassthroughTouchEventQueueTest,
1046 NoTouchTimeoutIfDisabledAfterTouchStart) {
1047 SetUpForTimeoutTesting();
1048
1049 // Queue a TouchStart.
1050 PressTouchPoint(0, 1);
1051 ASSERT_TRUE(IsTimeoutRunning());
1052
1053 // Send the ack immediately. The timeout should not have fired.
1054 SendTouchEventAck(blink::mojom::InputEventResultState::kNotConsumed);
1055 EXPECT_FALSE(IsTimeoutRunning());
1056 EXPECT_EQ(1U, GetAndResetSentEventCount());
1057 EXPECT_EQ(1U, GetAndResetAckedEventCount());
1058
1059 // Now explicitly disable the timeout.
1060 SetAckTimeoutDisabled();
1061 EXPECT_FALSE(IsTimeoutRunning());
1062
1063 // A TouchMove should not start or trigger the timeout.
1064 MoveTouchPoint(0, 5, 5);
1065 EXPECT_FALSE(IsTimeoutRunning());
1066 EXPECT_EQ(1U, GetAndResetSentEventCount());
1067 RunTasksAndWait(DefaultTouchTimeoutDelay() * 2);
1068 EXPECT_EQ(0U, GetAndResetAckedEventCount());
1069 }
1070
1071 // Tests that the timeout is never started if the ack is synchronous.
TEST_F(PassthroughTouchEventQueueTest,NoTouchTimeoutIfAckIsSynchronous)1072 TEST_F(PassthroughTouchEventQueueTest, NoTouchTimeoutIfAckIsSynchronous) {
1073 SetUpForTimeoutTesting();
1074
1075 // Queue a TouchStart.
1076 SetSyncAckResult(blink::mojom::InputEventResultState::kConsumed);
1077 ASSERT_FALSE(IsTimeoutRunning());
1078 PressTouchPoint(0, 1);
1079 EXPECT_FALSE(IsTimeoutRunning());
1080 }
1081
1082 // Tests that the timeout does not fire if explicitly disabled while an event
1083 // is in-flight.
TEST_F(PassthroughTouchEventQueueTest,NoTouchTimeoutIfDisabledWhileTimerIsActive)1084 TEST_F(PassthroughTouchEventQueueTest,
1085 NoTouchTimeoutIfDisabledWhileTimerIsActive) {
1086 SetUpForTimeoutTesting();
1087
1088 // Queue a TouchStart.
1089 PressTouchPoint(0, 1);
1090 ASSERT_TRUE(IsTimeoutRunning());
1091
1092 // Verify that disabling the timeout also turns off the timer.
1093 SetAckTimeoutDisabled();
1094 EXPECT_FALSE(IsTimeoutRunning());
1095 RunTasksAndWait(DefaultTouchTimeoutDelay() * 2);
1096 EXPECT_EQ(0U, GetAndResetAckedEventCount());
1097 }
1098
1099 // Tests that the timeout does not fire if the delay is zero.
TEST_F(PassthroughTouchEventQueueTest,NoTouchTimeoutIfTimeoutDelayIsZero)1100 TEST_F(PassthroughTouchEventQueueTest, NoTouchTimeoutIfTimeoutDelayIsZero) {
1101 SetUpForTimeoutTesting(base::TimeDelta(), base::TimeDelta());
1102
1103 // As the delay is zero, timeout behavior should be disabled.
1104 PressTouchPoint(0, 1);
1105 EXPECT_FALSE(IsTimeoutRunning());
1106 RunTasksAndWait(DefaultTouchTimeoutDelay() * 2);
1107 EXPECT_EQ(0U, GetAndResetAckedEventCount());
1108 }
1109
1110 // Tests that timeout delays for mobile sites take effect when appropriate.
TEST_F(PassthroughTouchEventQueueTest,TouchTimeoutConfiguredForMobile)1111 TEST_F(PassthroughTouchEventQueueTest, TouchTimeoutConfiguredForMobile) {
1112 base::TimeDelta desktop_delay = DefaultTouchTimeoutDelay();
1113 base::TimeDelta mobile_delay = base::TimeDelta();
1114 SetUpForTimeoutTesting(desktop_delay, mobile_delay);
1115
1116 // The desktop delay is non-zero, allowing timeout behavior.
1117 SetIsMobileOptimizedSite(false);
1118
1119 PressTouchPoint(0, 1);
1120 ASSERT_TRUE(IsTimeoutRunning());
1121 SendTouchEventAck(blink::mojom::InputEventResultState::kConsumed);
1122 ReleaseTouchPoint(0);
1123 SendTouchEventAck(blink::mojom::InputEventResultState::kConsumed);
1124 EXPECT_EQ(2U, GetAndResetAckedEventCount());
1125 ASSERT_FALSE(IsTimeoutRunning());
1126
1127 // The mobile delay is zero, preventing timeout behavior.
1128 SetIsMobileOptimizedSite(true);
1129
1130 PressTouchPoint(0, 1);
1131 EXPECT_FALSE(IsTimeoutRunning());
1132 RunTasksAndWait(DefaultTouchTimeoutDelay() * 2);
1133 EXPECT_EQ(0U, GetAndResetAckedEventCount());
1134 }
1135
1136 // Tests that a TouchCancel timeout plays nice when the timed out touch stream
1137 // turns into a scroll gesture sequence.
TEST_F(PassthroughTouchEventQueueTest,TouchTimeoutWithFollowupGesture)1138 TEST_F(PassthroughTouchEventQueueTest, TouchTimeoutWithFollowupGesture) {
1139 SetUpForTimeoutTesting();
1140
1141 // Queue a TouchStart.
1142 PressTouchPoint(0, 1);
1143 EXPECT_TRUE(IsTimeoutRunning());
1144 EXPECT_EQ(1U, GetAndResetSentEventCount());
1145
1146 // The cancelled sequence may turn into a scroll gesture, but this code but
1147 // these GestureScrollBegin events are generated elsewhere.
1148
1149 // Delay the ack.
1150 RunTasksAndWait(DefaultTouchTimeoutDelay() * 2);
1151
1152 // The timeout should have fired, disabling touch forwarding until both acks
1153 // are received, acking the timed out event.
1154 EXPECT_FALSE(IsTimeoutRunning());
1155 EXPECT_EQ(0U, GetAndResetSentEventCount());
1156 EXPECT_EQ(1U, GetAndResetAckedEventCount());
1157
1158 // Ack the original event, triggering a TouchCancel.
1159 SendTouchEventAck(blink::mojom::InputEventResultState::kConsumed);
1160 EXPECT_FALSE(IsTimeoutRunning());
1161 EXPECT_EQ(1U, GetAndResetSentEventCount());
1162 EXPECT_EQ(0U, GetAndResetAckedEventCount());
1163
1164 // Ack the cancel event. Normally, this would resume touch forwarding,
1165 // but we're still within a scroll gesture so it remains disabled.
1166 SendTouchEventAck(blink::mojom::InputEventResultState::kConsumed);
1167 EXPECT_FALSE(IsTimeoutRunning());
1168 EXPECT_EQ(0U, GetAndResetSentEventCount());
1169 EXPECT_EQ(0U, GetAndResetAckedEventCount());
1170
1171 // Forward touch events for the current sequence.
1172 GetAndResetSentEventCount();
1173 GetAndResetAckedEventCount();
1174 MoveTouchPoint(0, 1, 1);
1175 ReleaseTouchPoint(0);
1176 EXPECT_FALSE(IsTimeoutRunning());
1177 EXPECT_EQ(1U, GetAndResetSentEventCount());
1178 EXPECT_EQ(1U, GetAndResetAckedEventCount());
1179
1180 // Now end the scroll sequence (A GestureScrollEnd).
1181 PressTouchPoint(0, 1);
1182 EXPECT_TRUE(IsTimeoutRunning());
1183 EXPECT_EQ(1U, GetAndResetSentEventCount());
1184 EXPECT_EQ(0U, GetAndResetAckedEventCount());
1185 }
1186
1187 // Tests that a TouchCancel timeout plays nice when the timed out touch stream
1188 // turns into a scroll gesture sequence, but the original event acks are
1189 // significantly delayed.
TEST_F(PassthroughTouchEventQueueTest,TouchTimeoutWithFollowupGestureAndDelayedAck)1190 TEST_F(PassthroughTouchEventQueueTest,
1191 TouchTimeoutWithFollowupGestureAndDelayedAck) {
1192 SetUpForTimeoutTesting();
1193
1194 // Queue a TouchStart.
1195 PressTouchPoint(0, 1);
1196 EXPECT_TRUE(IsTimeoutRunning());
1197 EXPECT_EQ(1U, GetAndResetSentEventCount());
1198
1199 // The cancelled sequence may turn into a scroll gesture, but this code but
1200 // these GestureScrollBegin events are generated elsewhere.
1201
1202 // Delay the ack.
1203 RunTasksAndWait(DefaultTouchTimeoutDelay() * 2);
1204
1205 // The timeout should have fired, disabling touch forwarding until both acks
1206 // are received and acking the timed out event.
1207 EXPECT_FALSE(IsTimeoutRunning());
1208 EXPECT_EQ(0U, GetAndResetSentEventCount());
1209 EXPECT_EQ(1U, GetAndResetAckedEventCount());
1210
1211 // Try to forward a touch event.
1212 GetAndResetSentEventCount();
1213 GetAndResetAckedEventCount();
1214 MoveTouchPoint(0, 1, 1);
1215 EXPECT_FALSE(IsTimeoutRunning());
1216 EXPECT_EQ(0U, GetAndResetSentEventCount());
1217 EXPECT_EQ(1U, GetAndResetAckedEventCount());
1218
1219 // Now end the scroll sequence. Events will not be forwarded until the two
1220 // outstanding touch acks are received.
1221 MoveTouchPoint(0, 2, 2);
1222 ReleaseTouchPoint(0);
1223 EXPECT_FALSE(IsTimeoutRunning());
1224 EXPECT_EQ(0U, GetAndResetSentEventCount());
1225 EXPECT_EQ(2U, GetAndResetAckedEventCount());
1226
1227 // Ack the original event, triggering a cancel.
1228 SendTouchEventAck(blink::mojom::InputEventResultState::kConsumed);
1229 EXPECT_EQ(1U, GetAndResetSentEventCount());
1230 EXPECT_EQ(0U, GetAndResetAckedEventCount());
1231
1232 // Ack the cancel event, resuming touch forwarding.
1233 SendTouchEventAck(blink::mojom::InputEventResultState::kConsumed);
1234 EXPECT_EQ(0U, GetAndResetSentEventCount());
1235 EXPECT_EQ(0U, GetAndResetAckedEventCount());
1236
1237 PressTouchPoint(0, 1);
1238 EXPECT_TRUE(IsTimeoutRunning());
1239 EXPECT_EQ(1U, GetAndResetSentEventCount());
1240 }
1241
1242 // Tests that a delayed TouchEvent ack will not trigger a TouchCancel timeout if
1243 // the timed-out event had no consumer.
TEST_F(PassthroughTouchEventQueueTest,NoCancelOnTouchTimeoutWithoutConsumer)1244 TEST_F(PassthroughTouchEventQueueTest, NoCancelOnTouchTimeoutWithoutConsumer) {
1245 SetUpForTimeoutTesting();
1246
1247 // Queue a TouchStart.
1248 PressTouchPoint(0, 1);
1249 ASSERT_EQ(1U, GetAndResetSentEventCount());
1250 ASSERT_EQ(0U, GetAndResetAckedEventCount());
1251 EXPECT_TRUE(IsTimeoutRunning());
1252
1253 // Delay the ack.
1254 RunTasksAndWait(DefaultTouchTimeoutDelay() * 2);
1255
1256 // The timeout should have fired, synthetically ack'ing the timed out event.
1257 // TouchEvent forwarding is disabled until the original ack is received.
1258 EXPECT_FALSE(IsTimeoutRunning());
1259 EXPECT_EQ(0U, GetAndResetSentEventCount());
1260 EXPECT_EQ(1U, GetAndResetAckedEventCount());
1261
1262 // Touch events should not be forwarded until we receive the original ack.
1263 MoveTouchPoint(0, 1, 1);
1264 ReleaseTouchPoint(0);
1265 ASSERT_EQ(0U, GetAndResetSentEventCount());
1266 ASSERT_EQ(2U, GetAndResetAckedEventCount());
1267
1268 // Ack'ing the original event should not trigger a cancel event, as the
1269 // TouchStart had no consumer. However, it should re-enable touch forwarding.
1270 SendTouchEventAck(blink::mojom::InputEventResultState::kNoConsumerExists);
1271 EXPECT_FALSE(IsTimeoutRunning());
1272 EXPECT_EQ(0U, GetAndResetAckedEventCount());
1273 EXPECT_EQ(0U, GetAndResetSentEventCount());
1274
1275 // Subsequent events should be handled normally.
1276 PressTouchPoint(0, 1);
1277 EXPECT_EQ(1U, GetAndResetSentEventCount());
1278 EXPECT_EQ(0U, GetAndResetAckedEventCount());
1279 }
1280
1281 // Tests that TouchMove's movedBeyondSlopRegion is set to false if within the
1282 // boundary-inclusive slop region for an unconsumed TouchStart.
TEST_F(PassthroughTouchEventQueueTest,TouchMovedBeyondSlopRegionCheck)1283 TEST_F(PassthroughTouchEventQueueTest, TouchMovedBeyondSlopRegionCheck) {
1284 SetUpForTouchMoveSlopTesting(kSlopLengthDips);
1285
1286 // Queue a TouchStart.
1287 PressTouchPoint(0, 0);
1288 SendTouchEventAck(blink::mojom::InputEventResultState::kNotConsumed);
1289 ASSERT_EQ(1U, GetAndResetSentEventCount());
1290 ASSERT_EQ(1U, GetAndResetAckedEventCount());
1291
1292 // TouchMove's movedBeyondSlopRegion within the slop region is set to false.
1293 MoveTouchPoint(0, 0, kHalfSlopLengthDips);
1294 EXPECT_EQ(1U, queued_event_count());
1295 SendTouchEventAck(blink::mojom::InputEventResultState::kNotConsumed);
1296 EXPECT_EQ(1U, GetAndResetSentEventCount());
1297 EXPECT_EQ(1U, GetAndResetAckedEventCount());
1298 EXPECT_FALSE(acked_event().moved_beyond_slop_region);
1299
1300 MoveTouchPoint(0, kHalfSlopLengthDips, 0);
1301 EXPECT_EQ(1U, queued_event_count());
1302 SendTouchEventAck(blink::mojom::InputEventResultState::kNotConsumed);
1303 EXPECT_EQ(1U, GetAndResetSentEventCount());
1304 EXPECT_EQ(1U, GetAndResetAckedEventCount());
1305 EXPECT_FALSE(acked_event().moved_beyond_slop_region);
1306
1307 MoveTouchPoint(0, -kHalfSlopLengthDips, 0);
1308 EXPECT_EQ(1U, queued_event_count());
1309 SendTouchEventAck(blink::mojom::InputEventResultState::kNotConsumed);
1310 EXPECT_EQ(1U, GetAndResetSentEventCount());
1311 EXPECT_EQ(1U, GetAndResetAckedEventCount());
1312 EXPECT_FALSE(acked_event().moved_beyond_slop_region);
1313
1314 MoveTouchPoint(0, -kSlopLengthDips, 0);
1315 EXPECT_EQ(1U, queued_event_count());
1316 SendTouchEventAck(blink::mojom::InputEventResultState::kNotConsumed);
1317 EXPECT_EQ(1U, GetAndResetSentEventCount());
1318 EXPECT_EQ(1U, GetAndResetAckedEventCount());
1319 EXPECT_FALSE(acked_event().moved_beyond_slop_region);
1320
1321 MoveTouchPoint(0, 0, kSlopLengthDips);
1322 EXPECT_EQ(1U, queued_event_count());
1323 SendTouchEventAck(blink::mojom::InputEventResultState::kNotConsumed);
1324 EXPECT_EQ(1U, GetAndResetSentEventCount());
1325 EXPECT_EQ(1U, GetAndResetAckedEventCount());
1326 EXPECT_FALSE(acked_event().moved_beyond_slop_region);
1327
1328 // When a TouchMove exceeds the (Euclidean) distance, the TouchMove's
1329 // movedBeyondSlopRegion is set to true.
1330 const float kFortyFiveDegreeSlopLengthXY =
1331 kSlopLengthDips * std::sqrt(2.f) / 2;
1332 MoveTouchPoint(0, kFortyFiveDegreeSlopLengthXY + .2f,
1333 kFortyFiveDegreeSlopLengthXY + .2f);
1334 EXPECT_EQ(1U, queued_event_count());
1335 EXPECT_EQ(1U, GetAndResetSentEventCount());
1336 EXPECT_EQ(0U, GetAndResetAckedEventCount());
1337 SendTouchEventAck(blink::mojom::InputEventResultState::kNotConsumed);
1338 EXPECT_EQ(1U, GetAndResetAckedEventCount());
1339 EXPECT_TRUE(acked_event().moved_beyond_slop_region);
1340 }
1341
1342 // Tests that even very small TouchMove's movedBeyondSlopRegion is set to true
1343 // when the slop region's dimension is 0.
TEST_F(PassthroughTouchEventQueueTest,MovedBeyondSlopRegionAlwaysTrueIfDimensionZero)1344 TEST_F(PassthroughTouchEventQueueTest,
1345 MovedBeyondSlopRegionAlwaysTrueIfDimensionZero) {
1346 // Queue a TouchStart.
1347 PressTouchPoint(0, 0);
1348 SendTouchEventAck(blink::mojom::InputEventResultState::kNotConsumed);
1349 ASSERT_EQ(1U, GetAndResetSentEventCount());
1350 ASSERT_EQ(1U, GetAndResetAckedEventCount());
1351
1352 // Small TouchMove's movedBeyondSlopRegion is set to true.
1353 MoveTouchPoint(0, 0.001f, 0.001f);
1354 EXPECT_EQ(1U, queued_event_count());
1355 EXPECT_EQ(1U, GetAndResetSentEventCount());
1356 EXPECT_EQ(0U, GetAndResetAckedEventCount());
1357 SendTouchEventAck(blink::mojom::InputEventResultState::kNotConsumed);
1358 EXPECT_EQ(1U, GetAndResetAckedEventCount());
1359 EXPECT_TRUE(acked_event().moved_beyond_slop_region);
1360 }
1361
1362 // Tests that secondary touch points can be forwarded even if the primary touch
1363 // point had no consumer.
TEST_F(PassthroughTouchEventQueueTest,SecondaryTouchForwardedAfterPrimaryHadNoConsumer)1364 TEST_F(PassthroughTouchEventQueueTest,
1365 SecondaryTouchForwardedAfterPrimaryHadNoConsumer) {
1366 // Queue a TouchStart.
1367 PressTouchPoint(0, 0);
1368 SendTouchEventAck(blink::mojom::InputEventResultState::kNoConsumerExists);
1369 ASSERT_EQ(1U, GetAndResetSentEventCount());
1370 ASSERT_EQ(1U, GetAndResetAckedEventCount());
1371
1372 // TouchMove events should not be forwarded, as the point had no consumer.
1373 MoveTouchPoint(0, 0, 15);
1374 EXPECT_EQ(0U, queued_event_count());
1375 EXPECT_EQ(0U, GetAndResetSentEventCount());
1376 EXPECT_EQ(1U, GetAndResetAckedEventCount());
1377
1378 // Simulate a secondary pointer press.
1379 PressTouchPoint(20, 0);
1380 SendTouchEventAck(blink::mojom::InputEventResultState::kNotConsumed);
1381 EXPECT_EQ(1U, GetAndResetSentEventCount());
1382 EXPECT_EQ(1U, GetAndResetAckedEventCount());
1383
1384 // TouchMove with a secondary pointer should not be suppressed.
1385 MoveTouchPoint(1, 25, 0);
1386 EXPECT_EQ(1U, queued_event_count());
1387 EXPECT_EQ(1U, GetAndResetSentEventCount());
1388 SendTouchEventAck(blink::mojom::InputEventResultState::kNotConsumed);
1389 EXPECT_EQ(1U, GetAndResetAckedEventCount());
1390 }
1391
1392 // Tests that secondary touch points can be forwarded after scrolling begins
1393 // while first touch point has no consumer.
TEST_F(PassthroughTouchEventQueueTest,NoForwardingAfterScrollWithNoTouchConsumers)1394 TEST_F(PassthroughTouchEventQueueTest,
1395 NoForwardingAfterScrollWithNoTouchConsumers) {
1396 // Queue a TouchStart.
1397 PressTouchPoint(0, 0);
1398 SendTouchEventAck(blink::mojom::InputEventResultState::kNoConsumerExists);
1399 ASSERT_EQ(1U, GetAndResetSentEventCount());
1400 ASSERT_EQ(1U, GetAndResetAckedEventCount());
1401
1402 MoveTouchPoint(0, 20, 5);
1403 EXPECT_EQ(0U, GetAndResetSentEventCount());
1404 EXPECT_EQ(1U, GetAndResetAckedEventCount());
1405 EXPECT_EQ(blink::mojom::InputEventResultState::kNoConsumerExists,
1406 acked_event_state());
1407
1408 // The secondary pointer press should be forwarded.
1409 PressTouchPoint(20, 0);
1410 SendTouchEventAck(blink::mojom::InputEventResultState::kConsumed);
1411 EXPECT_EQ(1U, GetAndResetSentEventCount());
1412 EXPECT_EQ(1U, GetAndResetAckedEventCount());
1413
1414 // TouchMove with a secondary pointer should also be forwarded.
1415 MoveTouchPoint(1, 25, 0);
1416 EXPECT_EQ(1U, queued_event_count());
1417 EXPECT_EQ(1U, GetAndResetSentEventCount());
1418 SendTouchEventAck(blink::mojom::InputEventResultState::kConsumed);
1419 EXPECT_EQ(1U, GetAndResetAckedEventCount());
1420 }
1421
TEST_F(PassthroughTouchEventQueueTest,TouchAbsorptionWithConsumedFirstMove)1422 TEST_F(PassthroughTouchEventQueueTest, TouchAbsorptionWithConsumedFirstMove) {
1423 // Queue a TouchStart.
1424 PressTouchPoint(0, 1);
1425 SendTouchEventAck(blink::mojom::InputEventResultState::kNotConsumed);
1426 EXPECT_EQ(0U, queued_event_count());
1427 EXPECT_EQ(1U, GetAndResetAckedEventCount());
1428
1429 MoveTouchPoint(0, 20, 5);
1430 SendTouchEventAck(blink::mojom::InputEventResultState::kConsumed);
1431 EXPECT_EQ(0U, queued_event_count());
1432 EXPECT_EQ(2U, GetAndResetSentEventCount());
1433
1434 // Even if the first touchmove event was consumed, subsequent unconsumed
1435 // touchmove events should trigger scrolling.
1436 MoveTouchPoint(0, 60, 5);
1437 SendTouchEventAck(blink::mojom::InputEventResultState::kConsumed);
1438 EXPECT_EQ(0U, queued_event_count());
1439 EXPECT_EQ(WebInputEvent::DispatchType::kBlocking, sent_event().dispatch_type);
1440 EXPECT_EQ(1U, GetAndResetSentEventCount());
1441
1442 MoveTouchPoint(0, 20, 5);
1443 // A GestureScrollUpdate would be sent here so simulate the ACK of the
1444 // TouchMove AND the GestureScrollUpdate
1445 SendTouchEventAck(blink::mojom::InputEventResultState::kNotConsumed);
1446 SendGestureEventAck(WebInputEvent::Type::kGestureScrollUpdate,
1447 blink::mojom::InputEventResultState::kConsumed);
1448 EXPECT_EQ(0U, queued_event_count());
1449 EXPECT_EQ(WebInputEvent::DispatchType::kBlocking, sent_event().dispatch_type);
1450 EXPECT_EQ(1U, GetAndResetSentEventCount());
1451
1452 // Touch moves are sent right away.
1453 MoveTouchPoint(0, 60, 5);
1454 EXPECT_EQ(1U, queued_event_count());
1455 EXPECT_EQ(1U, GetAndResetSentEventCount());
1456 }
1457
TEST_F(PassthroughTouchEventQueueTest,TouchStartCancelableDuringScroll)1458 TEST_F(PassthroughTouchEventQueueTest, TouchStartCancelableDuringScroll) {
1459 // Queue a touchstart and touchmove that go unconsumed, transitioning to an
1460 // active scroll sequence.
1461 PressTouchPoint(0, 1);
1462 SendTouchEventAck(blink::mojom::InputEventResultState::kNotConsumed);
1463 EXPECT_EQ(WebInputEvent::DispatchType::kBlocking, sent_event().dispatch_type);
1464 ASSERT_EQ(1U, GetAndResetSentEventCount());
1465
1466 MoveTouchPoint(0, 20, 5);
1467 EXPECT_EQ(WebInputEvent::DispatchType::kBlocking, sent_event().dispatch_type);
1468 SendTouchEventAck(blink::mojom::InputEventResultState::kNotConsumed);
1469 // Consume the GestureScrollUpdate to move TouchMoves to async behaviour.
1470 SendGestureEventAck(WebInputEvent::Type::kGestureScrollUpdate,
1471 blink::mojom::InputEventResultState::kConsumed);
1472 EXPECT_EQ(WebInputEvent::DispatchType::kBlocking, sent_event().dispatch_type);
1473 ASSERT_EQ(1U, GetAndResetSentEventCount());
1474
1475 // Even though scrolling has begun, touchstart events should be cancelable,
1476 // allowing, for example, customized pinch processing.
1477 PressTouchPoint(10, 11);
1478 SendTouchEventAck(blink::mojom::InputEventResultState::kConsumed);
1479 EXPECT_EQ(WebInputEvent::DispatchType::kBlocking, sent_event().dispatch_type);
1480 ASSERT_EQ(1U, GetAndResetSentEventCount());
1481
1482 // As the touch start was consumed, touchmoves should no longer be throttled.
1483 MoveTouchPoint(1, 11, 11);
1484 SendTouchEventAck(blink::mojom::InputEventResultState::kConsumed);
1485 EXPECT_EQ(WebInputEvent::DispatchType::kBlocking, sent_event().dispatch_type);
1486 ASSERT_EQ(1U, GetAndResetSentEventCount());
1487
1488 // With throttling disabled, touchend and touchmove events should also be
1489 // cancelable.
1490 MoveTouchPoint(1, 12, 12);
1491 SendTouchEventAck(blink::mojom::InputEventResultState::kConsumed);
1492 EXPECT_EQ(WebInputEvent::DispatchType::kBlocking, sent_event().dispatch_type);
1493 ASSERT_EQ(1U, GetAndResetSentEventCount());
1494 ReleaseTouchPoint(1);
1495 SendTouchEventAck(blink::mojom::InputEventResultState::kConsumed);
1496 EXPECT_EQ(WebInputEvent::DispatchType::kBlocking, sent_event().dispatch_type);
1497 ASSERT_EQ(1U, GetAndResetSentEventCount());
1498
1499 // If subsequent touchmoves aren't consumed, the generated scroll events
1500 // will restore async touch dispatch if the GestureScrollUpdate's are
1501 // consumed.
1502 MoveTouchPoint(0, 25, 5);
1503 SendTouchEventAck(blink::mojom::InputEventResultState::kNotConsumed);
1504 SendGestureEventAck(WebInputEvent::Type::kGestureScrollUpdate,
1505 blink::mojom::InputEventResultState::kConsumed);
1506 EXPECT_EQ(WebInputEvent::DispatchType::kBlocking, sent_event().dispatch_type);
1507 ASSERT_EQ(1U, GetAndResetSentEventCount());
1508 AdvanceTouchTime(kMinSecondsBetweenThrottledTouchmoves + 0.1);
1509 MoveTouchPoint(0, 30, 5);
1510 SendTouchEventAck(blink::mojom::InputEventResultState::kNotConsumed);
1511 SendGestureEventAck(WebInputEvent::Type::kGestureScrollUpdate,
1512 blink::mojom::InputEventResultState::kConsumed);
1513 EXPECT_NE(WebInputEvent::DispatchType::kBlocking, sent_event().dispatch_type);
1514 ASSERT_EQ(1U, GetAndResetSentEventCount());
1515
1516 // The touchend will be uncancelable during an active scroll sequence.
1517 ReleaseTouchPoint(0);
1518 EXPECT_NE(WebInputEvent::DispatchType::kBlocking, sent_event().dispatch_type);
1519 ASSERT_EQ(1U, GetAndResetSentEventCount());
1520 }
1521
TEST_F(PassthroughTouchEventQueueTest,UnseenTouchPointerIdsNotForwarded)1522 TEST_F(PassthroughTouchEventQueueTest, UnseenTouchPointerIdsNotForwarded) {
1523 SyntheticWebTouchEvent event;
1524 event.PressPoint(0, 0);
1525 SendTouchEvent(event);
1526 EXPECT_EQ(1U, GetAndResetSentEventCount());
1527 SendTouchEventAck(blink::mojom::InputEventResultState::kConsumed);
1528 EXPECT_EQ(1U, GetAndResetAckedEventCount());
1529
1530 // Give the touchmove a previously unseen pointer id; it should not be sent.
1531 int press_id = event.touches[0].id;
1532 event.MovePoint(0, 1, 1);
1533 event.touches[0].id = 7;
1534 SendTouchEvent(event);
1535 EXPECT_EQ(0U, GetAndResetSentEventCount());
1536 EXPECT_EQ(1U, GetAndResetAckedEventCount());
1537
1538 // Give the touchmove a valid id; it should be sent.
1539 event.touches[0].id = press_id;
1540 SendTouchEvent(event);
1541 EXPECT_EQ(1U, GetAndResetSentEventCount());
1542 SendTouchEventAck(blink::mojom::InputEventResultState::kConsumed);
1543 EXPECT_EQ(1U, GetAndResetAckedEventCount());
1544
1545 // Do the same for release.
1546 event.ReleasePoint(0);
1547 event.touches[0].id = 11;
1548 SendTouchEvent(event);
1549 EXPECT_EQ(0U, GetAndResetSentEventCount());
1550 EXPECT_EQ(1U, GetAndResetAckedEventCount());
1551
1552 // Give the touchmove a valid id after release; it should be sent.
1553 event.touches[0].id = press_id;
1554 SendTouchEvent(event);
1555 EXPECT_EQ(1U, GetAndResetSentEventCount());
1556 EXPECT_EQ(0U, GetAndResetAckedEventCount());
1557 }
1558
1559 // Tests that touch points states are correct in TouchMove events.
TEST_F(PassthroughTouchEventQueueTest,PointerStatesInTouchMove)1560 TEST_F(PassthroughTouchEventQueueTest, PointerStatesInTouchMove) {
1561 PressTouchPoint(1, 1);
1562 PressTouchPoint(2, 2);
1563 PressTouchPoint(3, 3);
1564 EXPECT_EQ(3U, queued_event_count());
1565 EXPECT_EQ(3U, GetAndResetSentEventCount());
1566 PressTouchPoint(4, 4);
1567
1568 // Receive ACK for the first three touch-events.
1569 SendTouchEventAck(blink::mojom::InputEventResultState::kConsumed);
1570 SendTouchEventAck(blink::mojom::InputEventResultState::kConsumed);
1571 SendTouchEventAck(blink::mojom::InputEventResultState::kConsumed);
1572 EXPECT_EQ(1U, queued_event_count());
1573
1574 // Test current touches state before sending TouchMoves.
1575 const WebTouchEvent& event1 = sent_event();
1576 EXPECT_EQ(WebInputEvent::Type::kTouchStart, event1.GetType());
1577 EXPECT_EQ(WebTouchPoint::State::kStateStationary, event1.touches[0].state);
1578 EXPECT_EQ(WebTouchPoint::State::kStateStationary, event1.touches[1].state);
1579 EXPECT_EQ(WebTouchPoint::State::kStateStationary, event1.touches[2].state);
1580 EXPECT_EQ(WebTouchPoint::State::kStatePressed, event1.touches[3].state);
1581
1582 // Move x-position for 1st touch, y-position for 2nd touch
1583 // and do not move other touches.
1584 MoveTouchPoints(0, 1.1f, 1.f, 1, 2.f, 20.001f);
1585 MoveTouchPoints(2, 3.f, 3.f, 3, 4.f, 4.f);
1586 EXPECT_EQ(3U, queued_event_count());
1587
1588 // Receive an ACK for the last TouchPress event.
1589 SendTouchEventAck(blink::mojom::InputEventResultState::kConsumed);
1590
1591 // 1st TouchMove is sent. Test for touches state.
1592 const WebTouchEvent& event2 = sent_event();
1593 EXPECT_EQ(WebInputEvent::Type::kTouchMove, event2.GetType());
1594 EXPECT_EQ(WebTouchPoint::State::kStateMoved, event2.touches[0].state);
1595 EXPECT_EQ(WebTouchPoint::State::kStateMoved, event2.touches[1].state);
1596 EXPECT_EQ(WebTouchPoint::State::kStateStationary, event2.touches[2].state);
1597 EXPECT_EQ(WebTouchPoint::State::kStateStationary, event2.touches[3].state);
1598
1599 // Move only 4th touch but not others.
1600 MoveTouchPoints(0, 1.1f, 1.f, 1, 2.f, 20.001f);
1601 MoveTouchPoints(2, 3.f, 3.f, 3, 4.1f, 4.1f);
1602
1603 // Receive an ACK for previous (1st) TouchMove.
1604 SendTouchEventAck(blink::mojom::InputEventResultState::kConsumed);
1605
1606 // 2nd TouchMove is sent. Test for touches state.
1607 const WebTouchEvent& event3 = sent_event();
1608 EXPECT_EQ(WebInputEvent::Type::kTouchMove, event3.GetType());
1609 EXPECT_EQ(WebTouchPoint::State::kStateStationary, event3.touches[0].state);
1610 EXPECT_EQ(WebTouchPoint::State::kStateStationary, event3.touches[1].state);
1611 EXPECT_EQ(WebTouchPoint::State::kStateStationary, event3.touches[2].state);
1612 EXPECT_EQ(WebTouchPoint::State::kStateMoved, event3.touches[3].state);
1613 }
1614
1615 // Tests that touch point state is correct in TouchMove events
1616 // when point properties other than position changed.
TEST_F(PassthroughTouchEventQueueTest,PointerStatesWhenOtherThanPositionChanged)1617 TEST_F(PassthroughTouchEventQueueTest,
1618 PointerStatesWhenOtherThanPositionChanged) {
1619 PressTouchPoint(1, 1);
1620 SendTouchEventAck(blink::mojom::InputEventResultState::kConsumed);
1621
1622 // Default initial radiusX/Y is (20.f, 20.f).
1623 // Default initial rotationAngle is 0.f.
1624 // Default initial force is 1.f.
1625
1626 // Change touch point radius only.
1627 ChangeTouchPointRadius(0, 1.5f, 1.f);
1628 SendTouchEventAck(blink::mojom::InputEventResultState::kConsumed);
1629
1630 // TouchMove is sent. Test for pointer state.
1631 const WebTouchEvent& event1 = sent_event();
1632 EXPECT_EQ(WebInputEvent::Type::kTouchMove, event1.GetType());
1633 EXPECT_EQ(WebTouchPoint::State::kStateMoved, event1.touches[0].state);
1634
1635 // Change touch point force.
1636 ChangeTouchPointForce(0, 0.9f);
1637 SendTouchEventAck(blink::mojom::InputEventResultState::kConsumed);
1638
1639 // TouchMove is sent. Test for pointer state.
1640 const WebTouchEvent& event2 = sent_event();
1641 EXPECT_EQ(WebInputEvent::Type::kTouchMove, event2.GetType());
1642 EXPECT_EQ(WebTouchPoint::State::kStateMoved, event2.touches[0].state);
1643
1644 // Change touch point rotationAngle.
1645 ChangeTouchPointRotationAngle(0, 1.1f);
1646 SendTouchEventAck(blink::mojom::InputEventResultState::kConsumed);
1647
1648 // TouchMove is sent. Test for pointer state.
1649 const WebTouchEvent& event3 = sent_event();
1650 EXPECT_EQ(WebInputEvent::Type::kTouchMove, event3.GetType());
1651 EXPECT_EQ(WebTouchPoint::State::kStateMoved, event3.touches[0].state);
1652
1653 EXPECT_EQ(0U, queued_event_count());
1654 EXPECT_EQ(4U, GetAndResetSentEventCount());
1655 EXPECT_EQ(4U, GetAndResetAckedEventCount());
1656 }
1657
1658 // Tests that TouchMoves are filtered when none of the points are changed.
TEST_F(PassthroughTouchEventQueueTest,FilterTouchMovesWhenNoPointerChanged)1659 TEST_F(PassthroughTouchEventQueueTest, FilterTouchMovesWhenNoPointerChanged) {
1660 PressTouchPoint(1, 1);
1661 PressTouchPoint(2, 2);
1662 SendTouchEventAck(blink::mojom::InputEventResultState::kConsumed);
1663 SendTouchEventAck(blink::mojom::InputEventResultState::kConsumed);
1664 EXPECT_EQ(0U, queued_event_count());
1665 EXPECT_EQ(2U, GetAndResetSentEventCount());
1666 EXPECT_EQ(2U, GetAndResetAckedEventCount());
1667
1668 // Move 1st touch point.
1669 MoveTouchPoint(0, 10, 10);
1670 EXPECT_EQ(1U, queued_event_count());
1671
1672 // TouchMove should be allowed and test for touches state.
1673 const WebTouchEvent& event1 = sent_event();
1674 EXPECT_EQ(WebInputEvent::Type::kTouchMove, event1.GetType());
1675 EXPECT_EQ(WebTouchPoint::State::kStateMoved, event1.touches[0].state);
1676 EXPECT_EQ(WebTouchPoint::State::kStateStationary, event1.touches[1].state);
1677 EXPECT_EQ(1U, GetAndResetSentEventCount());
1678 EXPECT_EQ(0U, GetAndResetAckedEventCount());
1679
1680 // Do not really move any touch points, but use previous values.
1681 MoveTouchPoint(0, 10, 10);
1682 ChangeTouchPointRadius(1, radius_x_, radius_y_);
1683 MoveTouchPoint(1, 2, 2);
1684 EXPECT_EQ(4U, queued_event_count());
1685 EXPECT_EQ(0U, GetAndResetSentEventCount());
1686 // The TouchMove but should be filtered when none of the touch points have
1687 // changed but don't get acked right away.
1688 EXPECT_EQ(0U, GetAndResetAckedEventCount());
1689
1690 // Receive an ACK for 1st TouchMove.
1691 SendTouchEventAck(blink::mojom::InputEventResultState::kConsumed);
1692
1693 EXPECT_EQ(0U, queued_event_count());
1694 EXPECT_EQ(0U, GetAndResetSentEventCount());
1695 EXPECT_EQ(4U, GetAndResetAckedEventCount());
1696 EXPECT_EQ(blink::mojom::InputEventResultState::kNoConsumerExists,
1697 acked_event_state());
1698
1699 // Move 2nd touch point.
1700 MoveTouchPoint(1, 3, 3);
1701 SendTouchEventAck(blink::mojom::InputEventResultState::kConsumed);
1702 EXPECT_EQ(0U, queued_event_count());
1703
1704 // TouchMove should be allowed and test for touches state.
1705 const WebTouchEvent& event2 = sent_event();
1706 EXPECT_EQ(WebInputEvent::Type::kTouchMove, event2.GetType());
1707 EXPECT_EQ(WebTouchPoint::State::kStateStationary, event2.touches[0].state);
1708 EXPECT_EQ(WebTouchPoint::State::kStateMoved, event2.touches[1].state);
1709 EXPECT_EQ(1U, GetAndResetSentEventCount());
1710 EXPECT_EQ(1U, GetAndResetAckedEventCount());
1711 }
1712
1713 // Tests that touch-scroll-notification is queued normally.
TEST_F(PassthroughTouchEventQueueTest,TouchScrollNotificationOrder_EmptyQueue)1714 TEST_F(PassthroughTouchEventQueueTest,
1715 TouchScrollNotificationOrder_EmptyQueue) {
1716 PrependTouchScrollNotification();
1717
1718 EXPECT_EQ(0U, GetAndResetAckedEventCount());
1719 EXPECT_EQ(1U, queued_event_count());
1720 EXPECT_EQ(1U, GetAndResetSentEventCount());
1721 }
1722
1723 // Tests touch-scroll-notification firing is appended to the tail of sent
1724 // events since all events are sent right away.
TEST_F(PassthroughTouchEventQueueTest,TouchScrollNotificationOrder_EndOfQueue)1725 TEST_F(PassthroughTouchEventQueueTest,
1726 TouchScrollNotificationOrder_EndOfQueue) {
1727 PressTouchPoint(1, 1);
1728
1729 EXPECT_EQ(0U, GetAndResetAckedEventCount());
1730 EXPECT_EQ(1U, queued_event_count());
1731
1732 // Send the touch-scroll-notification when 3 events are in the queue.
1733 PrependTouchScrollNotification();
1734
1735 EXPECT_EQ(0U, GetAndResetAckedEventCount());
1736 EXPECT_EQ(2U, queued_event_count());
1737
1738 // Send ACKs.
1739 SendTouchEventAck(blink::mojom::InputEventResultState::kConsumed);
1740 SendTouchEventAck(blink::mojom::InputEventResultState::kIgnored);
1741
1742 // Touch-scroll-start Ack is not reported to client.
1743 EXPECT_EQ(1U, GetAndResetAckedEventCount());
1744 EXPECT_EQ(0U, queued_event_count());
1745
1746 EXPECT_EQ(WebInputEvent::Type::kTouchStart, all_sent_events()[0].GetType());
1747 EXPECT_EQ(WebInputEvent::Type::kTouchScrollStarted,
1748 all_sent_events()[1].GetType());
1749 EXPECT_EQ(2U, GetAndResetSentEventCount());
1750 }
1751
1752 // Tests that if touchStartOrFirstTouchMove is correctly set up for touch
1753 // events.
TEST_F(PassthroughTouchEventQueueTest,TouchStartOrFirstTouchMove)1754 TEST_F(PassthroughTouchEventQueueTest, TouchStartOrFirstTouchMove) {
1755 PressTouchPoint(1, 1);
1756 SendTouchEventAck(blink::mojom::InputEventResultState::kConsumed);
1757 EXPECT_EQ(WebInputEvent::Type::kTouchStart, sent_event().GetType());
1758 EXPECT_TRUE(sent_event().touch_start_or_first_touch_move);
1759
1760 MoveTouchPoint(0, 5, 5);
1761 SendTouchEventAck(blink::mojom::InputEventResultState::kConsumed);
1762 EXPECT_EQ(WebInputEvent::Type::kTouchMove, sent_event().GetType());
1763 EXPECT_TRUE(sent_event().touch_start_or_first_touch_move);
1764
1765 MoveTouchPoint(0, 15, 15);
1766 SendTouchEventAck(blink::mojom::InputEventResultState::kConsumed);
1767 EXPECT_EQ(WebInputEvent::Type::kTouchMove, sent_event().GetType());
1768 EXPECT_FALSE(sent_event().touch_start_or_first_touch_move);
1769
1770 ReleaseTouchPoint(0);
1771 SendTouchEventAck(blink::mojom::InputEventResultState::kConsumed);
1772 EXPECT_EQ(WebInputEvent::Type::kTouchEnd, sent_event().GetType());
1773 EXPECT_FALSE(sent_event().touch_start_or_first_touch_move);
1774 }
1775
TEST_F(PassthroughTouchEventQueueTest,TouchScrollStartedUnfiltered)1776 TEST_F(PassthroughTouchEventQueueTest, TouchScrollStartedUnfiltered) {
1777 SyntheticWebTouchEvent event;
1778 event.SetType(WebInputEvent::Type::kTouchScrollStarted);
1779 EXPECT_EQ(PassthroughTouchEventQueue::PreFilterResult::kUnfiltered,
1780 FilterBeforeForwarding(event));
1781 }
1782
TEST_F(PassthroughTouchEventQueueTest,TouchStartWithoutPageHandlersUnfiltered)1783 TEST_F(PassthroughTouchEventQueueTest,
1784 TouchStartWithoutPageHandlersUnfiltered) {
1785 OnHasTouchEventHandlers(false);
1786 SyntheticWebTouchEvent event;
1787 event.PressPoint(1, 1);
1788
1789 EXPECT_EQ(PassthroughTouchEventQueue::PreFilterResult::kUnfiltered,
1790 FilterBeforeForwarding(event));
1791 }
1792
TEST_F(PassthroughTouchEventQueueTest,TouchStartWithPageHandlersUnfiltered)1793 TEST_F(PassthroughTouchEventQueueTest, TouchStartWithPageHandlersUnfiltered) {
1794 OnHasTouchEventHandlers(true);
1795 SyntheticWebTouchEvent event;
1796 event.PressPoint(1, 1);
1797
1798 EXPECT_EQ(PassthroughTouchEventQueue::PreFilterResult::kUnfiltered,
1799 FilterBeforeForwarding(event));
1800 }
1801
TEST_F(PassthroughTouchEventQueueTest,TouchMoveFilteredAfterTimeout)1802 TEST_F(PassthroughTouchEventQueueTest, TouchMoveFilteredAfterTimeout) {
1803 SetUpForTimeoutTesting();
1804 OnHasTouchEventHandlers(true);
1805 PressTouchPoint(1, 1);
1806
1807 // Allow the initial touch start event to time out.
1808 RunTasksAndWait(DefaultTouchTimeoutDelay() * 2);
1809
1810 // Any subsequent touch move events are filtered.
1811 SyntheticWebTouchEvent event;
1812 int id = event.PressPoint(1, 1);
1813 event.MovePoint(id, 2, 2);
1814
1815 EXPECT_EQ(PassthroughTouchEventQueue::PreFilterResult::kFilteredTimeout,
1816 FilterBeforeForwarding(event));
1817 }
1818
TEST_F(PassthroughTouchEventQueueTest,TouchMoveWithoutPageHandlersUnfiltered)1819 TEST_F(PassthroughTouchEventQueueTest, TouchMoveWithoutPageHandlersUnfiltered) {
1820 OnHasTouchEventHandlers(false);
1821 // Start the touch sequence.
1822 PressTouchPoint(1, 1);
1823
1824 SyntheticWebTouchEvent event;
1825 int id = event.PressPoint(1, 1);
1826 event.MovePoint(id, 2, 2);
1827
1828 EXPECT_EQ(
1829 PassthroughTouchEventQueue::PreFilterResult::kFilteredNoPageHandlers,
1830 FilterBeforeForwarding(event));
1831 }
1832
TEST_F(PassthroughTouchEventQueueTest,StationaryTouchMoveFiltered)1833 TEST_F(PassthroughTouchEventQueueTest, StationaryTouchMoveFiltered) {
1834 OnHasTouchEventHandlers(true);
1835 // Start the touch sequence.
1836 PressTouchPoint(1, 1);
1837
1838 // Touch move events with stationary pointers are filtered.
1839 SyntheticWebTouchEvent event;
1840 int id = event.PressPoint(1, 1);
1841 event.MovePoint(id, 1, 1);
1842
1843 EXPECT_EQ(PassthroughTouchEventQueue::PreFilterResult::
1844 kFilteredNoNonstationaryPointers,
1845 FilterBeforeForwarding(event));
1846 }
1847
TEST_F(PassthroughTouchEventQueueTest,StationaryTouchMoveWithActualTouchMoveUnfiltered)1848 TEST_F(PassthroughTouchEventQueueTest,
1849 StationaryTouchMoveWithActualTouchMoveUnfiltered) {
1850 OnHasTouchEventHandlers(true);
1851 // Start the touch sequence.
1852 PressTouchPoint(1, 1);
1853 PressTouchPoint(2, 2);
1854
1855 // Touch move events with non stationary pointers are unfiltered, even if
1856 // there's another touch with a stationary pointer.
1857 SyntheticWebTouchEvent event;
1858 int id1 = event.PressPoint(1, 1);
1859 event.MovePoint(id1, 1, 1);
1860 int id2 = event.PressPoint(2, 2);
1861 event.MovePoint(id2, 3, 3);
1862
1863 EXPECT_EQ(PassthroughTouchEventQueue::PreFilterResult::kUnfiltered,
1864 FilterBeforeForwarding(event));
1865 }
1866
TEST_F(PassthroughTouchEventQueueTest,NonTouchMoveUnfiltered)1867 TEST_F(PassthroughTouchEventQueueTest, NonTouchMoveUnfiltered) {
1868 OnHasTouchEventHandlers(true);
1869 // Start the touch sequence.
1870 PressTouchPoint(1, 1);
1871
1872 // Non-touchmove events are never filtered.
1873 SyntheticWebTouchEvent event;
1874 int id = event.PressPoint(1, 1);
1875 event.ReleasePoint(id);
1876
1877 EXPECT_EQ(PassthroughTouchEventQueue::PreFilterResult::kUnfiltered,
1878 FilterBeforeForwarding(event));
1879 }
1880
TEST_F(PassthroughTouchEventQueueTest,TouchMoveWithNonTouchMoveUnfiltered)1881 TEST_F(PassthroughTouchEventQueueTest, TouchMoveWithNonTouchMoveUnfiltered) {
1882 OnHasTouchEventHandlers(true);
1883 // Start the touch sequence.
1884 PressTouchPoint(1, 1);
1885 PressTouchPoint(1, 1);
1886
1887 // Non-touchmove events are never filtered, even if they're paired with a
1888 // touchmove event that would otherwise be filtered.
1889 SyntheticWebTouchEvent event;
1890 int id1 = event.PressPoint(1, 1);
1891 event.MovePoint(id1, 1, 1);
1892 int id2 = event.PressPoint(2, 2);
1893 event.ReleasePoint(id2);
1894
1895 EXPECT_EQ(PassthroughTouchEventQueue::PreFilterResult::kUnfiltered,
1896 FilterBeforeForwarding(event));
1897 }
1898
TEST_F(PassthroughTouchEventQueueTest,TouchMoveWithoutSequenceHandlerUnfiltered)1899 TEST_F(PassthroughTouchEventQueueTest,
1900 TouchMoveWithoutSequenceHandlerUnfiltered) {
1901 OnHasTouchEventHandlers(true);
1902 // Start the touch sequence.
1903 PressTouchPoint(1, 1);
1904
1905 // Send an ack indicating that there's no handler for the current sequence.
1906 SendTouchEventAck(blink::mojom::InputEventResultState::kNoConsumerExists);
1907
1908 // Any subsequent touches in the sequence should be unfiltered.
1909 SyntheticWebTouchEvent event;
1910 int id = event.PressPoint(1, 1);
1911 event.MovePoint(id, 3, 3);
1912
1913 EXPECT_EQ(PassthroughTouchEventQueue::PreFilterResult::
1914 kFilteredNoHandlerForSequence,
1915 FilterBeforeForwarding(event));
1916 }
1917
TEST_F(PassthroughTouchEventQueueTest,TouchStartUnfilteredWithForwardDiscrete)1918 TEST_F(PassthroughTouchEventQueueTest,
1919 TouchStartUnfilteredWithForwardDiscrete) {
1920 SetUpForSkipFilterTesting(
1921 blink::features::kSkipTouchEventFilterTypeParamValueDiscrete);
1922
1923 OnHasTouchEventHandlers(false);
1924 SyntheticWebTouchEvent event;
1925 event.PressPoint(1, 1);
1926
1927 EXPECT_EQ(PassthroughTouchEventQueue::PreFilterResult::kUnfiltered,
1928 FilterBeforeForwarding(event));
1929 }
1930
TEST_F(PassthroughTouchEventQueueTest,TouchMoveFilteredWithForwardDiscrete)1931 TEST_F(PassthroughTouchEventQueueTest, TouchMoveFilteredWithForwardDiscrete) {
1932 SetUpForSkipFilterTesting(
1933 blink::features::kSkipTouchEventFilterTypeParamValueDiscrete);
1934
1935 OnHasTouchEventHandlers(false);
1936 // Start the touch sequence.
1937 PressTouchPoint(1, 1);
1938
1939 SyntheticWebTouchEvent event;
1940 int id = event.PressPoint(1, 1);
1941 event.MovePoint(id, 2, 2);
1942
1943 EXPECT_EQ(
1944 PassthroughTouchEventQueue::PreFilterResult::kFilteredNoPageHandlers,
1945 FilterBeforeForwarding(event));
1946 }
1947
TEST_F(PassthroughTouchEventQueueTest,TouchStartUnfilteredWithForwardAll)1948 TEST_F(PassthroughTouchEventQueueTest, TouchStartUnfilteredWithForwardAll) {
1949 SetUpForSkipFilterTesting(
1950 blink::features::kSkipTouchEventFilterTypeParamValueAll);
1951
1952 OnHasTouchEventHandlers(false);
1953 SyntheticWebTouchEvent event;
1954 event.PressPoint(1, 1);
1955
1956 EXPECT_EQ(PassthroughTouchEventQueue::PreFilterResult::kUnfiltered,
1957 FilterBeforeForwarding(event));
1958 }
1959
TEST_F(PassthroughTouchEventQueueTest,TouchMoveUnfilteredWithForwardAll)1960 TEST_F(PassthroughTouchEventQueueTest, TouchMoveUnfilteredWithForwardAll) {
1961 SetUpForSkipFilterTesting(
1962 blink::features::kSkipTouchEventFilterTypeParamValueAll);
1963
1964 OnHasTouchEventHandlers(false);
1965 // Start the touch sequence.
1966 PressTouchPoint(1, 1);
1967
1968 SyntheticWebTouchEvent event;
1969 int id = event.PressPoint(1, 1);
1970 event.MovePoint(id, 2, 2);
1971
1972 EXPECT_EQ(PassthroughTouchEventQueue::PreFilterResult::kUnfiltered,
1973 FilterBeforeForwarding(event));
1974 }
1975
1976 } // namespace content
1977