1 // Copyright 2013 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.
7 #include "base/basictypes.h"
8 #include "base/logging.h"
9 #include "base/memory/scoped_ptr.h"
10 #include "base/message_loop/message_loop.h"
11 #include "base/time/time.h"
12 #include "content/browser/renderer_host/input/gesture_event_filter.h"
13 #include "content/browser/renderer_host/input/touchpad_tap_suppression_controller.h"
14 #include "content/common/input/synthetic_web_input_event_builders.h"
15 #include "content/port/common/input_event_ack_state.h"
16 #include "testing/gtest/include/gtest/gtest.h"
17 #include "third_party/WebKit/public/web/WebInputEvent.h"
19 using base::TimeDelta;
20 using blink::WebGestureEvent;
21 using blink::WebInputEvent;
25 class GestureEventFilterTest : public testing::Test,
26 public GestureEventFilterClient,
27 public TouchpadTapSuppressionControllerClient {
29 GestureEventFilterTest()
30 : acked_gesture_event_count_(0),
31 sent_gesture_event_count_(0) {}
33 virtual ~GestureEventFilterTest() {}
36 virtual void SetUp() OVERRIDE {
37 filter_.reset(new GestureEventFilter(this, this));
40 virtual void TearDown() OVERRIDE {
41 // Process all pending tasks to avoid leaks.
46 // GestureEventFilterClient
47 virtual void SendGestureEventImmediately(
48 const GestureEventWithLatencyInfo& event) OVERRIDE {
49 ++sent_gesture_event_count_;
50 if (sync_ack_result_) {
51 scoped_ptr<InputEventAckState> ack_result = sync_ack_result_.Pass();
52 SendInputEventACK(event.event.type, *ack_result);
56 virtual void OnGestureEventAck(
57 const GestureEventWithLatencyInfo& event,
58 InputEventAckState ack_result) OVERRIDE {
59 ++acked_gesture_event_count_;
60 last_acked_event_ = event.event;
61 if (sync_followup_event_)
62 SimulateGestureEvent(*sync_followup_event_.Pass());
65 // TouchpadTapSuppressionControllerClient
66 virtual void SendMouseEventImmediately(
67 const MouseEventWithLatencyInfo& event) OVERRIDE {
72 // Returns the result of |GestureEventFilter::ShouldForward()|.
73 bool SimulateGestureEvent(const WebGestureEvent& gesture) {
74 GestureEventWithLatencyInfo gesture_with_latency(gesture,
76 if (filter()->ShouldForward(gesture_with_latency)) {
77 SendGestureEventImmediately(gesture_with_latency);
83 void SimulateGestureEvent(WebInputEvent::Type type,
84 WebGestureEvent::SourceDevice sourceDevice) {
86 SyntheticWebGestureEventBuilder::Build(type, sourceDevice));
89 void SimulateGestureScrollUpdateEvent(float dX, float dY, int modifiers) {
91 SyntheticWebGestureEventBuilder::BuildScrollUpdate(dX, dY, modifiers));
94 void SimulateGesturePinchUpdateEvent(float scale,
99 SyntheticWebGestureEventBuilder::BuildPinchUpdate(scale,
105 void SimulateGestureFlingStartEvent(
108 WebGestureEvent::SourceDevice sourceDevice) {
109 SimulateGestureEvent(
110 SyntheticWebGestureEventBuilder::BuildFling(velocityX,
115 void SendInputEventACK(WebInputEvent::Type type,
116 InputEventAckState ack) {
117 filter()->ProcessGestureAck(ack, type, ui::LatencyInfo());
120 void RunUntilIdle() {
121 base::MessageLoop::current()->RunUntilIdle();
124 size_t GetAndResetSentGestureEventCount() {
125 size_t count = sent_gesture_event_count_;
126 sent_gesture_event_count_ = 0;
130 size_t GetAndResetAckedGestureEventCount() {
131 size_t count = acked_gesture_event_count_;
132 acked_gesture_event_count_ = 0;
136 const WebGestureEvent& last_acked_event() const {
137 return last_acked_event_;
140 void DisableDebounce() {
141 filter()->set_debounce_enabled_for_testing(false);
144 void set_debounce_interval_time_ms(int ms) {
145 filter()->set_debounce_interval_time_ms_for_testing(ms);
148 void set_synchronous_ack(InputEventAckState ack_result) {
149 sync_ack_result_.reset(new InputEventAckState(ack_result));
152 void set_sync_followup_event(WebInputEvent::Type type,
153 WebGestureEvent::SourceDevice sourceDevice) {
154 sync_followup_event_.reset(new WebGestureEvent(
155 SyntheticWebGestureEventBuilder::Build(type, sourceDevice)));
158 unsigned GestureEventQueueSize() {
159 return filter()->coalesced_gesture_events_.size();
162 WebGestureEvent GestureEventSecondFromLastQueueEvent() {
163 return filter()->coalesced_gesture_events_.at(
164 GestureEventQueueSize() - 2).event;
167 WebGestureEvent GestureEventLastQueueEvent() {
168 return filter()->coalesced_gesture_events_.back().event;
171 unsigned GestureEventDebouncingQueueSize() {
172 return filter()->debouncing_deferral_queue_.size();
175 WebGestureEvent GestureEventQueueEventAt(int i) {
176 return filter()->coalesced_gesture_events_.at(i).event;
179 bool ScrollingInProgress() {
180 return filter()->scrolling_in_progress_;
183 bool FlingInProgress() {
184 return filter()->fling_in_progress_;
187 bool WillIgnoreNextACK() {
188 return filter()->ignore_next_ack_;
191 GestureEventFilter* filter() const {
192 return filter_.get();
196 scoped_ptr<GestureEventFilter> filter_;
197 size_t acked_gesture_event_count_;
198 size_t sent_gesture_event_count_;
199 WebGestureEvent last_acked_event_;
200 scoped_ptr<InputEventAckState> sync_ack_result_;
201 scoped_ptr<WebGestureEvent> sync_followup_event_;
202 base::MessageLoopForUI message_loop_;
205 #if GTEST_HAS_PARAM_TEST
206 // This is for tests that are to be run for all source devices.
207 class GestureEventFilterWithSourceTest
208 : public GestureEventFilterTest,
209 public testing::WithParamInterface<WebGestureEvent::SourceDevice> {
211 #endif // GTEST_HAS_PARAM_TEST
213 TEST_F(GestureEventFilterTest, CoalescesScrollGestureEvents) {
214 // Turn off debounce handling for test isolation.
217 // Test coalescing of only GestureScrollUpdate events.
218 // Simulate gesture events.
221 SimulateGestureEvent(WebInputEvent::GestureScrollBegin,
222 WebGestureEvent::Touchscreen);
223 EXPECT_EQ(1U, GetAndResetSentGestureEventCount());
226 SimulateGestureScrollUpdateEvent(8, -5, 0);
228 // Make sure that the queue contains what we think it should.
229 WebGestureEvent merged_event = GestureEventLastQueueEvent();
230 EXPECT_EQ(2U, GestureEventQueueSize());
231 EXPECT_EQ(WebInputEvent::GestureScrollUpdate, merged_event.type);
234 SimulateGestureScrollUpdateEvent(8, -6, 0);
236 // Check that coalescing updated the correct values.
237 merged_event = GestureEventLastQueueEvent();
238 EXPECT_EQ(WebInputEvent::GestureScrollUpdate, merged_event.type);
239 EXPECT_EQ(0, merged_event.modifiers);
240 EXPECT_EQ(16, merged_event.data.scrollUpdate.deltaX);
241 EXPECT_EQ(-11, merged_event.data.scrollUpdate.deltaY);
244 SimulateGestureScrollUpdateEvent(8, -7, 1);
246 // Check that we didn't wrongly coalesce.
247 merged_event = GestureEventLastQueueEvent();
248 EXPECT_EQ(WebInputEvent::GestureScrollUpdate, merged_event.type);
249 EXPECT_EQ(1, merged_event.modifiers);
252 SimulateGestureEvent(WebInputEvent::GestureScrollEnd,
253 WebGestureEvent::Touchscreen);
255 // Check that only the first event was sent.
256 EXPECT_EQ(0U, GetAndResetSentGestureEventCount());
258 // Check that the ACK sends the second message.
259 SendInputEventACK(WebInputEvent::GestureScrollBegin,
260 INPUT_EVENT_ACK_STATE_CONSUMED);
262 EXPECT_EQ(1U, GetAndResetAckedGestureEventCount());
263 EXPECT_EQ(1U, GetAndResetSentGestureEventCount());
265 // Ack for queued coalesced event.
266 SendInputEventACK(WebInputEvent::GestureScrollUpdate,
267 INPUT_EVENT_ACK_STATE_CONSUMED);
269 EXPECT_EQ(1U, GetAndResetAckedGestureEventCount());
270 EXPECT_EQ(1U, GetAndResetSentGestureEventCount());
272 // Ack for queued uncoalesced event.
273 SendInputEventACK(WebInputEvent::GestureScrollUpdate,
274 INPUT_EVENT_ACK_STATE_CONSUMED);
276 EXPECT_EQ(1U, GetAndResetAckedGestureEventCount());
277 EXPECT_EQ(1U, GetAndResetSentGestureEventCount());
279 // After the final ack, the queue should be empty.
280 SendInputEventACK(WebInputEvent::GestureScrollEnd,
281 INPUT_EVENT_ACK_STATE_CONSUMED);
283 EXPECT_EQ(1U, GetAndResetAckedGestureEventCount());
284 EXPECT_EQ(0U, GetAndResetSentGestureEventCount());
287 TEST_F(GestureEventFilterTest, CoalescesScrollAndPinchEvents) {
288 // Turn off debounce handling for test isolation.
291 // Test coalescing of only GestureScrollUpdate events.
292 // Simulate gesture events.
295 SimulateGestureEvent(WebInputEvent::GestureScrollBegin,
296 WebGestureEvent::Touchscreen);
299 SimulateGestureEvent(WebInputEvent::GesturePinchBegin,
300 WebGestureEvent::Touchscreen);
303 SimulateGestureScrollUpdateEvent(8, -4, 1);
305 // Make sure that the queue contains what we think it should.
306 WebGestureEvent merged_event = GestureEventLastQueueEvent();
307 EXPECT_EQ(3U, GestureEventQueueSize());
308 EXPECT_EQ(WebInputEvent::GestureScrollUpdate, merged_event.type);
310 // Coalesced without changing event order. Note anchor at (60, 60). Anchoring
311 // from a point that is not the origin should still give us the right scroll.
312 SimulateGesturePinchUpdateEvent(1.5, 60, 60, 1);
313 EXPECT_EQ(4U, GestureEventQueueSize());
314 merged_event = GestureEventLastQueueEvent();
315 EXPECT_EQ(WebInputEvent::GesturePinchUpdate, merged_event.type);
316 EXPECT_EQ(1.5, merged_event.data.pinchUpdate.scale);
317 EXPECT_EQ(1, merged_event.modifiers);
318 merged_event = GestureEventSecondFromLastQueueEvent();
319 EXPECT_EQ(WebInputEvent::GestureScrollUpdate, merged_event.type);
320 EXPECT_EQ(8, merged_event.data.scrollUpdate.deltaX);
321 EXPECT_EQ(-4, merged_event.data.scrollUpdate.deltaY);
322 EXPECT_EQ(1, merged_event.modifiers);
325 SimulateGestureScrollUpdateEvent(6, -3, 1);
327 // Check whether coalesced correctly.
328 EXPECT_EQ(4U, GestureEventQueueSize());
329 merged_event = GestureEventLastQueueEvent();
330 EXPECT_EQ(WebInputEvent::GesturePinchUpdate, merged_event.type);
331 EXPECT_EQ(1.5, merged_event.data.pinchUpdate.scale);
332 EXPECT_EQ(1, merged_event.modifiers);
333 merged_event = GestureEventSecondFromLastQueueEvent();
334 EXPECT_EQ(WebInputEvent::GestureScrollUpdate, merged_event.type);
335 EXPECT_EQ(12, merged_event.data.scrollUpdate.deltaX);
336 EXPECT_EQ(-6, merged_event.data.scrollUpdate.deltaY);
337 EXPECT_EQ(1, merged_event.modifiers);
340 SimulateGesturePinchUpdateEvent(2, 60, 60, 1);
342 // Check whether coalesced correctly.
343 EXPECT_EQ(4U, GestureEventQueueSize());
344 merged_event = GestureEventLastQueueEvent();
345 EXPECT_EQ(WebInputEvent::GesturePinchUpdate, merged_event.type);
346 EXPECT_EQ(3, merged_event.data.pinchUpdate.scale);
347 EXPECT_EQ(1, merged_event.modifiers);
348 merged_event = GestureEventSecondFromLastQueueEvent();
349 EXPECT_EQ(WebInputEvent::GestureScrollUpdate, merged_event.type);
350 EXPECT_EQ(12, merged_event.data.scrollUpdate.deltaX);
351 EXPECT_EQ(-6, merged_event.data.scrollUpdate.deltaY);
352 EXPECT_EQ(1, merged_event.modifiers);
355 SimulateGesturePinchUpdateEvent(2, 60, 60, 1);
357 // Check whether coalesced correctly.
358 EXPECT_EQ(4U, GestureEventQueueSize());
359 merged_event = GestureEventLastQueueEvent();
360 EXPECT_EQ(WebInputEvent::GesturePinchUpdate, merged_event.type);
361 EXPECT_EQ(6, merged_event.data.pinchUpdate.scale);
362 EXPECT_EQ(1, merged_event.modifiers);
363 merged_event = GestureEventSecondFromLastQueueEvent();
364 EXPECT_EQ(WebInputEvent::GestureScrollUpdate, merged_event.type);
365 EXPECT_EQ(12, merged_event.data.scrollUpdate.deltaX);
366 EXPECT_EQ(-6, merged_event.data.scrollUpdate.deltaY);
367 EXPECT_EQ(1, merged_event.modifiers);
369 // Check that only the first event was sent.
370 EXPECT_EQ(1U, GetAndResetSentGestureEventCount());
372 // Check that the ACK sends the second message.
373 SendInputEventACK(WebInputEvent::GestureScrollBegin,
374 INPUT_EVENT_ACK_STATE_CONSUMED);
376 EXPECT_EQ(1U, GetAndResetSentGestureEventCount());
379 SimulateGestureScrollUpdateEvent(6, -6, 1);
381 // Check whether coalesced correctly.
382 EXPECT_EQ(3U, GestureEventQueueSize());
383 merged_event = GestureEventLastQueueEvent();
384 EXPECT_EQ(WebInputEvent::GesturePinchUpdate, merged_event.type);
385 EXPECT_EQ(6, merged_event.data.pinchUpdate.scale);
386 EXPECT_EQ(1, merged_event.modifiers);
387 merged_event = GestureEventSecondFromLastQueueEvent();
388 EXPECT_EQ(WebInputEvent::GestureScrollUpdate, merged_event.type);
389 EXPECT_EQ(13, merged_event.data.scrollUpdate.deltaX);
390 EXPECT_EQ(-7, merged_event.data.scrollUpdate.deltaY);
391 EXPECT_EQ(1, merged_event.modifiers);
393 // At this point ACKs shouldn't be getting ignored.
394 EXPECT_FALSE(WillIgnoreNextACK());
396 // Check that the ACK sends both scroll and pinch updates.
397 SendInputEventACK(WebInputEvent::GesturePinchBegin,
398 INPUT_EVENT_ACK_STATE_CONSUMED);
400 EXPECT_EQ(2U, GetAndResetSentGestureEventCount());
402 // The next ACK should be getting ignored.
403 EXPECT_TRUE(WillIgnoreNextACK());
406 SimulateGestureScrollUpdateEvent(1, -1, 1);
408 // Check whether coalesced correctly.
409 EXPECT_EQ(3U, GestureEventQueueSize());
410 merged_event = GestureEventLastQueueEvent();
411 EXPECT_EQ(WebInputEvent::GestureScrollUpdate, merged_event.type);
412 EXPECT_EQ(1, merged_event.data.scrollUpdate.deltaX);
413 EXPECT_EQ(-1, merged_event.data.scrollUpdate.deltaY);
414 EXPECT_EQ(1, merged_event.modifiers);
415 merged_event = GestureEventSecondFromLastQueueEvent();
416 EXPECT_EQ(WebInputEvent::GesturePinchUpdate, merged_event.type);
417 EXPECT_EQ(6, merged_event.data.pinchUpdate.scale);
418 EXPECT_EQ(1, merged_event.modifiers);
421 SimulateGestureScrollUpdateEvent(2, -2, 1);
423 // Coalescing scrolls should still work.
424 EXPECT_EQ(3U, GestureEventQueueSize());
425 merged_event = GestureEventLastQueueEvent();
426 EXPECT_EQ(WebInputEvent::GestureScrollUpdate, merged_event.type);
427 EXPECT_EQ(3, merged_event.data.scrollUpdate.deltaX);
428 EXPECT_EQ(-3, merged_event.data.scrollUpdate.deltaY);
429 EXPECT_EQ(1, merged_event.modifiers);
430 merged_event = GestureEventSecondFromLastQueueEvent();
431 EXPECT_EQ(WebInputEvent::GesturePinchUpdate, merged_event.type);
432 EXPECT_EQ(6, merged_event.data.pinchUpdate.scale);
433 EXPECT_EQ(1, merged_event.modifiers);
436 SimulateGesturePinchUpdateEvent(0.5, 60, 60, 1);
438 // Check whether coalesced correctly.
439 EXPECT_EQ(4U, GestureEventQueueSize());
440 merged_event = GestureEventLastQueueEvent();
441 EXPECT_EQ(WebInputEvent::GesturePinchUpdate, merged_event.type);
442 EXPECT_EQ(0.5, merged_event.data.pinchUpdate.scale);
443 EXPECT_EQ(1, merged_event.modifiers);
444 merged_event = GestureEventSecondFromLastQueueEvent();
445 EXPECT_EQ(WebInputEvent::GestureScrollUpdate, merged_event.type);
446 EXPECT_EQ(3, merged_event.data.scrollUpdate.deltaX);
447 EXPECT_EQ(-3, merged_event.data.scrollUpdate.deltaY);
448 EXPECT_EQ(1, merged_event.modifiers);
450 // Check that the ACK gets ignored.
451 SendInputEventACK(WebInputEvent::GestureScrollUpdate,
452 INPUT_EVENT_ACK_STATE_CONSUMED);
453 EXPECT_EQ(WebInputEvent::GestureScrollUpdate, last_acked_event().type);
455 EXPECT_EQ(0U, GetAndResetSentGestureEventCount());
456 // The flag should have been flipped back to false.
457 EXPECT_FALSE(WillIgnoreNextACK());
460 SimulateGestureScrollUpdateEvent(2, -2, 2);
462 // Shouldn't coalesce with different modifiers.
463 EXPECT_EQ(4U, GestureEventQueueSize());
464 merged_event = GestureEventLastQueueEvent();
465 EXPECT_EQ(WebInputEvent::GestureScrollUpdate, merged_event.type);
466 EXPECT_EQ(2, merged_event.data.scrollUpdate.deltaX);
467 EXPECT_EQ(-2, merged_event.data.scrollUpdate.deltaY);
468 EXPECT_EQ(2, merged_event.modifiers);
469 merged_event = GestureEventSecondFromLastQueueEvent();
470 EXPECT_EQ(WebInputEvent::GesturePinchUpdate, merged_event.type);
471 EXPECT_EQ(0.5, merged_event.data.pinchUpdate.scale);
472 EXPECT_EQ(1, merged_event.modifiers);
474 // Check that the ACK sends the next scroll pinch pair.
475 SendInputEventACK(WebInputEvent::GesturePinchUpdate,
476 INPUT_EVENT_ACK_STATE_CONSUMED);
477 EXPECT_EQ(WebInputEvent::GesturePinchUpdate, last_acked_event().type);
479 EXPECT_EQ(2U, GetAndResetSentGestureEventCount());
481 // Check that the ACK sends the second message.
482 SendInputEventACK(WebInputEvent::GestureScrollUpdate,
483 INPUT_EVENT_ACK_STATE_CONSUMED);
484 EXPECT_EQ(WebInputEvent::GestureScrollUpdate, last_acked_event().type);
486 EXPECT_EQ(0U, GetAndResetSentGestureEventCount());
488 // Check that the ACK sends the second event.
489 SendInputEventACK(WebInputEvent::GesturePinchUpdate,
490 INPUT_EVENT_ACK_STATE_CONSUMED);
491 EXPECT_EQ(WebInputEvent::GesturePinchUpdate, last_acked_event().type);
493 EXPECT_EQ(1U, GetAndResetSentGestureEventCount());
495 // Check that the queue is empty after ACK and no events get sent.
496 SendInputEventACK(WebInputEvent::GestureScrollUpdate,
497 INPUT_EVENT_ACK_STATE_CONSUMED);
498 EXPECT_EQ(WebInputEvent::GestureScrollUpdate, last_acked_event().type);
500 EXPECT_EQ(0U, GetAndResetSentGestureEventCount());
501 EXPECT_EQ(0U, GestureEventQueueSize());
504 TEST_F(GestureEventFilterTest, CoalescesMultiplePinchEventSequences) {
505 // Turn off debounce handling for test isolation.
508 // Simulate a pinch sequence.
509 SimulateGestureEvent(WebInputEvent::GestureScrollBegin,
510 WebGestureEvent::Touchscreen);
511 SimulateGestureEvent(WebInputEvent::GesturePinchBegin,
512 WebGestureEvent::Touchscreen);
514 SimulateGestureScrollUpdateEvent(8, -4, 1);
515 // Make sure that the queue contains what we think it should.
516 WebGestureEvent merged_event = GestureEventLastQueueEvent();
517 size_t expected_events_in_queue = 3;
518 EXPECT_EQ(expected_events_in_queue, GestureEventQueueSize());
519 EXPECT_EQ(WebInputEvent::GestureScrollUpdate, merged_event.type);
521 // Coalesced without changing event order. Note anchor at (60, 60). Anchoring
522 // from a point that is not the origin should still give us the right scroll.
523 SimulateGesturePinchUpdateEvent(1.5, 60, 60, 1);
524 EXPECT_EQ(++expected_events_in_queue, GestureEventQueueSize());
525 merged_event = GestureEventLastQueueEvent();
526 EXPECT_EQ(WebInputEvent::GesturePinchUpdate, merged_event.type);
527 EXPECT_EQ(1.5, merged_event.data.pinchUpdate.scale);
528 EXPECT_EQ(1, merged_event.modifiers);
529 merged_event = GestureEventSecondFromLastQueueEvent();
530 EXPECT_EQ(WebInputEvent::GestureScrollUpdate, merged_event.type);
531 EXPECT_EQ(8, merged_event.data.scrollUpdate.deltaX);
532 EXPECT_EQ(-4, merged_event.data.scrollUpdate.deltaY);
533 EXPECT_EQ(1, merged_event.modifiers);
536 SimulateGestureScrollUpdateEvent(6, -3, 1);
538 // Check whether coalesced correctly.
539 EXPECT_EQ(expected_events_in_queue, GestureEventQueueSize());
540 merged_event = GestureEventLastQueueEvent();
541 EXPECT_EQ(WebInputEvent::GesturePinchUpdate, merged_event.type);
542 EXPECT_EQ(1.5, merged_event.data.pinchUpdate.scale);
543 EXPECT_EQ(1, merged_event.modifiers);
544 merged_event = GestureEventSecondFromLastQueueEvent();
545 EXPECT_EQ(WebInputEvent::GestureScrollUpdate, merged_event.type);
546 EXPECT_EQ(12, merged_event.data.scrollUpdate.deltaX);
547 EXPECT_EQ(-6, merged_event.data.scrollUpdate.deltaY);
548 EXPECT_EQ(1, merged_event.modifiers);
550 // Now start another sequence before the previous sequence has been ack'ed.
551 SimulateGestureEvent(WebInputEvent::GesturePinchEnd,
552 WebGestureEvent::Touchscreen);
553 SimulateGestureEvent(WebInputEvent::GestureScrollEnd,
554 WebGestureEvent::Touchscreen);
555 SimulateGestureEvent(WebInputEvent::GestureScrollBegin,
556 WebGestureEvent::Touchscreen);
557 SimulateGestureEvent(WebInputEvent::GesturePinchBegin,
558 WebGestureEvent::Touchscreen);
560 SimulateGestureScrollUpdateEvent(8, -4, 1);
561 // Make sure that the queue contains what we think it should.
562 expected_events_in_queue += 5;
563 merged_event = GestureEventLastQueueEvent();
564 EXPECT_EQ(expected_events_in_queue, GestureEventQueueSize());
565 EXPECT_EQ(WebInputEvent::GestureScrollUpdate, merged_event.type);
567 // Coalesced without changing event order. Note anchor at (60, 60). Anchoring
568 // from a point that is not the origin should still give us the right scroll.
569 SimulateGesturePinchUpdateEvent(1.5, 30, 30, 1);
570 EXPECT_EQ(++expected_events_in_queue, GestureEventQueueSize());
571 merged_event = GestureEventLastQueueEvent();
572 EXPECT_EQ(WebInputEvent::GesturePinchUpdate, merged_event.type);
573 EXPECT_EQ(1.5, merged_event.data.pinchUpdate.scale);
574 EXPECT_EQ(1, merged_event.modifiers);
575 merged_event = GestureEventSecondFromLastQueueEvent();
576 EXPECT_EQ(WebInputEvent::GestureScrollUpdate, merged_event.type);
577 EXPECT_EQ(8, merged_event.data.scrollUpdate.deltaX);
578 EXPECT_EQ(-4, merged_event.data.scrollUpdate.deltaY);
579 EXPECT_EQ(1, merged_event.modifiers);
582 SimulateGestureScrollUpdateEvent(6, -3, 1);
584 // Check whether coalesced correctly.
585 EXPECT_EQ(expected_events_in_queue, GestureEventQueueSize());
586 merged_event = GestureEventLastQueueEvent();
587 EXPECT_EQ(WebInputEvent::GesturePinchUpdate, merged_event.type);
588 EXPECT_EQ(1.5, merged_event.data.pinchUpdate.scale);
589 EXPECT_EQ(1, merged_event.modifiers);
590 merged_event = GestureEventSecondFromLastQueueEvent();
591 EXPECT_EQ(WebInputEvent::GestureScrollUpdate, merged_event.type);
592 EXPECT_EQ(12, merged_event.data.scrollUpdate.deltaX);
593 EXPECT_EQ(-6, merged_event.data.scrollUpdate.deltaY);
594 EXPECT_EQ(1, merged_event.modifiers);
597 // Tests a single event with an synchronous ack.
598 TEST_F(GestureEventFilterTest, SimpleSyncAck) {
599 set_synchronous_ack(INPUT_EVENT_ACK_STATE_CONSUMED);
600 SimulateGestureEvent(WebInputEvent::GestureTapDown,
601 WebGestureEvent::Touchscreen);
602 EXPECT_EQ(1U, GetAndResetSentGestureEventCount());
603 EXPECT_EQ(0U, GestureEventQueueSize());
604 EXPECT_EQ(1U, GetAndResetAckedGestureEventCount());
607 // Tests an event with an synchronous ack which enqueues an additional event.
608 TEST_F(GestureEventFilterTest, SyncAckQueuesEvent) {
609 scoped_ptr<WebGestureEvent> queued_event;
610 set_synchronous_ack(INPUT_EVENT_ACK_STATE_CONSUMED);
611 set_sync_followup_event(WebInputEvent::GestureShowPress,
612 WebGestureEvent::Touchscreen);
613 // This event enqueues the show press event.
614 SimulateGestureEvent(WebInputEvent::GestureTapDown,
615 WebGestureEvent::Touchscreen);
616 EXPECT_EQ(2U, GetAndResetSentGestureEventCount());
617 EXPECT_EQ(1U, GestureEventQueueSize());
618 EXPECT_EQ(1U, GetAndResetAckedGestureEventCount());
620 SendInputEventACK(WebInputEvent::GestureShowPress,
621 INPUT_EVENT_ACK_STATE_CONSUMED);
622 EXPECT_EQ(0U, GetAndResetSentGestureEventCount());
623 EXPECT_EQ(0U, GestureEventQueueSize());
624 EXPECT_EQ(1U, GetAndResetAckedGestureEventCount());
627 // Tests an event with an async ack followed by an event with a sync ack.
628 TEST_F(GestureEventFilterTest, AsyncThenSyncAck) {
629 // Turn off debounce handling for test isolation.
632 SimulateGestureEvent(WebInputEvent::GestureTapDown,
633 WebGestureEvent::Touchscreen);
635 EXPECT_EQ(1U, GetAndResetSentGestureEventCount());
636 EXPECT_EQ(1U, GestureEventQueueSize());
637 EXPECT_EQ(0U, GetAndResetAckedGestureEventCount());
639 SimulateGestureEvent(WebInputEvent::GestureScrollBegin,
640 WebGestureEvent::Touchscreen);
641 set_synchronous_ack(INPUT_EVENT_ACK_STATE_CONSUMED);
642 EXPECT_EQ(0U, GetAndResetSentGestureEventCount());
643 EXPECT_EQ(2U, GestureEventQueueSize());
644 EXPECT_EQ(0U, GetAndResetAckedGestureEventCount());
646 SendInputEventACK(WebInputEvent::GestureTapDown,
647 INPUT_EVENT_ACK_STATE_CONSUMED);
648 EXPECT_EQ(1U, GetAndResetSentGestureEventCount());
649 EXPECT_EQ(0U, GestureEventQueueSize());
650 EXPECT_EQ(2U, GetAndResetAckedGestureEventCount());
653 TEST_F(GestureEventFilterTest, CoalescesScrollAndPinchEventWithSyncAck) {
654 // Turn off debounce handling for test isolation.
657 // Simulate a pinch sequence.
658 SimulateGestureEvent(WebInputEvent::GestureScrollBegin,
659 WebGestureEvent::Touchscreen);
660 EXPECT_EQ(1U, GetAndResetSentGestureEventCount());
661 SimulateGestureEvent(WebInputEvent::GesturePinchBegin,
662 WebGestureEvent::Touchscreen);
663 EXPECT_EQ(0U, GetAndResetSentGestureEventCount());
665 SimulateGestureScrollUpdateEvent(8, -4, 1);
666 // Make sure that the queue contains what we think it should.
667 WebGestureEvent merged_event = GestureEventLastQueueEvent();
668 EXPECT_EQ(3U, GestureEventQueueSize());
669 EXPECT_EQ(WebInputEvent::GestureScrollUpdate, merged_event.type);
671 // Coalesced without changing event order. Note anchor at (60, 60). Anchoring
672 // from a point that is not the origin should still give us the right scroll.
673 SimulateGesturePinchUpdateEvent(1.5, 60, 60, 1);
674 EXPECT_EQ(4U, GestureEventQueueSize());
676 SendInputEventACK(WebInputEvent::GestureScrollBegin,
677 INPUT_EVENT_ACK_STATE_CONSUMED);
678 EXPECT_EQ(1U, GetAndResetSentGestureEventCount());
679 EXPECT_EQ(3U, GestureEventQueueSize());
681 // Ack the PinchBegin, and schedule a synchronous ack for GestureScrollUpdate.
682 set_synchronous_ack(INPUT_EVENT_ACK_STATE_CONSUMED);
683 SendInputEventACK(WebInputEvent::GesturePinchBegin,
684 INPUT_EVENT_ACK_STATE_CONSUMED);
686 // Both GestureScrollUpdate and GesturePinchUpdate should have been sent.
687 EXPECT_EQ(WebInputEvent::GestureScrollUpdate, last_acked_event().type);
688 EXPECT_EQ(1U, GestureEventQueueSize());
689 EXPECT_EQ(2U, GetAndResetSentGestureEventCount());
691 // Ack the final GesturePinchUpdate.
692 SendInputEventACK(WebInputEvent::GesturePinchUpdate,
693 INPUT_EVENT_ACK_STATE_CONSUMED);
694 EXPECT_EQ(WebInputEvent::GesturePinchUpdate, last_acked_event().type);
695 EXPECT_EQ(0U, GestureEventQueueSize());
696 EXPECT_EQ(0U, GetAndResetSentGestureEventCount());
699 #if GTEST_HAS_PARAM_TEST
700 TEST_P(GestureEventFilterWithSourceTest, GestureFlingCancelsFiltered) {
701 WebGestureEvent::SourceDevice source_device = GetParam();
703 // Turn off debounce handling for test isolation.
705 // GFC without previous GFS is dropped.
706 SimulateGestureEvent(WebInputEvent::GestureFlingCancel, source_device);
707 EXPECT_EQ(0U, GetAndResetSentGestureEventCount());
708 EXPECT_EQ(0U, GestureEventQueueSize());
710 // GFC after previous GFS is dispatched and acked.
711 SimulateGestureFlingStartEvent(0, -10, source_device);
712 EXPECT_TRUE(FlingInProgress());
713 SendInputEventACK(WebInputEvent::GestureFlingStart,
714 INPUT_EVENT_ACK_STATE_CONSUMED);
716 EXPECT_EQ(1U, GetAndResetAckedGestureEventCount());
717 SimulateGestureEvent(WebInputEvent::GestureFlingCancel, source_device);
718 EXPECT_FALSE(FlingInProgress());
719 EXPECT_EQ(2U, GetAndResetSentGestureEventCount());
720 SendInputEventACK(WebInputEvent::GestureFlingCancel,
721 INPUT_EVENT_ACK_STATE_CONSUMED);
723 EXPECT_EQ(1U, GetAndResetAckedGestureEventCount());
724 EXPECT_EQ(0U, GestureEventQueueSize());
726 // GFC before previous GFS is acked.
727 SimulateGestureFlingStartEvent(0, -10, source_device);
728 EXPECT_TRUE(FlingInProgress());
729 SimulateGestureEvent(WebInputEvent::GestureFlingCancel, source_device);
730 EXPECT_FALSE(FlingInProgress());
731 EXPECT_EQ(1U, GetAndResetSentGestureEventCount());
732 EXPECT_EQ(2U, GestureEventQueueSize());
734 // Advance state realistically.
735 SendInputEventACK(WebInputEvent::GestureFlingStart,
736 INPUT_EVENT_ACK_STATE_CONSUMED);
738 EXPECT_EQ(1U, GetAndResetSentGestureEventCount());
739 SendInputEventACK(WebInputEvent::GestureFlingCancel,
740 INPUT_EVENT_ACK_STATE_CONSUMED);
742 EXPECT_EQ(2U, GetAndResetAckedGestureEventCount());
743 EXPECT_EQ(0U, GetAndResetSentGestureEventCount());
744 EXPECT_EQ(0U, GestureEventQueueSize());
746 // GFS is added to the queue if another event is pending
747 SimulateGestureScrollUpdateEvent(8, -7, 0);
748 SimulateGestureFlingStartEvent(0, -10, source_device);
749 EXPECT_EQ(2U, GestureEventQueueSize());
750 EXPECT_EQ(1U, GetAndResetSentGestureEventCount());
751 WebGestureEvent merged_event = GestureEventLastQueueEvent();
752 EXPECT_EQ(WebInputEvent::GestureFlingStart, merged_event.type);
753 EXPECT_TRUE(FlingInProgress());
754 EXPECT_EQ(2U, GestureEventQueueSize());
756 // GFS in queue means that a GFC is added to the queue
757 SimulateGestureEvent(WebInputEvent::GestureFlingCancel, source_device);
758 merged_event =GestureEventLastQueueEvent();
759 EXPECT_EQ(WebInputEvent::GestureFlingCancel, merged_event.type);
760 EXPECT_FALSE(FlingInProgress());
761 EXPECT_EQ(3U, GestureEventQueueSize());
763 // Adding a second GFC is dropped.
764 SimulateGestureEvent(WebInputEvent::GestureFlingCancel, source_device);
765 EXPECT_FALSE(FlingInProgress());
766 EXPECT_EQ(3U, GestureEventQueueSize());
768 // Adding another GFS will add it to the queue.
769 SimulateGestureFlingStartEvent(0, -10, source_device);
770 merged_event = GestureEventLastQueueEvent();
771 EXPECT_EQ(WebInputEvent::GestureFlingStart, merged_event.type);
772 EXPECT_TRUE(FlingInProgress());
773 EXPECT_EQ(4U, GestureEventQueueSize());
775 // GFS in queue means that a GFC is added to the queue
776 SimulateGestureEvent(WebInputEvent::GestureFlingCancel, source_device);
777 merged_event = GestureEventLastQueueEvent();
778 EXPECT_EQ(WebInputEvent::GestureFlingCancel, merged_event.type);
779 EXPECT_FALSE(FlingInProgress());
780 EXPECT_EQ(5U, GestureEventQueueSize());
782 // Adding another GFC with a GFC already there is dropped.
783 SimulateGestureEvent(WebInputEvent::GestureFlingCancel, source_device);
784 merged_event = GestureEventLastQueueEvent();
785 EXPECT_EQ(WebInputEvent::GestureFlingCancel, merged_event.type);
786 EXPECT_FALSE(FlingInProgress());
787 EXPECT_EQ(5U, GestureEventQueueSize());
790 INSTANTIATE_TEST_CASE_P(AllSources,
791 GestureEventFilterWithSourceTest,
792 testing::Values(WebGestureEvent::Touchscreen,
793 WebGestureEvent::Touchpad));
794 #endif // GTEST_HAS_PARAM_TEST
796 // Test that a GestureScrollEnd | GestureFlingStart are deferred during the
797 // debounce interval, that Scrolls are not and that the deferred events are
798 // sent after that timer fires.
799 TEST_F(GestureEventFilterTest, DebounceDefersFollowingGestureEvents) {
800 set_debounce_interval_time_ms(3);
802 SimulateGestureEvent(WebInputEvent::GestureScrollUpdate,
803 WebGestureEvent::Touchscreen);
804 EXPECT_EQ(1U, GetAndResetSentGestureEventCount());
805 EXPECT_EQ(1U, GestureEventQueueSize());
806 EXPECT_EQ(0U, GestureEventDebouncingQueueSize());
807 EXPECT_TRUE(ScrollingInProgress());
809 SimulateGestureEvent(WebInputEvent::GestureScrollUpdate,
810 WebGestureEvent::Touchscreen);
811 EXPECT_EQ(0U, GetAndResetSentGestureEventCount());
812 EXPECT_EQ(2U, GestureEventQueueSize());
813 EXPECT_EQ(0U, GestureEventDebouncingQueueSize());
814 EXPECT_TRUE(ScrollingInProgress());
816 SimulateGestureEvent(WebInputEvent::GestureScrollEnd,
817 WebGestureEvent::Touchscreen);
818 EXPECT_EQ(0U, GetAndResetSentGestureEventCount());
819 EXPECT_EQ(2U, GestureEventQueueSize());
820 EXPECT_EQ(1U, GestureEventDebouncingQueueSize());
822 SimulateGestureFlingStartEvent(0, 10, WebGestureEvent::Touchscreen);
823 EXPECT_EQ(0U, GetAndResetSentGestureEventCount());
824 EXPECT_EQ(2U, GestureEventQueueSize());
825 EXPECT_EQ(2U, GestureEventDebouncingQueueSize());
827 SimulateGestureEvent(WebInputEvent::GestureTapDown,
828 WebGestureEvent::Touchscreen);
829 EXPECT_EQ(0U, GetAndResetSentGestureEventCount());
830 EXPECT_EQ(2U, GestureEventQueueSize());
831 EXPECT_EQ(3U, GestureEventDebouncingQueueSize());
833 base::MessageLoop::current()->PostDelayedTask(
835 base::MessageLoop::QuitClosure(),
836 TimeDelta::FromMilliseconds(5));
837 base::MessageLoop::current()->Run();
839 // The deferred events are correctly queued in coalescing queue.
840 EXPECT_EQ(0U, GetAndResetSentGestureEventCount());
841 EXPECT_EQ(5U, GestureEventQueueSize());
842 EXPECT_EQ(0U, GestureEventDebouncingQueueSize());
843 EXPECT_FALSE(ScrollingInProgress());
845 // Verify that the coalescing queue contains the correct events.
846 WebInputEvent::Type expected[] = {
847 WebInputEvent::GestureScrollUpdate,
848 WebInputEvent::GestureScrollUpdate,
849 WebInputEvent::GestureScrollEnd,
850 WebInputEvent::GestureFlingStart};
852 for (unsigned i = 0; i < sizeof(expected) / sizeof(WebInputEvent::Type);
854 WebGestureEvent merged_event = GestureEventQueueEventAt(i);
855 EXPECT_EQ(expected[i], merged_event.type);
859 // Test that non-scroll events are deferred while scrolling during the debounce
860 // interval and are discarded if a GestureScrollUpdate event arrives before the
862 TEST_F(GestureEventFilterTest, DebounceDropsDeferredEvents) {
863 set_debounce_interval_time_ms(3);
864 EXPECT_FALSE(ScrollingInProgress());
866 SimulateGestureEvent(WebInputEvent::GestureScrollUpdate,
867 WebGestureEvent::Touchscreen);
868 EXPECT_EQ(1U, GetAndResetSentGestureEventCount());
869 EXPECT_EQ(1U, GestureEventQueueSize());
870 EXPECT_EQ(0U, GestureEventDebouncingQueueSize());
871 EXPECT_TRUE(ScrollingInProgress());
873 // This event should get discarded.
874 SimulateGestureEvent(WebInputEvent::GestureScrollEnd,
875 WebGestureEvent::Touchscreen);
876 EXPECT_EQ(0U, GetAndResetSentGestureEventCount());
877 EXPECT_EQ(1U, GestureEventQueueSize());
878 EXPECT_EQ(1U, GestureEventDebouncingQueueSize());
880 SimulateGestureEvent(WebInputEvent::GestureScrollUpdate,
881 WebGestureEvent::Touchscreen);
882 EXPECT_EQ(0U, GetAndResetSentGestureEventCount());
883 EXPECT_EQ(2U, GestureEventQueueSize());
884 EXPECT_EQ(0U, GestureEventDebouncingQueueSize());
885 EXPECT_TRUE(ScrollingInProgress());
887 // Verify that the coalescing queue contains the correct events.
888 WebInputEvent::Type expected[] = {
889 WebInputEvent::GestureScrollUpdate,
890 WebInputEvent::GestureScrollUpdate};
892 for (unsigned i = 0; i < sizeof(expected) / sizeof(WebInputEvent::Type);
894 WebGestureEvent merged_event = GestureEventQueueEventAt(i);
895 EXPECT_EQ(expected[i], merged_event.type);
899 TEST_F(GestureEventFilterTest, DropZeroVelocityFlings) {
900 WebGestureEvent gesture_event;
901 gesture_event.type = WebInputEvent::GestureFlingStart;
902 gesture_event.sourceDevice = WebGestureEvent::Touchpad;
903 gesture_event.data.flingStart.velocityX = 0.f;
904 gesture_event.data.flingStart.velocityY = 0.f;
905 ASSERT_EQ(0U, GetAndResetSentGestureEventCount());
906 ASSERT_EQ(0U, GestureEventQueueSize());
907 EXPECT_FALSE(SimulateGestureEvent(gesture_event));
908 EXPECT_EQ(0U, GetAndResetSentGestureEventCount());
909 EXPECT_EQ(0U, GestureEventQueueSize());
912 } // namespace content