src/content/browser/renderer_host/input/gesture_event_filter_unittest.cc

   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/synthetic_web_input_event_builders.h"
  14 #include "content/browser/renderer_host/input/touchpad_tap_suppression_controller.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
  19 using base::TimeDelta;
  20 using WebKit::WebGestureEvent;
  21 using WebKit::WebInputEvent;
  22
  23 namespace content {
  24
  25 class 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   }
  62
  63   // TouchpadTapSuppressionControllerClient
  64   virtual void SendMouseEventImmediately(
  65       const MouseEventWithLatencyInfo& event) OVERRIDE {
  66   }
  67
  68  protected:
  69
  70   // Returns the result of |GestureEventFilter::ShouldForward()|.
  71   bool SimulateGestureEvent(const WebGestureEvent& gesture) {
  72     GestureEventWithLatencyInfo gesture_with_latency(gesture,
  73                                                      ui::LatencyInfo());
  74     if (filter()->ShouldForward(gesture_with_latency)) {
  75       ++sent_gesture_event_count_;
  76       return true;
  77     }
  78     return false;
  79   }
  80
  81   void SimulateGestureEvent(WebInputEvent::Type type,
  82                             WebGestureEvent::SourceDevice sourceDevice) {
  83     SimulateGestureEvent(
  84         SyntheticWebGestureEventBuilder::Build(type, sourceDevice));
  85   }
  86
  87   void SimulateGestureScrollUpdateEvent(float dX, float dY, int modifiers) {
  88     SimulateGestureEvent(
  89         SyntheticWebGestureEventBuilder::BuildScrollUpdate(dX, dY, modifiers));
  90   }
  91
  92   void SimulateGesturePinchUpdateEvent(float scale,
  93                                        float anchorX,
  94                                        float anchorY,
  95                                        int modifiers) {
  96     SimulateGestureEvent(
  97         SyntheticWebGestureEventBuilder::BuildPinchUpdate(scale,
  98                                                           anchorX,
  99                                                           anchorY,
 100                                                           modifiers));
 101   }
 102
 103   void SimulateGestureFlingStartEvent(
 104       float velocityX,
 105       float velocityY,
 106       WebGestureEvent::SourceDevice sourceDevice) {
 107     SimulateGestureEvent(
 108         SyntheticWebGestureEventBuilder::BuildFling(velocityX,
 109                                                     velocityY,
 110                                                     sourceDevice));
 111   }
 112
 113   void SendInputEventACK(WebInputEvent::Type type,
 114                          InputEventAckState ack) {
 115     filter()->ProcessGestureAck(ack, type, ui::LatencyInfo());
 116   }
 117
 118   void RunUntilIdle() {
 119     base::MessageLoop::current()->RunUntilIdle();
 120   }
 121
 122   size_t GetAndResetSentGestureEventCount() {
 123     size_t count = sent_gesture_event_count_;
 124     sent_gesture_event_count_ = 0;
 125     return count;
 126   }
 127
 128   size_t GetAndResetAckedGestureEventCount() {
 129     size_t count = acked_gesture_event_count_;
 130     acked_gesture_event_count_ = 0;
 131     return count;
 132   }
 133
 134   const WebGestureEvent& last_acked_event() const {
 135     return last_acked_event_;
 136   }
 137
 138   void set_debounce_interval_time_ms(int ms) {
 139     filter()->debounce_interval_time_ms_ = ms;
 140   }
 141
 142   void set_synchronous_ack(InputEventAckState ack_result) {
 143     sync_ack_result_.reset(new InputEventAckState(ack_result));
 144   }
 145
 146   unsigned GestureEventQueueSize() {
 147     return filter()->coalesced_gesture_events_.size();
 148   }
 149
 150   WebGestureEvent GestureEventSecondFromLastQueueEvent() {
 151     return filter()->coalesced_gesture_events_.at(
 152         GestureEventQueueSize() - 2).event;
 153   }
 154
 155   WebGestureEvent GestureEventLastQueueEvent() {
 156     return filter()->coalesced_gesture_events_.back().event;
 157   }
 158
 159   unsigned GestureEventDebouncingQueueSize() {
 160     return filter()->debouncing_deferral_queue_.size();
 161   }
 162
 163   WebGestureEvent GestureEventQueueEventAt(int i) {
 164     return filter()->coalesced_gesture_events_.at(i).event;
 165   }
 166
 167   bool ScrollingInProgress() {
 168     return filter()->scrolling_in_progress_;
 169   }
 170
 171   bool FlingInProgress() {
 172     return filter()->fling_in_progress_;
 173   }
 174
 175   bool WillIgnoreNextACK() {
 176     return filter()->ignore_next_ack_;
 177   }
 178
 179   GestureEventFilter* filter() const {
 180     return filter_.get();
 181   }
 182
 183  private:
 184   scoped_ptr<GestureEventFilter> filter_;
 185   size_t acked_gesture_event_count_;
 186   size_t sent_gesture_event_count_;
 187   WebGestureEvent last_acked_event_;
 188   scoped_ptr<InputEventAckState> sync_ack_result_;
 189   base::MessageLoopForUI message_loop_;
 190 };
 191
 192 #if GTEST_HAS_PARAM_TEST
 193 // This is for tests that are to be run for all source devices.
 194 class GestureEventFilterWithSourceTest
 195     : public GestureEventFilterTest,
 196       public testing::WithParamInterface<WebGestureEvent::SourceDevice> {
 197 };
 198 #endif  // GTEST_HAS_PARAM_TEST
 199
 200 TEST_F(GestureEventFilterTest, CoalescesScrollGestureEvents) {
 201   // Turn off debounce handling for test isolation.
 202   set_debounce_interval_time_ms(0);
 203
 204   // Test coalescing of only GestureScrollUpdate events.
 205   // Simulate gesture events.
 206
 207   // Sent.
 208   SimulateGestureEvent(WebInputEvent::GestureScrollBegin,
 209                        WebGestureEvent::Touchscreen);
 210   EXPECT_EQ(1U, GetAndResetSentGestureEventCount());
 211
 212   // Enqueued.
 213   SimulateGestureScrollUpdateEvent(8, -5, 0);
 214
 215   // Make sure that the queue contains what we think it should.
 216   WebGestureEvent merged_event = GestureEventLastQueueEvent();
 217   EXPECT_EQ(2U, GestureEventQueueSize());
 218   EXPECT_EQ(WebInputEvent::GestureScrollUpdate, merged_event.type);
 219
 220   // Coalesced.
 221   SimulateGestureScrollUpdateEvent(8, -6, 0);
 222
 223   // Check that coalescing updated the correct values.
 224   merged_event = GestureEventLastQueueEvent();
 225   EXPECT_EQ(WebInputEvent::GestureScrollUpdate, merged_event.type);
 226   EXPECT_EQ(0, merged_event.modifiers);
 227   EXPECT_EQ(16, merged_event.data.scrollUpdate.deltaX);
 228   EXPECT_EQ(-11, merged_event.data.scrollUpdate.deltaY);
 229
 230   // Enqueued.
 231   SimulateGestureScrollUpdateEvent(8, -7, 1);
 232
 233   // Check that we didn't wrongly coalesce.
 234   merged_event = GestureEventLastQueueEvent();
 235   EXPECT_EQ(WebInputEvent::GestureScrollUpdate, merged_event.type);
 236   EXPECT_EQ(1, merged_event.modifiers);
 237
 238   // Different.
 239   SimulateGestureEvent(WebInputEvent::GestureScrollEnd,
 240                        WebGestureEvent::Touchscreen);
 241
 242   // Check that only the first event was sent.
 243   EXPECT_EQ(0U, GetAndResetSentGestureEventCount());
 244
 245   // Check that the ACK sends the second message.
 246   SendInputEventACK(WebInputEvent::GestureScrollBegin,
 247                     INPUT_EVENT_ACK_STATE_CONSUMED);
 248   RunUntilIdle();
 249   EXPECT_EQ(1U, GetAndResetAckedGestureEventCount());
 250   EXPECT_EQ(1U, GetAndResetSentGestureEventCount());
 251
 252   // Ack for queued coalesced event.
 253   SendInputEventACK(WebInputEvent::GestureScrollUpdate,
 254                     INPUT_EVENT_ACK_STATE_CONSUMED);
 255   RunUntilIdle();
 256   EXPECT_EQ(1U, GetAndResetAckedGestureEventCount());
 257   EXPECT_EQ(1U, GetAndResetSentGestureEventCount());
 258
 259   // Ack for queued uncoalesced event.
 260   SendInputEventACK(WebInputEvent::GestureScrollUpdate,
 261                     INPUT_EVENT_ACK_STATE_CONSUMED);
 262   RunUntilIdle();
 263   EXPECT_EQ(1U, GetAndResetAckedGestureEventCount());
 264   EXPECT_EQ(1U, GetAndResetSentGestureEventCount());
 265
 266   // After the final ack, the queue should be empty.
 267   SendInputEventACK(WebInputEvent::GestureScrollEnd,
 268                     INPUT_EVENT_ACK_STATE_CONSUMED);
 269   RunUntilIdle();
 270   EXPECT_EQ(1U, GetAndResetAckedGestureEventCount());
 271   EXPECT_EQ(0U, GetAndResetSentGestureEventCount());
 272 }
 273
 274 TEST_F(GestureEventFilterTest, CoalescesScrollAndPinchEvents) {
 275   // Turn off debounce handling for test isolation.
 276   set_debounce_interval_time_ms(0);
 277
 278   // Test coalescing of only GestureScrollUpdate events.
 279   // Simulate gesture events.
 280
 281   // Sent.
 282   SimulateGestureEvent(WebInputEvent::GestureScrollBegin,
 283                        WebGestureEvent::Touchscreen);
 284
 285   // Sent.
 286   SimulateGestureEvent(WebInputEvent::GesturePinchBegin,
 287                        WebGestureEvent::Touchscreen);
 288
 289   // Enqueued.
 290   SimulateGestureScrollUpdateEvent(8, -4, 1);
 291
 292   // Make sure that the queue contains what we think it should.
 293   WebGestureEvent merged_event = GestureEventLastQueueEvent();
 294   EXPECT_EQ(3U, GestureEventQueueSize());
 295   EXPECT_EQ(WebInputEvent::GestureScrollUpdate, merged_event.type);
 296
 297   // Coalesced without changing event order. Note anchor at (60, 60). Anchoring
 298   // from a point that is not the origin should still give us the right scroll.
 299   SimulateGesturePinchUpdateEvent(1.5, 60, 60, 1);
 300   EXPECT_EQ(4U, GestureEventQueueSize());
 301   merged_event = GestureEventLastQueueEvent();
 302   EXPECT_EQ(WebInputEvent::GesturePinchUpdate, merged_event.type);
 303   EXPECT_EQ(1.5, merged_event.data.pinchUpdate.scale);
 304   EXPECT_EQ(1, merged_event.modifiers);
 305   merged_event = GestureEventSecondFromLastQueueEvent();
 306   EXPECT_EQ(WebInputEvent::GestureScrollUpdate, merged_event.type);
 307   EXPECT_EQ(8, merged_event.data.scrollUpdate.deltaX);
 308   EXPECT_EQ(-4, merged_event.data.scrollUpdate.deltaY);
 309   EXPECT_EQ(1, merged_event.modifiers);
 310
 311   // Enqueued.
 312   SimulateGestureScrollUpdateEvent(6, -3, 1);
 313
 314   // Check whether coalesced correctly.
 315   EXPECT_EQ(4U, GestureEventQueueSize());
 316   merged_event = GestureEventLastQueueEvent();
 317   EXPECT_EQ(WebInputEvent::GesturePinchUpdate, merged_event.type);
 318   EXPECT_EQ(1.5, merged_event.data.pinchUpdate.scale);
 319   EXPECT_EQ(1, merged_event.modifiers);
 320   merged_event = GestureEventSecondFromLastQueueEvent();
 321   EXPECT_EQ(WebInputEvent::GestureScrollUpdate, merged_event.type);
 322   EXPECT_EQ(12, merged_event.data.scrollUpdate.deltaX);
 323   EXPECT_EQ(-6, merged_event.data.scrollUpdate.deltaY);
 324   EXPECT_EQ(1, merged_event.modifiers);
 325
 326   // Enqueued.
 327   SimulateGesturePinchUpdateEvent(2, 60, 60, 1);
 328
 329   // Check whether coalesced correctly.
 330   EXPECT_EQ(4U, GestureEventQueueSize());
 331   merged_event = GestureEventLastQueueEvent();
 332   EXPECT_EQ(WebInputEvent::GesturePinchUpdate, merged_event.type);
 333   EXPECT_EQ(3, merged_event.data.pinchUpdate.scale);
 334   EXPECT_EQ(1, merged_event.modifiers);
 335   merged_event = GestureEventSecondFromLastQueueEvent();
 336   EXPECT_EQ(WebInputEvent::GestureScrollUpdate, merged_event.type);
 337   EXPECT_EQ(12, merged_event.data.scrollUpdate.deltaX);
 338   EXPECT_EQ(-6, merged_event.data.scrollUpdate.deltaY);
 339   EXPECT_EQ(1, merged_event.modifiers);
 340
 341   // Enqueued.
 342   SimulateGesturePinchUpdateEvent(2, 60, 60, 1);
 343
 344   // Check whether coalesced correctly.
 345   EXPECT_EQ(4U, GestureEventQueueSize());
 346   merged_event = GestureEventLastQueueEvent();
 347   EXPECT_EQ(WebInputEvent::GesturePinchUpdate, merged_event.type);
 348   EXPECT_EQ(6, merged_event.data.pinchUpdate.scale);
 349   EXPECT_EQ(1, merged_event.modifiers);
 350   merged_event = GestureEventSecondFromLastQueueEvent();
 351   EXPECT_EQ(WebInputEvent::GestureScrollUpdate, merged_event.type);
 352   EXPECT_EQ(12, merged_event.data.scrollUpdate.deltaX);
 353   EXPECT_EQ(-6, merged_event.data.scrollUpdate.deltaY);
 354   EXPECT_EQ(1, merged_event.modifiers);
 355
 356   // Check that only the first event was sent.
 357   EXPECT_EQ(1U, GetAndResetSentGestureEventCount());
 358
 359   // Check that the ACK sends the second message.
 360   SendInputEventACK(WebInputEvent::GestureScrollBegin,
 361                     INPUT_EVENT_ACK_STATE_CONSUMED);
 362   RunUntilIdle();
 363   EXPECT_EQ(1U, GetAndResetSentGestureEventCount());
 364
 365   // Enqueued.
 366   SimulateGestureScrollUpdateEvent(6, -6, 1);
 367
 368   // Check whether coalesced correctly.
 369   EXPECT_EQ(3U, GestureEventQueueSize());
 370   merged_event = GestureEventLastQueueEvent();
 371   EXPECT_EQ(WebInputEvent::GesturePinchUpdate, merged_event.type);
 372   EXPECT_EQ(6, merged_event.data.pinchUpdate.scale);
 373   EXPECT_EQ(1, merged_event.modifiers);
 374   merged_event = GestureEventSecondFromLastQueueEvent();
 375   EXPECT_EQ(WebInputEvent::GestureScrollUpdate, merged_event.type);
 376   EXPECT_EQ(13, merged_event.data.scrollUpdate.deltaX);
 377   EXPECT_EQ(-7, merged_event.data.scrollUpdate.deltaY);
 378   EXPECT_EQ(1, merged_event.modifiers);
 379
 380   // At this point ACKs shouldn't be getting ignored.
 381   EXPECT_FALSE(WillIgnoreNextACK());
 382
 383   // Check that the ACK sends both scroll and pinch updates.
 384   SendInputEventACK(WebInputEvent::GesturePinchBegin,
 385                     INPUT_EVENT_ACK_STATE_CONSUMED);
 386   RunUntilIdle();
 387   EXPECT_EQ(2U, GetAndResetSentGestureEventCount());
 388
 389   // The next ACK should be getting ignored.
 390   EXPECT_TRUE(WillIgnoreNextACK());
 391
 392   // Enqueued.
 393   SimulateGestureScrollUpdateEvent(1, -1, 1);
 394
 395   // Check whether coalesced correctly.
 396   EXPECT_EQ(3U, GestureEventQueueSize());
 397   merged_event = GestureEventLastQueueEvent();
 398   EXPECT_EQ(WebInputEvent::GestureScrollUpdate, merged_event.type);
 399   EXPECT_EQ(1, merged_event.data.scrollUpdate.deltaX);
 400   EXPECT_EQ(-1, merged_event.data.scrollUpdate.deltaY);
 401   EXPECT_EQ(1, merged_event.modifiers);
 402   merged_event = GestureEventSecondFromLastQueueEvent();
 403   EXPECT_EQ(WebInputEvent::GesturePinchUpdate, merged_event.type);
 404   EXPECT_EQ(6, merged_event.data.pinchUpdate.scale);
 405   EXPECT_EQ(1, merged_event.modifiers);
 406
 407   // Enqueued.
 408   SimulateGestureScrollUpdateEvent(2, -2, 1);
 409
 410   // Coalescing scrolls should still work.
 411   EXPECT_EQ(3U, GestureEventQueueSize());
 412   merged_event = GestureEventLastQueueEvent();
 413   EXPECT_EQ(WebInputEvent::GestureScrollUpdate, merged_event.type);
 414   EXPECT_EQ(3, merged_event.data.scrollUpdate.deltaX);
 415   EXPECT_EQ(-3, merged_event.data.scrollUpdate.deltaY);
 416   EXPECT_EQ(1, merged_event.modifiers);
 417   merged_event = GestureEventSecondFromLastQueueEvent();
 418   EXPECT_EQ(WebInputEvent::GesturePinchUpdate, merged_event.type);
 419   EXPECT_EQ(6, merged_event.data.pinchUpdate.scale);
 420   EXPECT_EQ(1, merged_event.modifiers);
 421
 422   // Enqueued.
 423   SimulateGesturePinchUpdateEvent(0.5, 60, 60, 1);
 424
 425   // Check whether coalesced correctly.
 426   EXPECT_EQ(4U, GestureEventQueueSize());
 427   merged_event = GestureEventLastQueueEvent();
 428   EXPECT_EQ(WebInputEvent::GesturePinchUpdate, merged_event.type);
 429   EXPECT_EQ(0.5, merged_event.data.pinchUpdate.scale);
 430   EXPECT_EQ(1, merged_event.modifiers);
 431   merged_event = GestureEventSecondFromLastQueueEvent();
 432   EXPECT_EQ(WebInputEvent::GestureScrollUpdate, merged_event.type);
 433   EXPECT_EQ(3, merged_event.data.scrollUpdate.deltaX);
 434   EXPECT_EQ(-3, merged_event.data.scrollUpdate.deltaY);
 435   EXPECT_EQ(1, merged_event.modifiers);
 436
 437   // Check that the ACK gets ignored.
 438   SendInputEventACK(WebInputEvent::GestureScrollUpdate,
 439                     INPUT_EVENT_ACK_STATE_CONSUMED);
 440   EXPECT_EQ(WebInputEvent::GestureScrollUpdate, last_acked_event().type);
 441   RunUntilIdle();
 442   EXPECT_EQ(0U, GetAndResetSentGestureEventCount());
 443   // The flag should have been flipped back to false.
 444   EXPECT_FALSE(WillIgnoreNextACK());
 445
 446   // Enqueued.
 447   SimulateGestureScrollUpdateEvent(2, -2, 2);
 448
 449   // Shouldn't coalesce with different modifiers.
 450   EXPECT_EQ(4U, GestureEventQueueSize());
 451   merged_event = GestureEventLastQueueEvent();
 452   EXPECT_EQ(WebInputEvent::GestureScrollUpdate, merged_event.type);
 453   EXPECT_EQ(2, merged_event.data.scrollUpdate.deltaX);
 454   EXPECT_EQ(-2, merged_event.data.scrollUpdate.deltaY);
 455   EXPECT_EQ(2, merged_event.modifiers);
 456   merged_event = GestureEventSecondFromLastQueueEvent();
 457   EXPECT_EQ(WebInputEvent::GesturePinchUpdate, merged_event.type);
 458   EXPECT_EQ(0.5, merged_event.data.pinchUpdate.scale);
 459   EXPECT_EQ(1, merged_event.modifiers);
 460
 461   // Check that the ACK sends the next scroll pinch pair.
 462   SendInputEventACK(WebInputEvent::GesturePinchUpdate,
 463                     INPUT_EVENT_ACK_STATE_CONSUMED);
 464   EXPECT_EQ(WebInputEvent::GesturePinchUpdate, last_acked_event().type);
 465   RunUntilIdle();
 466   EXPECT_EQ(2U, GetAndResetSentGestureEventCount());
 467
 468   // Check that the ACK sends the second message.
 469   SendInputEventACK(WebInputEvent::GestureScrollUpdate,
 470                     INPUT_EVENT_ACK_STATE_CONSUMED);
 471   EXPECT_EQ(WebInputEvent::GestureScrollUpdate, last_acked_event().type);
 472   RunUntilIdle();
 473   EXPECT_EQ(0U, GetAndResetSentGestureEventCount());
 474
 475   // Check that the ACK sends the second event.
 476   SendInputEventACK(WebInputEvent::GesturePinchUpdate,
 477                     INPUT_EVENT_ACK_STATE_CONSUMED);
 478   EXPECT_EQ(WebInputEvent::GesturePinchUpdate, last_acked_event().type);
 479   RunUntilIdle();
 480   EXPECT_EQ(1U, GetAndResetSentGestureEventCount());
 481
 482   // Check that the queue is empty after ACK and no events get sent.
 483   SendInputEventACK(WebInputEvent::GestureScrollUpdate,
 484                     INPUT_EVENT_ACK_STATE_CONSUMED);
 485   EXPECT_EQ(WebInputEvent::GestureScrollUpdate, last_acked_event().type);
 486   RunUntilIdle();
 487   EXPECT_EQ(0U, GetAndResetSentGestureEventCount());
 488   EXPECT_EQ(0U, GestureEventQueueSize());
 489 }
 490
 491 TEST_F(GestureEventFilterTest, CoalescesMultiplePinchEventSequences) {
 492   // Turn off debounce handling for test isolation.
 493   set_debounce_interval_time_ms(0);
 494
 495   // Simulate a pinch sequence.
 496   SimulateGestureEvent(WebInputEvent::GestureScrollBegin,
 497                        WebGestureEvent::Touchscreen);
 498   SimulateGestureEvent(WebInputEvent::GesturePinchBegin,
 499                        WebGestureEvent::Touchscreen);
 500
 501   SimulateGestureScrollUpdateEvent(8, -4, 1);
 502   // Make sure that the queue contains what we think it should.
 503   WebGestureEvent merged_event = GestureEventLastQueueEvent();
 504   size_t expected_events_in_queue = 3;
 505   EXPECT_EQ(expected_events_in_queue, GestureEventQueueSize());
 506   EXPECT_EQ(WebInputEvent::GestureScrollUpdate, merged_event.type);
 507
 508   // Coalesced without changing event order. Note anchor at (60, 60). Anchoring
 509   // from a point that is not the origin should still give us the right scroll.
 510   SimulateGesturePinchUpdateEvent(1.5, 60, 60, 1);
 511   EXPECT_EQ(++expected_events_in_queue, GestureEventQueueSize());
 512   merged_event = GestureEventLastQueueEvent();
 513   EXPECT_EQ(WebInputEvent::GesturePinchUpdate, merged_event.type);
 514   EXPECT_EQ(1.5, merged_event.data.pinchUpdate.scale);
 515   EXPECT_EQ(1, merged_event.modifiers);
 516   merged_event = GestureEventSecondFromLastQueueEvent();
 517   EXPECT_EQ(WebInputEvent::GestureScrollUpdate, merged_event.type);
 518   EXPECT_EQ(8, merged_event.data.scrollUpdate.deltaX);
 519   EXPECT_EQ(-4, merged_event.data.scrollUpdate.deltaY);
 520   EXPECT_EQ(1, merged_event.modifiers);
 521
 522   // Enqueued.
 523   SimulateGestureScrollUpdateEvent(6, -3, 1);
 524
 525   // Check whether coalesced correctly.
 526   EXPECT_EQ(expected_events_in_queue, GestureEventQueueSize());
 527   merged_event = GestureEventLastQueueEvent();
 528   EXPECT_EQ(WebInputEvent::GesturePinchUpdate, merged_event.type);
 529   EXPECT_EQ(1.5, merged_event.data.pinchUpdate.scale);
 530   EXPECT_EQ(1, merged_event.modifiers);
 531   merged_event = GestureEventSecondFromLastQueueEvent();
 532   EXPECT_EQ(WebInputEvent::GestureScrollUpdate, merged_event.type);
 533   EXPECT_EQ(12, merged_event.data.scrollUpdate.deltaX);
 534   EXPECT_EQ(-6, merged_event.data.scrollUpdate.deltaY);
 535   EXPECT_EQ(1, merged_event.modifiers);
 536
 537   // Now start another sequence before the previous sequence has been ack'ed.
 538   SimulateGestureEvent(WebInputEvent::GesturePinchEnd,
 539                        WebGestureEvent::Touchscreen);
 540   SimulateGestureEvent(WebInputEvent::GestureScrollEnd,
 541                        WebGestureEvent::Touchscreen);
 542   SimulateGestureEvent(WebInputEvent::GestureScrollBegin,
 543                        WebGestureEvent::Touchscreen);
 544   SimulateGestureEvent(WebInputEvent::GesturePinchBegin,
 545                        WebGestureEvent::Touchscreen);
 546
 547   SimulateGestureScrollUpdateEvent(8, -4, 1);
 548   // Make sure that the queue contains what we think it should.
 549   expected_events_in_queue += 5;
 550   merged_event = GestureEventLastQueueEvent();
 551   EXPECT_EQ(expected_events_in_queue, GestureEventQueueSize());
 552   EXPECT_EQ(WebInputEvent::GestureScrollUpdate, merged_event.type);
 553
 554   // Coalesced without changing event order. Note anchor at (60, 60). Anchoring
 555   // from a point that is not the origin should still give us the right scroll.
 556   SimulateGesturePinchUpdateEvent(1.5, 30, 30, 1);
 557   EXPECT_EQ(++expected_events_in_queue, GestureEventQueueSize());
 558   merged_event = GestureEventLastQueueEvent();
 559   EXPECT_EQ(WebInputEvent::GesturePinchUpdate, merged_event.type);
 560   EXPECT_EQ(1.5, merged_event.data.pinchUpdate.scale);
 561   EXPECT_EQ(1, merged_event.modifiers);
 562   merged_event = GestureEventSecondFromLastQueueEvent();
 563   EXPECT_EQ(WebInputEvent::GestureScrollUpdate, merged_event.type);
 564   EXPECT_EQ(8, merged_event.data.scrollUpdate.deltaX);
 565   EXPECT_EQ(-4, merged_event.data.scrollUpdate.deltaY);
 566   EXPECT_EQ(1, merged_event.modifiers);
 567
 568   // Enqueued.
 569   SimulateGestureScrollUpdateEvent(6, -3, 1);
 570
 571   // Check whether coalesced correctly.
 572   EXPECT_EQ(expected_events_in_queue, GestureEventQueueSize());
 573   merged_event = GestureEventLastQueueEvent();
 574   EXPECT_EQ(WebInputEvent::GesturePinchUpdate, merged_event.type);
 575   EXPECT_EQ(1.5, merged_event.data.pinchUpdate.scale);
 576   EXPECT_EQ(1, merged_event.modifiers);
 577   merged_event = GestureEventSecondFromLastQueueEvent();
 578   EXPECT_EQ(WebInputEvent::GestureScrollUpdate, merged_event.type);
 579   EXPECT_EQ(12, merged_event.data.scrollUpdate.deltaX);
 580   EXPECT_EQ(-6, merged_event.data.scrollUpdate.deltaY);
 581   EXPECT_EQ(1, merged_event.modifiers);
 582 }
 583
 584
 585 TEST_F(GestureEventFilterTest, CoalescesScrollAndPinchEventWithSyncAck) {
 586   // Turn off debounce handling for test isolation.
 587   set_debounce_interval_time_ms(0);
 588
 589   // Simulate a pinch sequence.
 590   SimulateGestureEvent(WebInputEvent::GestureScrollBegin,
 591                        WebGestureEvent::Touchscreen);
 592   EXPECT_EQ(1U, GetAndResetSentGestureEventCount());
 593   SimulateGestureEvent(WebInputEvent::GesturePinchBegin,
 594                        WebGestureEvent::Touchscreen);
 595   EXPECT_EQ(0U, GetAndResetSentGestureEventCount());
 596
 597   SimulateGestureScrollUpdateEvent(8, -4, 1);
 598   // Make sure that the queue contains what we think it should.
 599   WebGestureEvent merged_event = GestureEventLastQueueEvent();
 600   EXPECT_EQ(3U, GestureEventQueueSize());
 601   EXPECT_EQ(WebInputEvent::GestureScrollUpdate, merged_event.type);
 602
 603   // Coalesced without changing event order. Note anchor at (60, 60). Anchoring
 604   // from a point that is not the origin should still give us the right scroll.
 605   SimulateGesturePinchUpdateEvent(1.5, 60, 60, 1);
 606   EXPECT_EQ(4U, GestureEventQueueSize());
 607
 608   SendInputEventACK(WebInputEvent::GestureScrollBegin,
 609                     INPUT_EVENT_ACK_STATE_CONSUMED);
 610   EXPECT_EQ(1U, GetAndResetSentGestureEventCount());
 611   EXPECT_EQ(3U, GestureEventQueueSize());
 612
 613   // Ack the PinchBegin, and schedule a synchronous ack for GestureScrollUpdate.
 614   set_synchronous_ack(INPUT_EVENT_ACK_STATE_CONSUMED);
 615   SendInputEventACK(WebInputEvent::GesturePinchBegin,
 616                     INPUT_EVENT_ACK_STATE_CONSUMED);
 617
 618   // Both GestureScrollUpdate and GesturePinchUpdate should have been sent.
 619   EXPECT_EQ(WebInputEvent::GestureScrollUpdate, last_acked_event().type);
 620   EXPECT_EQ(1U, GestureEventQueueSize());
 621   EXPECT_EQ(2U, GetAndResetSentGestureEventCount());
 622
 623   // Ack the final GesturePinchUpdate.
 624   SendInputEventACK(WebInputEvent::GesturePinchUpdate,
 625                     INPUT_EVENT_ACK_STATE_CONSUMED);
 626   EXPECT_EQ(WebInputEvent::GesturePinchUpdate, last_acked_event().type);
 627   EXPECT_EQ(0U, GestureEventQueueSize());
 628   EXPECT_EQ(0U, GetAndResetSentGestureEventCount());
 629 }
 630
 631 #if GTEST_HAS_PARAM_TEST
 632 TEST_P(GestureEventFilterWithSourceTest, GestureFlingCancelsFiltered) {
 633   WebGestureEvent::SourceDevice source_device = GetParam();
 634
 635   // Turn off debounce handling for test isolation.
 636   set_debounce_interval_time_ms(0);
 637   // GFC without previous GFS is dropped.
 638   SimulateGestureEvent(WebInputEvent::GestureFlingCancel, source_device);
 639   EXPECT_EQ(0U, GetAndResetSentGestureEventCount());
 640   EXPECT_EQ(0U, GestureEventQueueSize());
 641
 642   // GFC after previous GFS is dispatched and acked.
 643   SimulateGestureFlingStartEvent(0, -10, source_device);
 644   EXPECT_TRUE(FlingInProgress());
 645   SendInputEventACK(WebInputEvent::GestureFlingStart,
 646                     INPUT_EVENT_ACK_STATE_CONSUMED);
 647   RunUntilIdle();
 648   EXPECT_EQ(1U, GetAndResetAckedGestureEventCount());
 649   SimulateGestureEvent(WebInputEvent::GestureFlingCancel, source_device);
 650   EXPECT_FALSE(FlingInProgress());
 651   EXPECT_EQ(2U, GetAndResetSentGestureEventCount());
 652   SendInputEventACK(WebInputEvent::GestureFlingCancel,
 653                     INPUT_EVENT_ACK_STATE_CONSUMED);
 654   RunUntilIdle();
 655   EXPECT_EQ(1U, GetAndResetAckedGestureEventCount());
 656   EXPECT_EQ(0U, GestureEventQueueSize());
 657
 658   // GFC before previous GFS is acked.
 659   SimulateGestureFlingStartEvent(0, -10, source_device);
 660   EXPECT_TRUE(FlingInProgress());
 661   SimulateGestureEvent(WebInputEvent::GestureFlingCancel, source_device);
 662   EXPECT_FALSE(FlingInProgress());
 663   EXPECT_EQ(1U, GetAndResetSentGestureEventCount());
 664   EXPECT_EQ(2U, GestureEventQueueSize());
 665
 666   // Advance state realistically.
 667   SendInputEventACK(WebInputEvent::GestureFlingStart,
 668                     INPUT_EVENT_ACK_STATE_CONSUMED);
 669   RunUntilIdle();
 670   EXPECT_EQ(1U, GetAndResetSentGestureEventCount());
 671   SendInputEventACK(WebInputEvent::GestureFlingCancel,
 672                     INPUT_EVENT_ACK_STATE_CONSUMED);
 673   RunUntilIdle();
 674   EXPECT_EQ(2U, GetAndResetAckedGestureEventCount());
 675   EXPECT_EQ(0U, GetAndResetSentGestureEventCount());
 676   EXPECT_EQ(0U, GestureEventQueueSize());
 677
 678   // GFS is added to the queue if another event is pending
 679   SimulateGestureScrollUpdateEvent(8, -7, 0);
 680   SimulateGestureFlingStartEvent(0, -10, source_device);
 681   EXPECT_EQ(2U, GestureEventQueueSize());
 682   EXPECT_EQ(1U, GetAndResetSentGestureEventCount());
 683   WebGestureEvent merged_event = GestureEventLastQueueEvent();
 684   EXPECT_EQ(WebInputEvent::GestureFlingStart, merged_event.type);
 685   EXPECT_TRUE(FlingInProgress());
 686   EXPECT_EQ(2U, GestureEventQueueSize());
 687
 688   // GFS in queue means that a GFC is added to the queue
 689   SimulateGestureEvent(WebInputEvent::GestureFlingCancel, source_device);
 690   merged_event =GestureEventLastQueueEvent();
 691   EXPECT_EQ(WebInputEvent::GestureFlingCancel, merged_event.type);
 692   EXPECT_FALSE(FlingInProgress());
 693   EXPECT_EQ(3U, GestureEventQueueSize());
 694
 695   // Adding a second GFC is dropped.
 696   SimulateGestureEvent(WebInputEvent::GestureFlingCancel, source_device);
 697   EXPECT_FALSE(FlingInProgress());
 698   EXPECT_EQ(3U, GestureEventQueueSize());
 699
 700   // Adding another GFS will add it to the queue.
 701   SimulateGestureFlingStartEvent(0, -10, source_device);
 702   merged_event = GestureEventLastQueueEvent();
 703   EXPECT_EQ(WebInputEvent::GestureFlingStart, merged_event.type);
 704   EXPECT_TRUE(FlingInProgress());
 705   EXPECT_EQ(4U, GestureEventQueueSize());
 706
 707   // GFS in queue means that a GFC is added to the queue
 708   SimulateGestureEvent(WebInputEvent::GestureFlingCancel, source_device);
 709   merged_event = GestureEventLastQueueEvent();
 710   EXPECT_EQ(WebInputEvent::GestureFlingCancel, merged_event.type);
 711   EXPECT_FALSE(FlingInProgress());
 712   EXPECT_EQ(5U, GestureEventQueueSize());
 713
 714   // Adding another GFC with a GFC already there is dropped.
 715   SimulateGestureEvent(WebInputEvent::GestureFlingCancel, source_device);
 716   merged_event = GestureEventLastQueueEvent();
 717   EXPECT_EQ(WebInputEvent::GestureFlingCancel, merged_event.type);
 718   EXPECT_FALSE(FlingInProgress());
 719   EXPECT_EQ(5U, GestureEventQueueSize());
 720 }
 721
 722 INSTANTIATE_TEST_CASE_P(AllSources,
 723                         GestureEventFilterWithSourceTest,
 724                         testing::Values(WebGestureEvent::Touchscreen,
 725                                         WebGestureEvent::Touchpad));
 726 #endif  // GTEST_HAS_PARAM_TEST
 727
 728 // Test that GestureShowPress, GestureTapDown and GestureTapCancel events don't
 729 // wait for ACKs.
 730 TEST_F(GestureEventFilterTest, GestureTypesIgnoringAck) {
 731   set_debounce_interval_time_ms(0);
 732
 733   // The show press, tap down and tap cancel events will escape the queue
 734   // immediately when they reach the queue head, since they ignore acks.
 735   SimulateGestureEvent(WebInputEvent::GestureShowPress,
 736                        WebGestureEvent::Touchscreen);
 737   EXPECT_EQ(1U, GetAndResetSentGestureEventCount());
 738   EXPECT_EQ(0U, GestureEventQueueSize());
 739
 740   SimulateGestureEvent(WebInputEvent::GestureShowPress,
 741                        WebGestureEvent::Touchscreen);
 742   EXPECT_EQ(1U, GetAndResetSentGestureEventCount());
 743   EXPECT_EQ(0U, GestureEventQueueSize());
 744
 745   SimulateGestureEvent(WebInputEvent::GestureTapCancel,
 746                        WebGestureEvent::Touchscreen);
 747   EXPECT_EQ(1U, GetAndResetSentGestureEventCount());
 748   EXPECT_EQ(0U, GestureEventQueueSize());
 749
 750   // Interleave a few events that do and do not ignore acks, ensuring that
 751   // ack-ignoring events remain queued until they reach the queue head.
 752   SimulateGestureEvent(WebInputEvent::GesturePinchBegin,
 753                        WebGestureEvent::Touchpad);
 754   ASSERT_EQ(1U, GetAndResetSentGestureEventCount());
 755   ASSERT_EQ(1U, GestureEventQueueSize());
 756
 757   SimulateGestureEvent(WebInputEvent::GestureTapDown,
 758                        WebGestureEvent::Touchscreen);
 759   EXPECT_EQ(0U, GetAndResetSentGestureEventCount());
 760   EXPECT_EQ(2U, GestureEventQueueSize());
 761
 762   SimulateGestureEvent(WebInputEvent::GesturePinchUpdate,
 763                        WebGestureEvent::Touchpad);
 764   EXPECT_EQ(0U, GetAndResetSentGestureEventCount());
 765   EXPECT_EQ(3U, GestureEventQueueSize());
 766
 767   SimulateGestureEvent(WebInputEvent::GestureShowPress,
 768                        WebGestureEvent::Touchscreen);
 769   EXPECT_EQ(0U, GetAndResetSentGestureEventCount());
 770   EXPECT_EQ(4U, GestureEventQueueSize());
 771
 772   SimulateGestureEvent(WebInputEvent::GesturePinchEnd,
 773                        WebGestureEvent::Touchpad);
 774   EXPECT_EQ(0U, GetAndResetSentGestureEventCount());
 775   EXPECT_EQ(5U, GestureEventQueueSize());
 776
 777   SimulateGestureEvent(WebInputEvent::GestureTapCancel,
 778                        WebGestureEvent::Touchscreen);
 779   EXPECT_EQ(0U, GetAndResetSentGestureEventCount());
 780   EXPECT_EQ(6U, GestureEventQueueSize());
 781
 782   // Now ack each event. Ack-ignoring events should remain queued until they
 783   // reach the head of the queue, at which point they should be sent immediately
 784   // and removed from the queue, unblocking subsequent events.
 785   SendInputEventACK(WebInputEvent::GesturePinchBegin,
 786                     INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
 787   EXPECT_EQ(2U, GetAndResetSentGestureEventCount());
 788   EXPECT_EQ(4U, GestureEventQueueSize());
 789
 790   SendInputEventACK(WebInputEvent::GestureTapDown,
 791                     INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
 792   EXPECT_EQ(0U, GetAndResetSentGestureEventCount());
 793   EXPECT_EQ(4U, GestureEventQueueSize());
 794
 795   SendInputEventACK(WebInputEvent::GesturePinchUpdate,
 796                     INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
 797   EXPECT_EQ(2U, GetAndResetSentGestureEventCount());
 798   EXPECT_EQ(2U, GestureEventQueueSize());
 799
 800   SendInputEventACK(WebInputEvent::GestureShowPress,
 801                     INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
 802   EXPECT_EQ(0U, GetAndResetSentGestureEventCount());
 803   EXPECT_EQ(2U, GestureEventQueueSize());
 804
 805   SendInputEventACK(WebInputEvent::GesturePinchEnd,
 806                     INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
 807   EXPECT_EQ(1U, GetAndResetSentGestureEventCount());
 808   EXPECT_EQ(0U, GestureEventQueueSize());
 809
 810   SendInputEventACK(WebInputEvent::GestureTapCancel,
 811                     INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
 812   EXPECT_EQ(0U, GetAndResetSentGestureEventCount());
 813   EXPECT_EQ(0U, GestureEventQueueSize());
 814 }
 815
 816 // Test that GestureShowPress events don't get out of order due to
 817 // ignoring their acks.
 818 TEST_F(GestureEventFilterTest, GestureShowPressIsInOrder) {
 819   SimulateGestureEvent(WebInputEvent::GestureTap,
 820                        WebGestureEvent::Touchscreen);
 821
 822   EXPECT_EQ(1U, GetAndResetSentGestureEventCount());
 823   EXPECT_EQ(1U, GestureEventQueueSize());
 824
 825   SimulateGestureEvent(WebInputEvent::GestureShowPress,
 826                        WebGestureEvent::Touchscreen);
 827
 828   EXPECT_EQ(0U, GetAndResetSentGestureEventCount());
 829   // The ShowPress, though it ignores ack, is still stuck in the queue
 830   // behind the Tap which requires an ack.
 831   EXPECT_EQ(2U, GestureEventQueueSize());
 832
 833   SimulateGestureEvent(WebInputEvent::GestureShowPress,
 834                        WebGestureEvent::Touchscreen);
 835
 836   EXPECT_EQ(0U, GetAndResetSentGestureEventCount());
 837   // ShowPress has entered the queue.
 838   EXPECT_EQ(3U, GestureEventQueueSize());
 839
 840   SendInputEventACK(WebInputEvent::GestureTap,
 841                     INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
 842
 843   // Now that the Tap has been ACKed, the ShowPress events should fire
 844   // immediately.
 845   EXPECT_EQ(2U, GetAndResetSentGestureEventCount());
 846   EXPECT_EQ(0U, GestureEventQueueSize());
 847 }
 848
 849 // Test that a GestureScrollEnd | GestureFlingStart are deferred during the
 850 // debounce interval, that Scrolls are not and that the deferred events are
 851 // sent after that timer fires.
 852 TEST_F(GestureEventFilterTest, DebounceDefersFollowingGestureEvents) {
 853   set_debounce_interval_time_ms(3);
 854
 855   SimulateGestureEvent(WebInputEvent::GestureScrollUpdate,
 856                        WebGestureEvent::Touchscreen);
 857   EXPECT_EQ(1U, GetAndResetSentGestureEventCount());
 858   EXPECT_EQ(1U, GestureEventQueueSize());
 859   EXPECT_EQ(0U, GestureEventDebouncingQueueSize());
 860   EXPECT_TRUE(ScrollingInProgress());
 861
 862   SimulateGestureEvent(WebInputEvent::GestureScrollUpdate,
 863                        WebGestureEvent::Touchscreen);
 864   EXPECT_EQ(0U, GetAndResetSentGestureEventCount());
 865   EXPECT_EQ(2U, GestureEventQueueSize());
 866   EXPECT_EQ(0U, GestureEventDebouncingQueueSize());
 867   EXPECT_TRUE(ScrollingInProgress());
 868
 869   SimulateGestureEvent(WebInputEvent::GestureScrollEnd,
 870                        WebGestureEvent::Touchscreen);
 871   EXPECT_EQ(0U, GetAndResetSentGestureEventCount());
 872   EXPECT_EQ(2U, GestureEventQueueSize());
 873   EXPECT_EQ(1U, GestureEventDebouncingQueueSize());
 874
 875   SimulateGestureFlingStartEvent(0, 10, WebGestureEvent::Touchscreen);
 876   EXPECT_EQ(0U, GetAndResetSentGestureEventCount());
 877   EXPECT_EQ(2U, GestureEventQueueSize());
 878   EXPECT_EQ(2U, GestureEventDebouncingQueueSize());
 879
 880   SimulateGestureEvent(WebInputEvent::GestureTapDown,
 881                        WebGestureEvent::Touchscreen);
 882   EXPECT_EQ(0U, GetAndResetSentGestureEventCount());
 883   EXPECT_EQ(2U, GestureEventQueueSize());
 884   EXPECT_EQ(3U, GestureEventDebouncingQueueSize());
 885
 886   base::MessageLoop::current()->PostDelayedTask(
 887       FROM_HERE,
 888       base::MessageLoop::QuitClosure(),
 889       TimeDelta::FromMilliseconds(5));
 890   base::MessageLoop::current()->Run();
 891
 892   // The deferred events are correctly queued in coalescing queue.
 893   EXPECT_EQ(0U, GetAndResetSentGestureEventCount());
 894   EXPECT_EQ(5U, GestureEventQueueSize());
 895   EXPECT_EQ(0U, GestureEventDebouncingQueueSize());
 896   EXPECT_FALSE(ScrollingInProgress());
 897
 898   // Verify that the coalescing queue contains the correct events.
 899   WebInputEvent::Type expected[] = {
 900       WebInputEvent::GestureScrollUpdate,
 901       WebInputEvent::GestureScrollUpdate,
 902       WebInputEvent::GestureScrollEnd,
 903       WebInputEvent::GestureFlingStart};
 904
 905   for (unsigned i = 0; i < sizeof(expected) / sizeof(WebInputEvent::Type);
 906       i++) {
 907     WebGestureEvent merged_event = GestureEventQueueEventAt(i);
 908     EXPECT_EQ(expected[i], merged_event.type);
 909   }
 910 }
 911
 912 // Test that non-scroll events are deferred while scrolling during the debounce
 913 // interval and are discarded if a GestureScrollUpdate event arrives before the
 914 // interval end.
 915 TEST_F(GestureEventFilterTest, DebounceDropsDeferredEvents) {
 916   set_debounce_interval_time_ms(3);
 917   EXPECT_FALSE(ScrollingInProgress());
 918
 919   SimulateGestureEvent(WebInputEvent::GestureScrollUpdate,
 920                        WebGestureEvent::Touchscreen);
 921   EXPECT_EQ(1U, GetAndResetSentGestureEventCount());
 922   EXPECT_EQ(1U, GestureEventQueueSize());
 923   EXPECT_EQ(0U, GestureEventDebouncingQueueSize());
 924   EXPECT_TRUE(ScrollingInProgress());
 925
 926   // This event should get discarded.
 927   SimulateGestureEvent(WebInputEvent::GestureScrollEnd,
 928                        WebGestureEvent::Touchscreen);
 929   EXPECT_EQ(0U, GetAndResetSentGestureEventCount());
 930   EXPECT_EQ(1U, GestureEventQueueSize());
 931   EXPECT_EQ(1U, GestureEventDebouncingQueueSize());
 932
 933   SimulateGestureEvent(WebInputEvent::GestureScrollUpdate,
 934                        WebGestureEvent::Touchscreen);
 935   EXPECT_EQ(0U, GetAndResetSentGestureEventCount());
 936   EXPECT_EQ(2U, GestureEventQueueSize());
 937   EXPECT_EQ(0U, GestureEventDebouncingQueueSize());
 938   EXPECT_TRUE(ScrollingInProgress());
 939
 940   // Verify that the coalescing queue contains the correct events.
 941   WebInputEvent::Type expected[] = {
 942       WebInputEvent::GestureScrollUpdate,
 943       WebInputEvent::GestureScrollUpdate};
 944
 945   for (unsigned i = 0; i < sizeof(expected) / sizeof(WebInputEvent::Type);
 946       i++) {
 947     WebGestureEvent merged_event = GestureEventQueueEventAt(i);
 948     EXPECT_EQ(expected[i], merged_event.type);
 949   }
 950 }
 951
 952 TEST_F(GestureEventFilterTest, DropZeroVelocityFlings) {
 953   WebGestureEvent gesture_event;
 954   gesture_event.type = WebInputEvent::GestureFlingStart;
 955   gesture_event.sourceDevice = WebGestureEvent::Touchpad;
 956   gesture_event.data.flingStart.velocityX = 0.f;
 957   gesture_event.data.flingStart.velocityY = 0.f;
 958   ASSERT_EQ(0U, GetAndResetSentGestureEventCount());
 959   ASSERT_EQ(0U, GestureEventQueueSize());
 960   EXPECT_FALSE(SimulateGestureEvent(gesture_event));
 961   EXPECT_EQ(0U, GetAndResetSentGestureEventCount());
 962   EXPECT_EQ(0U, GestureEventQueueSize());
 963 }
 964
 965 }  // namespace content