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.
4
5#include <vector>
6
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"
18
19using base::TimeDelta;
20using blink::WebGestureEvent;
21using blink::WebInputEvent;
22
23namespace content {
24
25class GestureEventFilterTest : public testing::Test,
26                               public GestureEventFilterClient,
27                               public TouchpadTapSuppressionControllerClient {
28 public:
29  GestureEventFilterTest()
30      : acked_gesture_event_count_(0),
31        sent_gesture_event_count_(0) {}
32
33  virtual ~GestureEventFilterTest() {}
34
35  // testing::Test
36  virtual void SetUp() OVERRIDE {
37    filter_.reset(new GestureEventFilter(this, this));
38  }
39
40  virtual void TearDown() OVERRIDE {
41    // Process all pending tasks to avoid leaks.
42    RunUntilIdle();
43    filter_.reset();
44  }
45
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);
53    }
54  }
55
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());
63  }
64
65  // TouchpadTapSuppressionControllerClient
66  virtual void SendMouseEventImmediately(
67      const MouseEventWithLatencyInfo& event) OVERRIDE {
68  }
69
70 protected:
71
72  // Returns the result of |GestureEventFilter::ShouldForward()|.
73  bool SimulateGestureEvent(const WebGestureEvent& gesture) {
74    GestureEventWithLatencyInfo gesture_with_latency(gesture,
75                                                     ui::LatencyInfo());
76    if (filter()->ShouldForward(gesture_with_latency)) {
77      SendGestureEventImmediately(gesture_with_latency);
78      return true;
79    }
80    return false;
81  }
82
83  void SimulateGestureEvent(WebInputEvent::Type type,
84                            WebGestureEvent::SourceDevice sourceDevice) {
85    SimulateGestureEvent(
86        SyntheticWebGestureEventBuilder::Build(type, sourceDevice));
87  }
88
89  void SimulateGestureScrollUpdateEvent(float dX, float dY, int modifiers) {
90    SimulateGestureEvent(
91        SyntheticWebGestureEventBuilder::BuildScrollUpdate(dX, dY, modifiers));
92  }
93
94  void SimulateGesturePinchUpdateEvent(float scale,
95                                       float anchorX,
96                                       float anchorY,
97                                       int modifiers) {
98    SimulateGestureEvent(
99        SyntheticWebGestureEventBuilder::BuildPinchUpdate(scale,
100                                                          anchorX,
101                                                          anchorY,
102                                                          modifiers));
103  }
104
105  void SimulateGestureFlingStartEvent(
106      float velocityX,
107      float velocityY,
108      WebGestureEvent::SourceDevice sourceDevice) {
109    SimulateGestureEvent(
110        SyntheticWebGestureEventBuilder::BuildFling(velocityX,
111                                                    velocityY,
112                                                    sourceDevice));
113  }
114
115  void SendInputEventACK(WebInputEvent::Type type,
116                         InputEventAckState ack) {
117    filter()->ProcessGestureAck(ack, type, ui::LatencyInfo());
118  }
119
120  void RunUntilIdle() {
121    base::MessageLoop::current()->RunUntilIdle();
122  }
123
124  size_t GetAndResetSentGestureEventCount() {
125    size_t count = sent_gesture_event_count_;
126    sent_gesture_event_count_ = 0;
127    return count;
128  }
129
130  size_t GetAndResetAckedGestureEventCount() {
131    size_t count = acked_gesture_event_count_;
132    acked_gesture_event_count_ = 0;
133    return count;
134  }
135
136  const WebGestureEvent& last_acked_event() const {
137    return last_acked_event_;
138  }
139
140  void DisableDebounce() {
141    filter()->set_debounce_enabled_for_testing(false);
142  }
143
144  void set_debounce_interval_time_ms(int ms) {
145    filter()->set_debounce_interval_time_ms_for_testing(ms);
146  }
147
148  void set_synchronous_ack(InputEventAckState ack_result) {
149    sync_ack_result_.reset(new InputEventAckState(ack_result));
150  }
151
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)));
156  }
157
158  unsigned GestureEventQueueSize() {
159    return filter()->coalesced_gesture_events_.size();
160  }
161
162  WebGestureEvent GestureEventSecondFromLastQueueEvent() {
163    return filter()->coalesced_gesture_events_.at(
164        GestureEventQueueSize() - 2).event;
165  }
166
167  WebGestureEvent GestureEventLastQueueEvent() {
168    return filter()->coalesced_gesture_events_.back().event;
169  }
170
171  unsigned GestureEventDebouncingQueueSize() {
172    return filter()->debouncing_deferral_queue_.size();
173  }
174
175  WebGestureEvent GestureEventQueueEventAt(int i) {
176    return filter()->coalesced_gesture_events_.at(i).event;
177  }
178
179  bool ScrollingInProgress() {
180    return filter()->scrolling_in_progress_;
181  }
182
183  bool FlingInProgress() {
184    return filter()->fling_in_progress_;
185  }
186
187  bool WillIgnoreNextACK() {
188    return filter()->ignore_next_ack_;
189  }
190
191  GestureEventFilter* filter() const {
192    return filter_.get();
193  }
194
195 private:
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_;
203};
204
205#if GTEST_HAS_PARAM_TEST
206// This is for tests that are to be run for all source devices.
207class GestureEventFilterWithSourceTest
208    : public GestureEventFilterTest,
209      public testing::WithParamInterface<WebGestureEvent::SourceDevice> {
210};
211#endif  // GTEST_HAS_PARAM_TEST
212
213TEST_F(GestureEventFilterTest, CoalescesScrollGestureEvents) {
214  // Turn off debounce handling for test isolation.
215  DisableDebounce();
216
217  // Test coalescing of only GestureScrollUpdate events.
218  // Simulate gesture events.
219
220  // Sent.
221  SimulateGestureEvent(WebInputEvent::GestureScrollBegin,
222                       WebGestureEvent::Touchscreen);
223  EXPECT_EQ(1U, GetAndResetSentGestureEventCount());
224
225  // Enqueued.
226  SimulateGestureScrollUpdateEvent(8, -5, 0);
227
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);
232
233  // Coalesced.
234  SimulateGestureScrollUpdateEvent(8, -6, 0);
235
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);
242
243  // Enqueued.
244  SimulateGestureScrollUpdateEvent(8, -7, 1);
245
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);
250
251  // Different.
252  SimulateGestureEvent(WebInputEvent::GestureScrollEnd,
253                       WebGestureEvent::Touchscreen);
254
255  // Check that only the first event was sent.
256  EXPECT_EQ(0U, GetAndResetSentGestureEventCount());
257
258  // Check that the ACK sends the second message.
259  SendInputEventACK(WebInputEvent::GestureScrollBegin,
260                    INPUT_EVENT_ACK_STATE_CONSUMED);
261  RunUntilIdle();
262  EXPECT_EQ(1U, GetAndResetAckedGestureEventCount());
263  EXPECT_EQ(1U, GetAndResetSentGestureEventCount());
264
265  // Ack for queued coalesced event.
266  SendInputEventACK(WebInputEvent::GestureScrollUpdate,
267                    INPUT_EVENT_ACK_STATE_CONSUMED);
268  RunUntilIdle();
269  EXPECT_EQ(1U, GetAndResetAckedGestureEventCount());
270  EXPECT_EQ(1U, GetAndResetSentGestureEventCount());
271
272  // Ack for queued uncoalesced event.
273  SendInputEventACK(WebInputEvent::GestureScrollUpdate,
274                    INPUT_EVENT_ACK_STATE_CONSUMED);
275  RunUntilIdle();
276  EXPECT_EQ(1U, GetAndResetAckedGestureEventCount());
277  EXPECT_EQ(1U, GetAndResetSentGestureEventCount());
278
279  // After the final ack, the queue should be empty.
280  SendInputEventACK(WebInputEvent::GestureScrollEnd,
281                    INPUT_EVENT_ACK_STATE_CONSUMED);
282  RunUntilIdle();
283  EXPECT_EQ(1U, GetAndResetAckedGestureEventCount());
284  EXPECT_EQ(0U, GetAndResetSentGestureEventCount());
285}
286
287TEST_F(GestureEventFilterTest, CoalescesScrollAndPinchEvents) {
288  // Turn off debounce handling for test isolation.
289  DisableDebounce();
290
291  // Test coalescing of only GestureScrollUpdate events.
292  // Simulate gesture events.
293
294  // Sent.
295  SimulateGestureEvent(WebInputEvent::GestureScrollBegin,
296                       WebGestureEvent::Touchscreen);
297
298  // Sent.
299  SimulateGestureEvent(WebInputEvent::GesturePinchBegin,
300                       WebGestureEvent::Touchscreen);
301
302  // Enqueued.
303  SimulateGestureScrollUpdateEvent(8, -4, 1);
304
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);
309
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);
323
324  // Enqueued.
325  SimulateGestureScrollUpdateEvent(6, -3, 1);
326
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);
338
339  // Enqueued.
340  SimulateGesturePinchUpdateEvent(2, 60, 60, 1);
341
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);
353
354  // Enqueued.
355  SimulateGesturePinchUpdateEvent(2, 60, 60, 1);
356
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);
368
369  // Check that only the first event was sent.
370  EXPECT_EQ(1U, GetAndResetSentGestureEventCount());
371
372  // Check that the ACK sends the second message.
373  SendInputEventACK(WebInputEvent::GestureScrollBegin,
374                    INPUT_EVENT_ACK_STATE_CONSUMED);
375  RunUntilIdle();
376  EXPECT_EQ(1U, GetAndResetSentGestureEventCount());
377
378  // Enqueued.
379  SimulateGestureScrollUpdateEvent(6, -6, 1);
380
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);
392
393  // At this point ACKs shouldn't be getting ignored.
394  EXPECT_FALSE(WillIgnoreNextACK());
395
396  // Check that the ACK sends both scroll and pinch updates.
397  SendInputEventACK(WebInputEvent::GesturePinchBegin,
398                    INPUT_EVENT_ACK_STATE_CONSUMED);
399  RunUntilIdle();
400  EXPECT_EQ(2U, GetAndResetSentGestureEventCount());
401
402  // The next ACK should be getting ignored.
403  EXPECT_TRUE(WillIgnoreNextACK());
404
405  // Enqueued.
406  SimulateGestureScrollUpdateEvent(1, -1, 1);
407
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);
419
420  // Enqueued.
421  SimulateGestureScrollUpdateEvent(2, -2, 1);
422
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);
434
435  // Enqueued.
436  SimulateGesturePinchUpdateEvent(0.5, 60, 60, 1);
437
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);
449
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);
454  RunUntilIdle();
455  EXPECT_EQ(0U, GetAndResetSentGestureEventCount());
456  // The flag should have been flipped back to false.
457  EXPECT_FALSE(WillIgnoreNextACK());
458
459  // Enqueued.
460  SimulateGestureScrollUpdateEvent(2, -2, 2);
461
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);
473
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);
478  RunUntilIdle();
479  EXPECT_EQ(2U, GetAndResetSentGestureEventCount());
480
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);
485  RunUntilIdle();
486  EXPECT_EQ(0U, GetAndResetSentGestureEventCount());
487
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);
492  RunUntilIdle();
493  EXPECT_EQ(1U, GetAndResetSentGestureEventCount());
494
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);
499  RunUntilIdle();
500  EXPECT_EQ(0U, GetAndResetSentGestureEventCount());
501  EXPECT_EQ(0U, GestureEventQueueSize());
502}
503
504TEST_F(GestureEventFilterTest, CoalescesMultiplePinchEventSequences) {
505  // Turn off debounce handling for test isolation.
506  DisableDebounce();
507
508  // Simulate a pinch sequence.
509  SimulateGestureEvent(WebInputEvent::GestureScrollBegin,
510                       WebGestureEvent::Touchscreen);
511  SimulateGestureEvent(WebInputEvent::GesturePinchBegin,
512                       WebGestureEvent::Touchscreen);
513
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);
520
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);
534
535  // Enqueued.
536  SimulateGestureScrollUpdateEvent(6, -3, 1);
537
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);
549
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);
559
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);
566
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);
580
581  // Enqueued.
582  SimulateGestureScrollUpdateEvent(6, -3, 1);
583
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);
595}
596
597// Tests a single event with an synchronous ack.
598TEST_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());
605}
606
607// Tests an event with an synchronous ack which enqueues an additional event.
608TEST_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());
619
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());
625}
626
627// Tests an event with an async ack followed by an event with a sync ack.
628TEST_F(GestureEventFilterTest, AsyncThenSyncAck) {
629  // Turn off debounce handling for test isolation.
630  DisableDebounce();
631
632  SimulateGestureEvent(WebInputEvent::GestureTapDown,
633                       WebGestureEvent::Touchscreen);
634
635  EXPECT_EQ(1U, GetAndResetSentGestureEventCount());
636  EXPECT_EQ(1U, GestureEventQueueSize());
637  EXPECT_EQ(0U, GetAndResetAckedGestureEventCount());
638
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());
645
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());
651}
652
653TEST_F(GestureEventFilterTest, CoalescesScrollAndPinchEventWithSyncAck) {
654  // Turn off debounce handling for test isolation.
655  DisableDebounce();
656
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());
664
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);
670
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());
675
676  SendInputEventACK(WebInputEvent::GestureScrollBegin,
677                    INPUT_EVENT_ACK_STATE_CONSUMED);
678  EXPECT_EQ(1U, GetAndResetSentGestureEventCount());
679  EXPECT_EQ(3U, GestureEventQueueSize());
680
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);
685
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());
690
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());
697}
698
699#if GTEST_HAS_PARAM_TEST
700TEST_P(GestureEventFilterWithSourceTest, GestureFlingCancelsFiltered) {
701  WebGestureEvent::SourceDevice source_device = GetParam();
702
703  // Turn off debounce handling for test isolation.
704  DisableDebounce();
705  // GFC without previous GFS is dropped.
706  SimulateGestureEvent(WebInputEvent::GestureFlingCancel, source_device);
707  EXPECT_EQ(0U, GetAndResetSentGestureEventCount());
708  EXPECT_EQ(0U, GestureEventQueueSize());
709
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);
715  RunUntilIdle();
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);
722  RunUntilIdle();
723  EXPECT_EQ(1U, GetAndResetAckedGestureEventCount());
724  EXPECT_EQ(0U, GestureEventQueueSize());
725
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());
733
734  // Advance state realistically.
735  SendInputEventACK(WebInputEvent::GestureFlingStart,
736                    INPUT_EVENT_ACK_STATE_CONSUMED);
737  RunUntilIdle();
738  EXPECT_EQ(1U, GetAndResetSentGestureEventCount());
739  SendInputEventACK(WebInputEvent::GestureFlingCancel,
740                    INPUT_EVENT_ACK_STATE_CONSUMED);
741  RunUntilIdle();
742  EXPECT_EQ(2U, GetAndResetAckedGestureEventCount());
743  EXPECT_EQ(0U, GetAndResetSentGestureEventCount());
744  EXPECT_EQ(0U, GestureEventQueueSize());
745
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());
755
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());
762
763  // Adding a second GFC is dropped.
764  SimulateGestureEvent(WebInputEvent::GestureFlingCancel, source_device);
765  EXPECT_FALSE(FlingInProgress());
766  EXPECT_EQ(3U, GestureEventQueueSize());
767
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());
774
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());
781
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());
788}
789
790INSTANTIATE_TEST_CASE_P(AllSources,
791                        GestureEventFilterWithSourceTest,
792                        testing::Values(WebGestureEvent::Touchscreen,
793                                        WebGestureEvent::Touchpad));
794#endif  // GTEST_HAS_PARAM_TEST
795
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.
799TEST_F(GestureEventFilterTest, DebounceDefersFollowingGestureEvents) {
800  set_debounce_interval_time_ms(3);
801
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());
808
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());
815
816  SimulateGestureEvent(WebInputEvent::GestureScrollEnd,
817                       WebGestureEvent::Touchscreen);
818  EXPECT_EQ(0U, GetAndResetSentGestureEventCount());
819  EXPECT_EQ(2U, GestureEventQueueSize());
820  EXPECT_EQ(1U, GestureEventDebouncingQueueSize());
821
822  SimulateGestureFlingStartEvent(0, 10, WebGestureEvent::Touchscreen);
823  EXPECT_EQ(0U, GetAndResetSentGestureEventCount());
824  EXPECT_EQ(2U, GestureEventQueueSize());
825  EXPECT_EQ(2U, GestureEventDebouncingQueueSize());
826
827  SimulateGestureEvent(WebInputEvent::GestureTapDown,
828                       WebGestureEvent::Touchscreen);
829  EXPECT_EQ(0U, GetAndResetSentGestureEventCount());
830  EXPECT_EQ(2U, GestureEventQueueSize());
831  EXPECT_EQ(3U, GestureEventDebouncingQueueSize());
832
833  base::MessageLoop::current()->PostDelayedTask(
834      FROM_HERE,
835      base::MessageLoop::QuitClosure(),
836      TimeDelta::FromMilliseconds(5));
837  base::MessageLoop::current()->Run();
838
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());
844
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};
851
852  for (unsigned i = 0; i < sizeof(expected) / sizeof(WebInputEvent::Type);
853      i++) {
854    WebGestureEvent merged_event = GestureEventQueueEventAt(i);
855    EXPECT_EQ(expected[i], merged_event.type);
856  }
857}
858
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
861// interval end.
862TEST_F(GestureEventFilterTest, DebounceDropsDeferredEvents) {
863  set_debounce_interval_time_ms(3);
864  EXPECT_FALSE(ScrollingInProgress());
865
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());
872
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());
879
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());
886
887  // Verify that the coalescing queue contains the correct events.
888  WebInputEvent::Type expected[] = {
889      WebInputEvent::GestureScrollUpdate,
890      WebInputEvent::GestureScrollUpdate};
891
892  for (unsigned i = 0; i < sizeof(expected) / sizeof(WebInputEvent::Type);
893      i++) {
894    WebGestureEvent merged_event = GestureEventQueueEventAt(i);
895    EXPECT_EQ(expected[i], merged_event.type);
896  }
897}
898
899TEST_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());
910}
911
912}  // namespace content
913