content/browser/renderer_host/input/gesture_event_queue_unittest.cc

   1 // Copyright 2014 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_queue.h"
  13 #include "content/browser/renderer_host/input/touchpad_tap_suppression_controller.h"
  14 #include "content/common/input/input_event_ack_state.h"
  15 #include "content/common/input/synthetic_web_input_event_builders.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 blink::WebGestureDevice;
  21 using blink::WebGestureEvent;
  22 using blink::WebInputEvent;
  23
  24 namespace content {
  25
  26 class GestureEventQueueTest : public testing::Test,
  27                               public GestureEventQueueClient,
  28                               public TouchpadTapSuppressionControllerClient {
  29  public:
  30   GestureEventQueueTest()
  31       : acked_gesture_event_count_(0),
  32         sent_gesture_event_count_(0) {}
  33
  34   virtual ~GestureEventQueueTest() {}
  35
  36   // testing::Test
  37   virtual void SetUp() OVERRIDE {
  38     queue_.reset(new GestureEventQueue(this, this, DefaultConfig()));
  39   }
  40
  41   virtual void TearDown() OVERRIDE {
  42     // Process all pending tasks to avoid leaks.
  43     RunUntilIdle();
  44     queue_.reset();
  45   }
  46
  47   // GestureEventQueueClient
  48   virtual void SendGestureEventImmediately(
  49       const GestureEventWithLatencyInfo& event) OVERRIDE {
  50     ++sent_gesture_event_count_;
  51     if (sync_ack_result_) {
  52       scoped_ptr<InputEventAckState> ack_result = sync_ack_result_.Pass();
  53       SendInputEventACK(event.event.type, *ack_result);
  54     }
  55   }
  56
  57   virtual void OnGestureEventAck(
  58       const GestureEventWithLatencyInfo& event,
  59       InputEventAckState ack_result) OVERRIDE {
  60     ++acked_gesture_event_count_;
  61     last_acked_event_ = event.event;
  62     if (sync_followup_event_)
  63       SimulateGestureEvent(*sync_followup_event_.Pass());
  64   }
  65
  66   // TouchpadTapSuppressionControllerClient
  67   virtual void SendMouseEventImmediately(
  68       const MouseEventWithLatencyInfo& event) OVERRIDE {
  69   }
  70
  71  protected:
  72   static GestureEventQueue::Config DefaultConfig() {
  73     return GestureEventQueue::Config();
  74   }
  75
  76   void SetUpForDebounce(int interval_ms) {
  77     queue()->set_debounce_interval_time_ms_for_testing(interval_ms);
  78   }
  79
  80   // Returns the result of |GestureEventQueue::ShouldForward()|.
  81   bool SimulateGestureEvent(const WebGestureEvent& gesture) {
  82     GestureEventWithLatencyInfo gesture_with_latency(gesture,
  83                                                      ui::LatencyInfo());
  84     if (queue()->ShouldForward(gesture_with_latency)) {
  85       SendGestureEventImmediately(gesture_with_latency);
  86       return true;
  87     }
  88     return false;
  89   }
  90
  91   void SimulateGestureEvent(WebInputEvent::Type type,
  92                             WebGestureDevice sourceDevice) {
  93     SimulateGestureEvent(
  94         SyntheticWebGestureEventBuilder::Build(type, sourceDevice));
  95   }
  96
  97   void SimulateGestureScrollUpdateEvent(float dX, float dY, int modifiers) {
  98     SimulateGestureEvent(
  99         SyntheticWebGestureEventBuilder::BuildScrollUpdate(dX, dY, modifiers));
 100   }
 101
 102   void SimulateGesturePinchUpdateEvent(float scale,
 103                                        float anchorX,
 104                                        float anchorY,
 105                                        int modifiers) {
 106     SimulateGestureEvent(SyntheticWebGestureEventBuilder::BuildPinchUpdate(
 107         scale,
 108         anchorX,
 109         anchorY,
 110         modifiers,
 111         blink::WebGestureDeviceTouchscreen));
 112   }
 113
 114   void SimulateGestureFlingStartEvent(float velocityX,
 115                                       float velocityY,
 116                                       WebGestureDevice sourceDevice) {
 117     SimulateGestureEvent(
 118         SyntheticWebGestureEventBuilder::BuildFling(velocityX,
 119                                                     velocityY,
 120                                                     sourceDevice));
 121   }
 122
 123   void SendInputEventACK(WebInputEvent::Type type,
 124                          InputEventAckState ack) {
 125     queue()->ProcessGestureAck(ack, type, ui::LatencyInfo());
 126   }
 127
 128   void RunUntilIdle() {
 129     base::MessageLoop::current()->RunUntilIdle();
 130   }
 131
 132   size_t GetAndResetSentGestureEventCount() {
 133     size_t count = sent_gesture_event_count_;
 134     sent_gesture_event_count_ = 0;
 135     return count;
 136   }
 137
 138   size_t GetAndResetAckedGestureEventCount() {
 139     size_t count = acked_gesture_event_count_;
 140     acked_gesture_event_count_ = 0;
 141     return count;
 142   }
 143
 144   const WebGestureEvent& last_acked_event() const {
 145     return last_acked_event_;
 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                                WebGestureDevice sourceDevice) {
 154     sync_followup_event_.reset(new WebGestureEvent(
 155         SyntheticWebGestureEventBuilder::Build(type, sourceDevice)));
 156   }
 157
 158   unsigned GestureEventQueueSize() {
 159     return queue()->coalesced_gesture_events_.size();
 160   }
 161
 162   WebGestureEvent GestureEventSecondFromLastQueueEvent() {
 163     return queue()->coalesced_gesture_events_.at(
 164         GestureEventQueueSize() - 2).event;
 165   }
 166
 167   WebGestureEvent GestureEventLastQueueEvent() {
 168     return queue()->coalesced_gesture_events_.back().event;
 169   }
 170
 171   unsigned GestureEventDebouncingQueueSize() {
 172     return queue()->debouncing_deferral_queue_.size();
 173   }
 174
 175   WebGestureEvent GestureEventQueueEventAt(int i) {
 176     return queue()->coalesced_gesture_events_.at(i).event;
 177   }
 178
 179   bool ScrollingInProgress() {
 180     return queue()->scrolling_in_progress_;
 181   }
 182
 183   bool FlingInProgress() {
 184     return queue()->fling_in_progress_;
 185   }
 186
 187   bool WillIgnoreNextACK() {
 188     return queue()->ignore_next_ack_;
 189   }
 190
 191   GestureEventQueue* queue() const {
 192     return queue_.get();
 193   }
 194
 195  private:
 196   scoped_ptr<GestureEventQueue> queue_;
 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.
 207 class GestureEventQueueWithSourceTest
 208     : public GestureEventQueueTest,
 209       public testing::WithParamInterface<WebGestureDevice> {};
 210 #endif  // GTEST_HAS_PARAM_TEST
 211
 212 TEST_F(GestureEventQueueTest, CoalescesScrollGestureEvents) {
 213   // Test coalescing of only GestureScrollUpdate events.
 214   // Simulate gesture events.
 215
 216   // Sent.
 217   SimulateGestureEvent(WebInputEvent::GestureScrollBegin,
 218                        blink::WebGestureDeviceTouchscreen);
 219   EXPECT_EQ(1U, GetAndResetSentGestureEventCount());
 220
 221   // Enqueued.
 222   SimulateGestureScrollUpdateEvent(8, -5, 0);
 223
 224   // Make sure that the queue contains what we think it should.
 225   WebGestureEvent merged_event = GestureEventLastQueueEvent();
 226   EXPECT_EQ(2U, GestureEventQueueSize());
 227   EXPECT_EQ(WebInputEvent::GestureScrollUpdate, merged_event.type);
 228   EXPECT_EQ(blink::WebGestureDeviceTouchscreen, merged_event.sourceDevice);
 229
 230   // Coalesced.
 231   SimulateGestureScrollUpdateEvent(8, -6, 0);
 232
 233   // Check that coalescing updated the correct values.
 234   merged_event = GestureEventLastQueueEvent();
 235   EXPECT_EQ(WebInputEvent::GestureScrollUpdate, merged_event.type);
 236   EXPECT_EQ(0, merged_event.modifiers);
 237   EXPECT_EQ(16, merged_event.data.scrollUpdate.deltaX);
 238   EXPECT_EQ(-11, merged_event.data.scrollUpdate.deltaY);
 239   EXPECT_EQ(blink::WebGestureDeviceTouchscreen, merged_event.sourceDevice);
 240
 241   // Enqueued.
 242   SimulateGestureScrollUpdateEvent(8, -7, 1);
 243
 244   // Check that we didn't wrongly coalesce.
 245   merged_event = GestureEventLastQueueEvent();
 246   EXPECT_EQ(WebInputEvent::GestureScrollUpdate, merged_event.type);
 247   EXPECT_EQ(1, merged_event.modifiers);
 248   EXPECT_EQ(blink::WebGestureDeviceTouchscreen, merged_event.sourceDevice);
 249
 250   // Different.
 251   SimulateGestureEvent(WebInputEvent::GestureScrollEnd,
 252                        blink::WebGestureDeviceTouchscreen);
 253
 254   // Check that only the first event was sent.
 255   EXPECT_EQ(0U, GetAndResetSentGestureEventCount());
 256
 257   // Check that the ACK sends the second message.
 258   SendInputEventACK(WebInputEvent::GestureScrollBegin,
 259                     INPUT_EVENT_ACK_STATE_CONSUMED);
 260   RunUntilIdle();
 261   EXPECT_EQ(1U, GetAndResetAckedGestureEventCount());
 262   EXPECT_EQ(1U, GetAndResetSentGestureEventCount());
 263
 264   // Ack for queued coalesced event.
 265   SendInputEventACK(WebInputEvent::GestureScrollUpdate,
 266                     INPUT_EVENT_ACK_STATE_CONSUMED);
 267   RunUntilIdle();
 268   EXPECT_EQ(1U, GetAndResetAckedGestureEventCount());
 269   EXPECT_EQ(1U, GetAndResetSentGestureEventCount());
 270
 271   // Ack for queued uncoalesced event.
 272   SendInputEventACK(WebInputEvent::GestureScrollUpdate,
 273                     INPUT_EVENT_ACK_STATE_CONSUMED);
 274   RunUntilIdle();
 275   EXPECT_EQ(1U, GetAndResetAckedGestureEventCount());
 276   EXPECT_EQ(1U, GetAndResetSentGestureEventCount());
 277
 278   // After the final ack, the queue should be empty.
 279   SendInputEventACK(WebInputEvent::GestureScrollEnd,
 280                     INPUT_EVENT_ACK_STATE_CONSUMED);
 281   RunUntilIdle();
 282   EXPECT_EQ(1U, GetAndResetAckedGestureEventCount());
 283   EXPECT_EQ(0U, GetAndResetSentGestureEventCount());
 284 }
 285
 286 TEST_F(GestureEventQueueTest,
 287        DoesNotCoalesceScrollGestureEventsFromDifferentDevices) {
 288   // Test that GestureScrollUpdate events from Touchscreen and Touchpad do not
 289   // coalesce.
 290
 291   // Sent.
 292   SimulateGestureEvent(WebInputEvent::GestureScrollBegin,
 293                        blink::WebGestureDeviceTouchscreen);
 294   EXPECT_EQ(1U, GetAndResetSentGestureEventCount());
 295
 296   // Enqueued.
 297   SimulateGestureScrollUpdateEvent(8, -5, 0);
 298
 299   // Make sure that the queue contains what we think it should.
 300   EXPECT_EQ(2U, GestureEventQueueSize());
 301   EXPECT_EQ(blink::WebGestureDeviceTouchscreen,
 302             GestureEventLastQueueEvent().sourceDevice);
 303
 304   // Coalesced.
 305   SimulateGestureScrollUpdateEvent(8, -6, 0);
 306   EXPECT_EQ(2U, GestureEventQueueSize());
 307   EXPECT_EQ(blink::WebGestureDeviceTouchscreen,
 308             GestureEventLastQueueEvent().sourceDevice);
 309
 310   // Enqueued.
 311   SimulateGestureEvent(WebInputEvent::GestureScrollUpdate,
 312                        blink::WebGestureDeviceTouchpad);
 313   EXPECT_EQ(3U, GestureEventQueueSize());
 314   EXPECT_EQ(blink::WebGestureDeviceTouchpad,
 315             GestureEventLastQueueEvent().sourceDevice);
 316
 317   // Coalesced.
 318   SimulateGestureEvent(WebInputEvent::GestureScrollUpdate,
 319                        blink::WebGestureDeviceTouchpad);
 320   EXPECT_EQ(3U, GestureEventQueueSize());
 321   EXPECT_EQ(blink::WebGestureDeviceTouchpad,
 322             GestureEventLastQueueEvent().sourceDevice);
 323
 324   // Enqueued.
 325   SimulateGestureScrollUpdateEvent(8, -7, 0);
 326   EXPECT_EQ(4U, GestureEventQueueSize());
 327   EXPECT_EQ(blink::WebGestureDeviceTouchscreen,
 328             GestureEventLastQueueEvent().sourceDevice);
 329 }
 330
 331 TEST_F(GestureEventQueueTest, CoalescesScrollAndPinchEvents) {
 332   // Test coalescing of only GestureScrollUpdate events.
 333   // Simulate gesture events.
 334
 335   // Sent.
 336   SimulateGestureEvent(WebInputEvent::GestureScrollBegin,
 337                        blink::WebGestureDeviceTouchscreen);
 338
 339   // Sent.
 340   SimulateGestureEvent(WebInputEvent::GesturePinchBegin,
 341                        blink::WebGestureDeviceTouchscreen);
 342
 343   // Enqueued.
 344   SimulateGestureScrollUpdateEvent(8, -4, 1);
 345
 346   // Make sure that the queue contains what we think it should.
 347   WebGestureEvent merged_event = GestureEventLastQueueEvent();
 348   EXPECT_EQ(3U, GestureEventQueueSize());
 349   EXPECT_EQ(WebInputEvent::GestureScrollUpdate, merged_event.type);
 350
 351   // Coalesced without changing event order. Note anchor at (60, 60). Anchoring
 352   // from a point that is not the origin should still give us the right scroll.
 353   SimulateGesturePinchUpdateEvent(1.5, 60, 60, 1);
 354   EXPECT_EQ(4U, GestureEventQueueSize());
 355   merged_event = GestureEventLastQueueEvent();
 356   EXPECT_EQ(WebInputEvent::GesturePinchUpdate, merged_event.type);
 357   EXPECT_EQ(1.5, merged_event.data.pinchUpdate.scale);
 358   EXPECT_EQ(1, merged_event.modifiers);
 359   EXPECT_EQ(blink::WebGestureDeviceTouchscreen, merged_event.sourceDevice);
 360   merged_event = GestureEventSecondFromLastQueueEvent();
 361   EXPECT_EQ(WebInputEvent::GestureScrollUpdate, merged_event.type);
 362   EXPECT_EQ(8, merged_event.data.scrollUpdate.deltaX);
 363   EXPECT_EQ(-4, merged_event.data.scrollUpdate.deltaY);
 364   EXPECT_EQ(1, merged_event.modifiers);
 365   EXPECT_EQ(blink::WebGestureDeviceTouchscreen, merged_event.sourceDevice);
 366
 367   // Enqueued.
 368   SimulateGestureScrollUpdateEvent(6, -3, 1);
 369
 370   // Check whether coalesced correctly.
 371   EXPECT_EQ(4U, GestureEventQueueSize());
 372   merged_event = GestureEventLastQueueEvent();
 373   EXPECT_EQ(WebInputEvent::GesturePinchUpdate, merged_event.type);
 374   EXPECT_EQ(1.5, merged_event.data.pinchUpdate.scale);
 375   EXPECT_EQ(1, merged_event.modifiers);
 376   EXPECT_EQ(blink::WebGestureDeviceTouchscreen, merged_event.sourceDevice);
 377   merged_event = GestureEventSecondFromLastQueueEvent();
 378   EXPECT_EQ(WebInputEvent::GestureScrollUpdate, merged_event.type);
 379   EXPECT_EQ(12, merged_event.data.scrollUpdate.deltaX);
 380   EXPECT_EQ(-6, merged_event.data.scrollUpdate.deltaY);
 381   EXPECT_EQ(1, merged_event.modifiers);
 382   EXPECT_EQ(blink::WebGestureDeviceTouchscreen, merged_event.sourceDevice);
 383
 384   // Enqueued.
 385   SimulateGesturePinchUpdateEvent(2, 60, 60, 1);
 386
 387   // Check whether coalesced correctly.
 388   EXPECT_EQ(4U, GestureEventQueueSize());
 389   merged_event = GestureEventLastQueueEvent();
 390   EXPECT_EQ(WebInputEvent::GesturePinchUpdate, merged_event.type);
 391   EXPECT_EQ(3, merged_event.data.pinchUpdate.scale);
 392   EXPECT_EQ(1, merged_event.modifiers);
 393   EXPECT_EQ(blink::WebGestureDeviceTouchscreen, merged_event.sourceDevice);
 394   merged_event = GestureEventSecondFromLastQueueEvent();
 395   EXPECT_EQ(WebInputEvent::GestureScrollUpdate, merged_event.type);
 396   EXPECT_EQ(12, merged_event.data.scrollUpdate.deltaX);
 397   EXPECT_EQ(-6, merged_event.data.scrollUpdate.deltaY);
 398   EXPECT_EQ(1, merged_event.modifiers);
 399   EXPECT_EQ(blink::WebGestureDeviceTouchscreen, merged_event.sourceDevice);
 400
 401   // Enqueued.
 402   SimulateGesturePinchUpdateEvent(2, 60, 60, 1);
 403
 404   // Check whether coalesced correctly.
 405   EXPECT_EQ(4U, GestureEventQueueSize());
 406   merged_event = GestureEventLastQueueEvent();
 407   EXPECT_EQ(WebInputEvent::GesturePinchUpdate, merged_event.type);
 408   EXPECT_EQ(6, merged_event.data.pinchUpdate.scale);
 409   EXPECT_EQ(1, merged_event.modifiers);
 410   EXPECT_EQ(blink::WebGestureDeviceTouchscreen, merged_event.sourceDevice);
 411   merged_event = GestureEventSecondFromLastQueueEvent();
 412   EXPECT_EQ(WebInputEvent::GestureScrollUpdate, merged_event.type);
 413   EXPECT_EQ(12, merged_event.data.scrollUpdate.deltaX);
 414   EXPECT_EQ(-6, merged_event.data.scrollUpdate.deltaY);
 415   EXPECT_EQ(1, merged_event.modifiers);
 416   EXPECT_EQ(blink::WebGestureDeviceTouchscreen, merged_event.sourceDevice);
 417
 418   // Check that only the first event was sent.
 419   EXPECT_EQ(1U, GetAndResetSentGestureEventCount());
 420
 421   // Check that the ACK sends the second message.
 422   SendInputEventACK(WebInputEvent::GestureScrollBegin,
 423                     INPUT_EVENT_ACK_STATE_CONSUMED);
 424   RunUntilIdle();
 425   EXPECT_EQ(1U, GetAndResetSentGestureEventCount());
 426
 427   // Enqueued.
 428   SimulateGestureScrollUpdateEvent(6, -6, 1);
 429
 430   // Check whether coalesced correctly.
 431   EXPECT_EQ(3U, GestureEventQueueSize());
 432   merged_event = GestureEventLastQueueEvent();
 433   EXPECT_EQ(WebInputEvent::GesturePinchUpdate, merged_event.type);
 434   EXPECT_EQ(6, merged_event.data.pinchUpdate.scale);
 435   EXPECT_EQ(1, merged_event.modifiers);
 436   EXPECT_EQ(blink::WebGestureDeviceTouchscreen, merged_event.sourceDevice);
 437   merged_event = GestureEventSecondFromLastQueueEvent();
 438   EXPECT_EQ(WebInputEvent::GestureScrollUpdate, merged_event.type);
 439   EXPECT_EQ(13, merged_event.data.scrollUpdate.deltaX);
 440   EXPECT_EQ(-7, merged_event.data.scrollUpdate.deltaY);
 441   EXPECT_EQ(1, merged_event.modifiers);
 442   EXPECT_EQ(blink::WebGestureDeviceTouchscreen, merged_event.sourceDevice);
 443
 444   // At this point ACKs shouldn't be getting ignored.
 445   EXPECT_FALSE(WillIgnoreNextACK());
 446
 447   // Check that the ACK sends both scroll and pinch updates.
 448   SendInputEventACK(WebInputEvent::GesturePinchBegin,
 449                     INPUT_EVENT_ACK_STATE_CONSUMED);
 450   RunUntilIdle();
 451   EXPECT_EQ(2U, GetAndResetSentGestureEventCount());
 452
 453   // The next ACK should be getting ignored.
 454   EXPECT_TRUE(WillIgnoreNextACK());
 455
 456   // Enqueued.
 457   SimulateGestureScrollUpdateEvent(1, -1, 1);
 458
 459   // Check whether coalesced correctly.
 460   EXPECT_EQ(3U, GestureEventQueueSize());
 461   merged_event = GestureEventLastQueueEvent();
 462   EXPECT_EQ(WebInputEvent::GestureScrollUpdate, merged_event.type);
 463   EXPECT_EQ(1, merged_event.data.scrollUpdate.deltaX);
 464   EXPECT_EQ(-1, merged_event.data.scrollUpdate.deltaY);
 465   EXPECT_EQ(1, merged_event.modifiers);
 466   EXPECT_EQ(blink::WebGestureDeviceTouchscreen, merged_event.sourceDevice);
 467   merged_event = GestureEventSecondFromLastQueueEvent();
 468   EXPECT_EQ(WebInputEvent::GesturePinchUpdate, merged_event.type);
 469   EXPECT_EQ(6, merged_event.data.pinchUpdate.scale);
 470   EXPECT_EQ(1, merged_event.modifiers);
 471   EXPECT_EQ(blink::WebGestureDeviceTouchscreen, merged_event.sourceDevice);
 472
 473   // Enqueued.
 474   SimulateGestureScrollUpdateEvent(2, -2, 1);
 475
 476   // Coalescing scrolls should still work.
 477   EXPECT_EQ(3U, GestureEventQueueSize());
 478   merged_event = GestureEventLastQueueEvent();
 479   EXPECT_EQ(WebInputEvent::GestureScrollUpdate, merged_event.type);
 480   EXPECT_EQ(3, merged_event.data.scrollUpdate.deltaX);
 481   EXPECT_EQ(-3, merged_event.data.scrollUpdate.deltaY);
 482   EXPECT_EQ(1, merged_event.modifiers);
 483   EXPECT_EQ(blink::WebGestureDeviceTouchscreen, merged_event.sourceDevice);
 484   merged_event = GestureEventSecondFromLastQueueEvent();
 485   EXPECT_EQ(WebInputEvent::GesturePinchUpdate, merged_event.type);
 486   EXPECT_EQ(6, merged_event.data.pinchUpdate.scale);
 487   EXPECT_EQ(1, merged_event.modifiers);
 488   EXPECT_EQ(blink::WebGestureDeviceTouchscreen, merged_event.sourceDevice);
 489
 490   // Enqueued.
 491   SimulateGesturePinchUpdateEvent(0.5, 60, 60, 1);
 492
 493   // Check whether coalesced correctly.
 494   EXPECT_EQ(4U, GestureEventQueueSize());
 495   merged_event = GestureEventLastQueueEvent();
 496   EXPECT_EQ(WebInputEvent::GesturePinchUpdate, merged_event.type);
 497   EXPECT_EQ(0.5, merged_event.data.pinchUpdate.scale);
 498   EXPECT_EQ(1, merged_event.modifiers);
 499   EXPECT_EQ(blink::WebGestureDeviceTouchscreen, merged_event.sourceDevice);
 500   merged_event = GestureEventSecondFromLastQueueEvent();
 501   EXPECT_EQ(WebInputEvent::GestureScrollUpdate, merged_event.type);
 502   EXPECT_EQ(3, merged_event.data.scrollUpdate.deltaX);
 503   EXPECT_EQ(-3, merged_event.data.scrollUpdate.deltaY);
 504   EXPECT_EQ(1, merged_event.modifiers);
 505   EXPECT_EQ(blink::WebGestureDeviceTouchscreen, merged_event.sourceDevice);
 506
 507   // Check that the ACK gets ignored.
 508   SendInputEventACK(WebInputEvent::GestureScrollUpdate,
 509                     INPUT_EVENT_ACK_STATE_CONSUMED);
 510   EXPECT_EQ(WebInputEvent::GestureScrollUpdate, last_acked_event().type);
 511   RunUntilIdle();
 512   EXPECT_EQ(0U, GetAndResetSentGestureEventCount());
 513   // The flag should have been flipped back to false.
 514   EXPECT_FALSE(WillIgnoreNextACK());
 515
 516   // Enqueued.
 517   SimulateGestureScrollUpdateEvent(2, -2, 2);
 518
 519   // Shouldn't coalesce with different modifiers.
 520   EXPECT_EQ(4U, GestureEventQueueSize());
 521   merged_event = GestureEventLastQueueEvent();
 522   EXPECT_EQ(WebInputEvent::GestureScrollUpdate, merged_event.type);
 523   EXPECT_EQ(2, merged_event.data.scrollUpdate.deltaX);
 524   EXPECT_EQ(-2, merged_event.data.scrollUpdate.deltaY);
 525   EXPECT_EQ(2, merged_event.modifiers);
 526   EXPECT_EQ(blink::WebGestureDeviceTouchscreen, merged_event.sourceDevice);
 527   merged_event = GestureEventSecondFromLastQueueEvent();
 528   EXPECT_EQ(WebInputEvent::GesturePinchUpdate, merged_event.type);
 529   EXPECT_EQ(0.5, merged_event.data.pinchUpdate.scale);
 530   EXPECT_EQ(1, merged_event.modifiers);
 531   EXPECT_EQ(blink::WebGestureDeviceTouchscreen, merged_event.sourceDevice);
 532
 533   // Check that the ACK sends the next scroll pinch pair.
 534   SendInputEventACK(WebInputEvent::GesturePinchUpdate,
 535                     INPUT_EVENT_ACK_STATE_CONSUMED);
 536   EXPECT_EQ(WebInputEvent::GesturePinchUpdate, last_acked_event().type);
 537   RunUntilIdle();
 538   EXPECT_EQ(2U, GetAndResetSentGestureEventCount());
 539
 540   // Check that the ACK sends the second message.
 541   SendInputEventACK(WebInputEvent::GestureScrollUpdate,
 542                     INPUT_EVENT_ACK_STATE_CONSUMED);
 543   EXPECT_EQ(WebInputEvent::GestureScrollUpdate, last_acked_event().type);
 544   RunUntilIdle();
 545   EXPECT_EQ(0U, GetAndResetSentGestureEventCount());
 546
 547   // Check that the ACK sends the second event.
 548   SendInputEventACK(WebInputEvent::GesturePinchUpdate,
 549                     INPUT_EVENT_ACK_STATE_CONSUMED);
 550   EXPECT_EQ(WebInputEvent::GesturePinchUpdate, last_acked_event().type);
 551   RunUntilIdle();
 552   EXPECT_EQ(1U, GetAndResetSentGestureEventCount());
 553
 554   // Check that the queue is empty after ACK and no events get sent.
 555   SendInputEventACK(WebInputEvent::GestureScrollUpdate,
 556                     INPUT_EVENT_ACK_STATE_CONSUMED);
 557   EXPECT_EQ(WebInputEvent::GestureScrollUpdate, last_acked_event().type);
 558   RunUntilIdle();
 559   EXPECT_EQ(0U, GetAndResetSentGestureEventCount());
 560   EXPECT_EQ(0U, GestureEventQueueSize());
 561 }
 562
 563 TEST_F(GestureEventQueueTest, CoalescesMultiplePinchEventSequences) {
 564   // Simulate a pinch sequence.
 565   SimulateGestureEvent(WebInputEvent::GestureScrollBegin,
 566                        blink::WebGestureDeviceTouchscreen);
 567   SimulateGestureEvent(WebInputEvent::GesturePinchBegin,
 568                        blink::WebGestureDeviceTouchscreen);
 569
 570   SimulateGestureScrollUpdateEvent(8, -4, 1);
 571   // Make sure that the queue contains what we think it should.
 572   WebGestureEvent merged_event = GestureEventLastQueueEvent();
 573   size_t expected_events_in_queue = 3;
 574   EXPECT_EQ(expected_events_in_queue, GestureEventQueueSize());
 575   EXPECT_EQ(WebInputEvent::GestureScrollUpdate, merged_event.type);
 576
 577   // Coalesced without changing event order. Note anchor at (60, 60). Anchoring
 578   // from a point that is not the origin should still give us the right scroll.
 579   SimulateGesturePinchUpdateEvent(1.5, 60, 60, 1);
 580   EXPECT_EQ(++expected_events_in_queue, GestureEventQueueSize());
 581   merged_event = GestureEventLastQueueEvent();
 582   EXPECT_EQ(WebInputEvent::GesturePinchUpdate, merged_event.type);
 583   EXPECT_EQ(1.5, merged_event.data.pinchUpdate.scale);
 584   EXPECT_EQ(1, merged_event.modifiers);
 585   merged_event = GestureEventSecondFromLastQueueEvent();
 586   EXPECT_EQ(WebInputEvent::GestureScrollUpdate, merged_event.type);
 587   EXPECT_EQ(8, merged_event.data.scrollUpdate.deltaX);
 588   EXPECT_EQ(-4, merged_event.data.scrollUpdate.deltaY);
 589   EXPECT_EQ(1, merged_event.modifiers);
 590
 591   // Enqueued.
 592   SimulateGestureScrollUpdateEvent(6, -3, 1);
 593
 594   // Check whether coalesced correctly.
 595   EXPECT_EQ(expected_events_in_queue, GestureEventQueueSize());
 596   merged_event = GestureEventLastQueueEvent();
 597   EXPECT_EQ(WebInputEvent::GesturePinchUpdate, merged_event.type);
 598   EXPECT_EQ(1.5, merged_event.data.pinchUpdate.scale);
 599   EXPECT_EQ(1, merged_event.modifiers);
 600   merged_event = GestureEventSecondFromLastQueueEvent();
 601   EXPECT_EQ(WebInputEvent::GestureScrollUpdate, merged_event.type);
 602   EXPECT_EQ(12, merged_event.data.scrollUpdate.deltaX);
 603   EXPECT_EQ(-6, merged_event.data.scrollUpdate.deltaY);
 604   EXPECT_EQ(1, merged_event.modifiers);
 605
 606   // Now start another sequence before the previous sequence has been ack'ed.
 607   SimulateGestureEvent(WebInputEvent::GesturePinchEnd,
 608                        blink::WebGestureDeviceTouchscreen);
 609   SimulateGestureEvent(WebInputEvent::GestureScrollEnd,
 610                        blink::WebGestureDeviceTouchscreen);
 611   SimulateGestureEvent(WebInputEvent::GestureScrollBegin,
 612                        blink::WebGestureDeviceTouchscreen);
 613   SimulateGestureEvent(WebInputEvent::GesturePinchBegin,
 614                        blink::WebGestureDeviceTouchscreen);
 615
 616   SimulateGestureScrollUpdateEvent(8, -4, 1);
 617   // Make sure that the queue contains what we think it should.
 618   expected_events_in_queue += 5;
 619   merged_event = GestureEventLastQueueEvent();
 620   EXPECT_EQ(expected_events_in_queue, GestureEventQueueSize());
 621   EXPECT_EQ(WebInputEvent::GestureScrollUpdate, merged_event.type);
 622
 623   // Coalesced without changing event order. Note anchor at (60, 60). Anchoring
 624   // from a point that is not the origin should still give us the right scroll.
 625   SimulateGesturePinchUpdateEvent(1.5, 30, 30, 1);
 626   EXPECT_EQ(++expected_events_in_queue, GestureEventQueueSize());
 627   merged_event = GestureEventLastQueueEvent();
 628   EXPECT_EQ(WebInputEvent::GesturePinchUpdate, merged_event.type);
 629   EXPECT_EQ(1.5, merged_event.data.pinchUpdate.scale);
 630   EXPECT_EQ(1, merged_event.modifiers);
 631   merged_event = GestureEventSecondFromLastQueueEvent();
 632   EXPECT_EQ(WebInputEvent::GestureScrollUpdate, merged_event.type);
 633   EXPECT_EQ(8, merged_event.data.scrollUpdate.deltaX);
 634   EXPECT_EQ(-4, merged_event.data.scrollUpdate.deltaY);
 635   EXPECT_EQ(1, merged_event.modifiers);
 636
 637   // Enqueued.
 638   SimulateGestureScrollUpdateEvent(6, -3, 1);
 639
 640   // Check whether coalesced correctly.
 641   EXPECT_EQ(expected_events_in_queue, GestureEventQueueSize());
 642   merged_event = GestureEventLastQueueEvent();
 643   EXPECT_EQ(WebInputEvent::GesturePinchUpdate, merged_event.type);
 644   EXPECT_EQ(1.5, merged_event.data.pinchUpdate.scale);
 645   EXPECT_EQ(1, merged_event.modifiers);
 646   merged_event = GestureEventSecondFromLastQueueEvent();
 647   EXPECT_EQ(WebInputEvent::GestureScrollUpdate, merged_event.type);
 648   EXPECT_EQ(12, merged_event.data.scrollUpdate.deltaX);
 649   EXPECT_EQ(-6, merged_event.data.scrollUpdate.deltaY);
 650   EXPECT_EQ(1, merged_event.modifiers);
 651 }
 652
 653 TEST_F(GestureEventQueueTest, CoalescesPinchSequencesWithEarlyAck) {
 654   SimulateGestureEvent(WebInputEvent::GestureScrollBegin,
 655                        blink::WebGestureDeviceTouchscreen);
 656   SendInputEventACK(WebInputEvent::GestureScrollBegin,
 657                     INPUT_EVENT_ACK_STATE_CONSUMED);
 658
 659   SimulateGestureEvent(WebInputEvent::GesturePinchBegin,
 660                        blink::WebGestureDeviceTouchscreen);
 661   SendInputEventACK(WebInputEvent::GesturePinchBegin,
 662                     INPUT_EVENT_ACK_STATE_CONSUMED);
 663   // ScrollBegin and PinchBegin have been sent
 664   EXPECT_EQ(2U, GetAndResetSentGestureEventCount());
 665   EXPECT_EQ(0U, GestureEventQueueSize());
 666
 667   SimulateGestureScrollUpdateEvent(5, 5, 1);
 668   EXPECT_EQ(1U, GetAndResetSentGestureEventCount());
 669   EXPECT_EQ(WebInputEvent::GestureScrollUpdate,
 670             GestureEventLastQueueEvent().type);
 671   EXPECT_EQ(1U, GestureEventQueueSize());
 672
 673
 674   SimulateGesturePinchUpdateEvent(2, 60, 60, 1);
 675   EXPECT_EQ(0U, GetAndResetSentGestureEventCount());
 676   EXPECT_EQ(WebInputEvent::GesturePinchUpdate,
 677             GestureEventLastQueueEvent().type);
 678   EXPECT_EQ(2U, GestureEventQueueSize());
 679
 680   SimulateGesturePinchUpdateEvent(3, 60, 60, 1);
 681   EXPECT_EQ(0U, GetAndResetSentGestureEventCount());
 682   EXPECT_EQ(WebInputEvent::GesturePinchUpdate,
 683             GestureEventLastQueueEvent().type);
 684   EXPECT_EQ(2U, GestureEventQueueSize());
 685
 686   SimulateGestureScrollUpdateEvent(5, 5, 1);
 687   EXPECT_EQ(0U, GetAndResetSentGestureEventCount());
 688   // The coalesced pinch/scroll pair will have been re-arranged, with the
 689   // pinch following the scroll.
 690   EXPECT_EQ(WebInputEvent::GesturePinchUpdate,
 691             GestureEventLastQueueEvent().type);
 692   EXPECT_EQ(3U, GestureEventQueueSize());
 693
 694   SimulateGesturePinchUpdateEvent(4, 60, 60, 1);
 695   EXPECT_EQ(0U, GetAndResetSentGestureEventCount());
 696   EXPECT_EQ(3U, GestureEventQueueSize());
 697
 698   SendInputEventACK(WebInputEvent::GestureScrollUpdate,
 699                     INPUT_EVENT_ACK_STATE_CONSUMED);
 700   EXPECT_EQ(2U, GetAndResetSentGestureEventCount());
 701   EXPECT_EQ(2U, GestureEventQueueSize());
 702
 703   SendInputEventACK(WebInputEvent::GestureScrollUpdate,
 704                     INPUT_EVENT_ACK_STATE_CONSUMED);
 705   EXPECT_EQ(WebInputEvent::GestureScrollUpdate, last_acked_event().type);
 706
 707   SendInputEventACK(WebInputEvent::GesturePinchUpdate,
 708                     INPUT_EVENT_ACK_STATE_CONSUMED);
 709   EXPECT_EQ(WebInputEvent::GesturePinchUpdate, last_acked_event().type);
 710   EXPECT_EQ(2.f * 3.f * 4.f, last_acked_event().data.pinchUpdate.scale);
 711
 712   EXPECT_EQ(0U, GestureEventQueueSize());
 713 }
 714
 715 TEST_F(GestureEventQueueTest,
 716        DoesNotCoalescePinchGestureEventsWithDifferentModifiers) {
 717   // Insert an event to force queueing of gestures.
 718   SimulateGestureEvent(WebInputEvent::GestureTapCancel,
 719                        blink::WebGestureDeviceTouchscreen);
 720   EXPECT_EQ(1U, GetAndResetSentGestureEventCount());
 721   EXPECT_EQ(1U, GestureEventQueueSize());
 722
 723   SimulateGestureScrollUpdateEvent(5, 5, 1);
 724   EXPECT_EQ(0U, GetAndResetSentGestureEventCount());
 725   EXPECT_EQ(2U, GestureEventQueueSize());
 726
 727   SimulateGesturePinchUpdateEvent(3, 60, 60, 1);
 728   EXPECT_EQ(0U, GetAndResetSentGestureEventCount());
 729   EXPECT_EQ(3U, GestureEventQueueSize());
 730
 731   SimulateGestureScrollUpdateEvent(10, 15, 1);
 732   EXPECT_EQ(0U, GetAndResetSentGestureEventCount());
 733   EXPECT_EQ(3U, GestureEventQueueSize());
 734
 735   SimulateGesturePinchUpdateEvent(4, 60, 60, 1);
 736   EXPECT_EQ(0U, GetAndResetSentGestureEventCount());
 737   EXPECT_EQ(3U, GestureEventQueueSize());
 738
 739   // Using different modifiers should prevent coalescing.
 740   SimulateGesturePinchUpdateEvent(5, 60, 60, 2);
 741   EXPECT_EQ(0U, GetAndResetSentGestureEventCount());
 742   EXPECT_EQ(4U, GestureEventQueueSize());
 743
 744   SimulateGesturePinchUpdateEvent(6, 60, 60, 3);
 745   EXPECT_EQ(0U, GetAndResetSentGestureEventCount());
 746   EXPECT_EQ(5U, GestureEventQueueSize());
 747
 748   SendInputEventACK(WebInputEvent::GestureTapCancel,
 749                     INPUT_EVENT_ACK_STATE_CONSUMED);
 750   EXPECT_EQ(2U, GetAndResetSentGestureEventCount());
 751   EXPECT_EQ(4U, GestureEventQueueSize());
 752
 753   SendInputEventACK(WebInputEvent::GestureScrollUpdate,
 754                     INPUT_EVENT_ACK_STATE_CONSUMED);
 755   EXPECT_EQ(WebInputEvent::GestureScrollUpdate, last_acked_event().type);
 756   EXPECT_EQ(3U, GestureEventQueueSize());
 757
 758   SendInputEventACK(WebInputEvent::GesturePinchUpdate,
 759                     INPUT_EVENT_ACK_STATE_CONSUMED);
 760   EXPECT_EQ(WebInputEvent::GesturePinchUpdate, last_acked_event().type);
 761   EXPECT_EQ(3.f * 4.f, last_acked_event().data.pinchUpdate.scale);
 762   EXPECT_EQ(2U, GestureEventQueueSize());
 763   EXPECT_EQ(1U, GetAndResetSentGestureEventCount());
 764
 765   SendInputEventACK(WebInputEvent::GesturePinchUpdate,
 766                     INPUT_EVENT_ACK_STATE_CONSUMED);
 767   EXPECT_EQ(WebInputEvent::GesturePinchUpdate, last_acked_event().type);
 768   EXPECT_EQ(5.f, last_acked_event().data.pinchUpdate.scale);
 769   EXPECT_EQ(1U, GestureEventQueueSize());
 770   EXPECT_EQ(1U, GetAndResetSentGestureEventCount());
 771
 772   SendInputEventACK(WebInputEvent::GesturePinchUpdate,
 773                     INPUT_EVENT_ACK_STATE_CONSUMED);
 774   EXPECT_EQ(WebInputEvent::GesturePinchUpdate, last_acked_event().type);
 775   EXPECT_EQ(6.f, last_acked_event().data.pinchUpdate.scale);
 776   EXPECT_EQ(0U, GestureEventQueueSize());
 777 }
 778
 779 TEST_F(GestureEventQueueTest, CoalescesScrollAndPinchEventsIdentity) {
 780   // Insert an event to force queueing of gestures.
 781   SimulateGestureEvent(WebInputEvent::GestureTapCancel,
 782                        blink::WebGestureDeviceTouchscreen);
 783   EXPECT_EQ(1U, GetAndResetSentGestureEventCount());
 784   EXPECT_EQ(1U, GestureEventQueueSize());
 785
 786   // Ensure that coalescing yields an identity transform for any pinch/scroll
 787   // pair combined with its inverse.
 788   SimulateGestureScrollUpdateEvent(5, 5, 1);
 789   EXPECT_EQ(0U, GetAndResetSentGestureEventCount());
 790   EXPECT_EQ(2U, GestureEventQueueSize());
 791
 792   SimulateGesturePinchUpdateEvent(5, 10, 10, 1);
 793   EXPECT_EQ(0U, GetAndResetSentGestureEventCount());
 794   EXPECT_EQ(3U, GestureEventQueueSize());
 795
 796   SimulateGesturePinchUpdateEvent(.2f, 10, 10, 1);
 797   EXPECT_EQ(0U, GetAndResetSentGestureEventCount());
 798   EXPECT_EQ(3U, GestureEventQueueSize());
 799
 800   SimulateGestureScrollUpdateEvent(-5, -5, 1);
 801   EXPECT_EQ(0U, GetAndResetSentGestureEventCount());
 802   EXPECT_EQ(3U, GestureEventQueueSize());
 803
 804   SendInputEventACK(WebInputEvent::GestureTapCancel,
 805                     INPUT_EVENT_ACK_STATE_CONSUMED);
 806   EXPECT_EQ(2U, GetAndResetSentGestureEventCount());
 807   EXPECT_EQ(2U, GestureEventQueueSize());
 808
 809   SendInputEventACK(WebInputEvent::GestureScrollUpdate,
 810                     INPUT_EVENT_ACK_STATE_CONSUMED);
 811   EXPECT_EQ(WebInputEvent::GestureScrollUpdate, last_acked_event().type);
 812   EXPECT_EQ(0.f, last_acked_event().data.scrollUpdate.deltaX);
 813   EXPECT_EQ(0.f, last_acked_event().data.scrollUpdate.deltaY);
 814
 815   SendInputEventACK(WebInputEvent::GesturePinchUpdate,
 816                     INPUT_EVENT_ACK_STATE_CONSUMED);
 817   EXPECT_EQ(WebInputEvent::GesturePinchUpdate, last_acked_event().type);
 818   EXPECT_EQ(1.f, last_acked_event().data.pinchUpdate.scale);
 819   EXPECT_EQ(0U, GestureEventQueueSize());
 820
 821   // Insert an event to force queueing of gestures.
 822   SimulateGestureEvent(WebInputEvent::GestureTapCancel,
 823                        blink::WebGestureDeviceTouchscreen);
 824   EXPECT_EQ(1U, GetAndResetSentGestureEventCount());
 825   EXPECT_EQ(1U, GestureEventQueueSize());
 826
 827   // Ensure that coalescing yields an identity transform for any pinch/scroll
 828   // pair combined with its inverse.
 829   SimulateGesturePinchUpdateEvent(2, 10, 10, 1);
 830   EXPECT_EQ(0U, GetAndResetSentGestureEventCount());
 831   EXPECT_EQ(2U, GestureEventQueueSize());
 832
 833   SimulateGestureScrollUpdateEvent(20, 20, 1);
 834   EXPECT_EQ(0U, GetAndResetSentGestureEventCount());
 835   EXPECT_EQ(3U, GestureEventQueueSize());
 836
 837   SimulateGesturePinchUpdateEvent(0.5f, 20, 20, 1);
 838   EXPECT_EQ(0U, GetAndResetSentGestureEventCount());
 839   EXPECT_EQ(3U, GestureEventQueueSize());
 840
 841   SimulateGestureScrollUpdateEvent(-5, -5, 1);
 842   EXPECT_EQ(0U, GetAndResetSentGestureEventCount());
 843   EXPECT_EQ(3U, GestureEventQueueSize());
 844
 845   SendInputEventACK(WebInputEvent::GestureTapCancel,
 846                     INPUT_EVENT_ACK_STATE_CONSUMED);
 847   EXPECT_EQ(2U, GetAndResetSentGestureEventCount());
 848   EXPECT_EQ(2U, GestureEventQueueSize());
 849
 850   SendInputEventACK(WebInputEvent::GestureScrollUpdate,
 851                     INPUT_EVENT_ACK_STATE_CONSUMED);
 852   EXPECT_EQ(WebInputEvent::GestureScrollUpdate, last_acked_event().type);
 853   EXPECT_EQ(0.f, last_acked_event().data.scrollUpdate.deltaX);
 854   EXPECT_EQ(0.f, last_acked_event().data.scrollUpdate.deltaY);
 855
 856   SendInputEventACK(WebInputEvent::GesturePinchUpdate,
 857                     INPUT_EVENT_ACK_STATE_CONSUMED);
 858   EXPECT_EQ(WebInputEvent::GesturePinchUpdate, last_acked_event().type);
 859   EXPECT_EQ(1.f, last_acked_event().data.pinchUpdate.scale);
 860 }
 861
 862 // Tests a single event with an synchronous ack.
 863 TEST_F(GestureEventQueueTest, SimpleSyncAck) {
 864   set_synchronous_ack(INPUT_EVENT_ACK_STATE_CONSUMED);
 865   SimulateGestureEvent(WebInputEvent::GestureTapDown,
 866                        blink::WebGestureDeviceTouchscreen);
 867   EXPECT_EQ(1U, GetAndResetSentGestureEventCount());
 868   EXPECT_EQ(0U, GestureEventQueueSize());
 869   EXPECT_EQ(1U, GetAndResetAckedGestureEventCount());
 870 }
 871
 872 // Tests an event with an synchronous ack which enqueues an additional event.
 873 TEST_F(GestureEventQueueTest, SyncAckQueuesEvent) {
 874   scoped_ptr<WebGestureEvent> queued_event;
 875   set_synchronous_ack(INPUT_EVENT_ACK_STATE_CONSUMED);
 876   set_sync_followup_event(WebInputEvent::GestureShowPress,
 877                           blink::WebGestureDeviceTouchscreen);
 878   // This event enqueues the show press event.
 879   SimulateGestureEvent(WebInputEvent::GestureTapDown,
 880                        blink::WebGestureDeviceTouchscreen);
 881   EXPECT_EQ(2U, GetAndResetSentGestureEventCount());
 882   EXPECT_EQ(1U, GestureEventQueueSize());
 883   EXPECT_EQ(1U, GetAndResetAckedGestureEventCount());
 884
 885   SendInputEventACK(WebInputEvent::GestureShowPress,
 886                     INPUT_EVENT_ACK_STATE_CONSUMED);
 887   EXPECT_EQ(0U, GetAndResetSentGestureEventCount());
 888   EXPECT_EQ(0U, GestureEventQueueSize());
 889   EXPECT_EQ(1U, GetAndResetAckedGestureEventCount());
 890 }
 891
 892 // Tests an event with an async ack followed by an event with a sync ack.
 893 TEST_F(GestureEventQueueTest, AsyncThenSyncAck) {
 894   SimulateGestureEvent(WebInputEvent::GestureTapDown,
 895                        blink::WebGestureDeviceTouchscreen);
 896
 897   EXPECT_EQ(1U, GetAndResetSentGestureEventCount());
 898   EXPECT_EQ(1U, GestureEventQueueSize());
 899   EXPECT_EQ(0U, GetAndResetAckedGestureEventCount());
 900
 901   SimulateGestureEvent(WebInputEvent::GestureScrollBegin,
 902                        blink::WebGestureDeviceTouchscreen);
 903   set_synchronous_ack(INPUT_EVENT_ACK_STATE_CONSUMED);
 904   EXPECT_EQ(0U, GetAndResetSentGestureEventCount());
 905   EXPECT_EQ(2U, GestureEventQueueSize());
 906   EXPECT_EQ(0U, GetAndResetAckedGestureEventCount());
 907
 908   SendInputEventACK(WebInputEvent::GestureTapDown,
 909                     INPUT_EVENT_ACK_STATE_CONSUMED);
 910   EXPECT_EQ(1U, GetAndResetSentGestureEventCount());
 911   EXPECT_EQ(0U, GestureEventQueueSize());
 912   EXPECT_EQ(2U, GetAndResetAckedGestureEventCount());
 913 }
 914
 915 TEST_F(GestureEventQueueTest, CoalescesScrollAndPinchEventWithSyncAck) {
 916   // Simulate a pinch sequence.
 917   SimulateGestureEvent(WebInputEvent::GestureScrollBegin,
 918                        blink::WebGestureDeviceTouchscreen);
 919   EXPECT_EQ(1U, GetAndResetSentGestureEventCount());
 920   SimulateGestureEvent(WebInputEvent::GesturePinchBegin,
 921                        blink::WebGestureDeviceTouchscreen);
 922   EXPECT_EQ(0U, GetAndResetSentGestureEventCount());
 923
 924   SimulateGestureScrollUpdateEvent(8, -4, 1);
 925   // Make sure that the queue contains what we think it should.
 926   WebGestureEvent merged_event = GestureEventLastQueueEvent();
 927   EXPECT_EQ(3U, GestureEventQueueSize());
 928   EXPECT_EQ(WebInputEvent::GestureScrollUpdate, merged_event.type);
 929
 930   // Coalesced without changing event order. Note anchor at (60, 60). Anchoring
 931   // from a point that is not the origin should still give us the right scroll.
 932   SimulateGesturePinchUpdateEvent(1.5, 60, 60, 1);
 933   EXPECT_EQ(4U, GestureEventQueueSize());
 934
 935   SendInputEventACK(WebInputEvent::GestureScrollBegin,
 936                     INPUT_EVENT_ACK_STATE_CONSUMED);
 937   EXPECT_EQ(1U, GetAndResetSentGestureEventCount());
 938   EXPECT_EQ(3U, GestureEventQueueSize());
 939
 940   // Ack the PinchBegin, and schedule a synchronous ack for GestureScrollUpdate.
 941   set_synchronous_ack(INPUT_EVENT_ACK_STATE_CONSUMED);
 942   SendInputEventACK(WebInputEvent::GesturePinchBegin,
 943                     INPUT_EVENT_ACK_STATE_CONSUMED);
 944
 945   // Both GestureScrollUpdate and GesturePinchUpdate should have been sent.
 946   EXPECT_EQ(WebInputEvent::GestureScrollUpdate, last_acked_event().type);
 947   EXPECT_EQ(1U, GestureEventQueueSize());
 948   EXPECT_EQ(2U, GetAndResetSentGestureEventCount());
 949
 950   // Ack the final GesturePinchUpdate.
 951   SendInputEventACK(WebInputEvent::GesturePinchUpdate,
 952                     INPUT_EVENT_ACK_STATE_CONSUMED);
 953   EXPECT_EQ(WebInputEvent::GesturePinchUpdate, last_acked_event().type);
 954   EXPECT_EQ(0U, GestureEventQueueSize());
 955   EXPECT_EQ(0U, GetAndResetSentGestureEventCount());
 956 }
 957
 958 #if GTEST_HAS_PARAM_TEST
 959 TEST_P(GestureEventQueueWithSourceTest, GestureFlingCancelsFiltered) {
 960   WebGestureDevice source_device = GetParam();
 961
 962   // GFC without previous GFS is dropped.
 963   SimulateGestureEvent(WebInputEvent::GestureFlingCancel, source_device);
 964   EXPECT_EQ(0U, GetAndResetSentGestureEventCount());
 965   EXPECT_EQ(0U, GestureEventQueueSize());
 966
 967   // GFC after previous GFS is dispatched and acked.
 968   SimulateGestureFlingStartEvent(0, -10, source_device);
 969   EXPECT_TRUE(FlingInProgress());
 970   SendInputEventACK(WebInputEvent::GestureFlingStart,
 971                     INPUT_EVENT_ACK_STATE_CONSUMED);
 972   RunUntilIdle();
 973   EXPECT_EQ(1U, GetAndResetAckedGestureEventCount());
 974   SimulateGestureEvent(WebInputEvent::GestureFlingCancel, source_device);
 975   EXPECT_FALSE(FlingInProgress());
 976   EXPECT_EQ(2U, GetAndResetSentGestureEventCount());
 977   SendInputEventACK(WebInputEvent::GestureFlingCancel,
 978                     INPUT_EVENT_ACK_STATE_CONSUMED);
 979   RunUntilIdle();
 980   EXPECT_EQ(1U, GetAndResetAckedGestureEventCount());
 981   EXPECT_EQ(0U, GestureEventQueueSize());
 982
 983   // GFC before previous GFS is acked.
 984   SimulateGestureFlingStartEvent(0, -10, source_device);
 985   EXPECT_TRUE(FlingInProgress());
 986   SimulateGestureEvent(WebInputEvent::GestureFlingCancel, source_device);
 987   EXPECT_FALSE(FlingInProgress());
 988   EXPECT_EQ(1U, GetAndResetSentGestureEventCount());
 989   EXPECT_EQ(2U, GestureEventQueueSize());
 990
 991   // Advance state realistically.
 992   SendInputEventACK(WebInputEvent::GestureFlingStart,
 993                     INPUT_EVENT_ACK_STATE_CONSUMED);
 994   RunUntilIdle();
 995   EXPECT_EQ(1U, GetAndResetSentGestureEventCount());
 996   SendInputEventACK(WebInputEvent::GestureFlingCancel,
 997                     INPUT_EVENT_ACK_STATE_CONSUMED);
 998   RunUntilIdle();
 999   EXPECT_EQ(2U, GetAndResetAckedGestureEventCount());
1000   EXPECT_EQ(0U, GetAndResetSentGestureEventCount());
1001   EXPECT_EQ(0U, GestureEventQueueSize());
1002
1003   // GFS is added to the queue if another event is pending
1004   SimulateGestureScrollUpdateEvent(8, -7, 0);
1005   SimulateGestureFlingStartEvent(0, -10, source_device);
1006   EXPECT_EQ(2U, GestureEventQueueSize());
1007   EXPECT_EQ(1U, GetAndResetSentGestureEventCount());
1008   WebGestureEvent merged_event = GestureEventLastQueueEvent();
1009   EXPECT_EQ(WebInputEvent::GestureFlingStart, merged_event.type);
1010   EXPECT_TRUE(FlingInProgress());
1011   EXPECT_EQ(2U, GestureEventQueueSize());
1012
1013   // GFS in queue means that a GFC is added to the queue
1014   SimulateGestureEvent(WebInputEvent::GestureFlingCancel, source_device);
1015   merged_event =GestureEventLastQueueEvent();
1016   EXPECT_EQ(WebInputEvent::GestureFlingCancel, merged_event.type);
1017   EXPECT_FALSE(FlingInProgress());
1018   EXPECT_EQ(3U, GestureEventQueueSize());
1019
1020   // Adding a second GFC is dropped.
1021   SimulateGestureEvent(WebInputEvent::GestureFlingCancel, source_device);
1022   EXPECT_FALSE(FlingInProgress());
1023   EXPECT_EQ(3U, GestureEventQueueSize());
1024
1025   // Adding another GFS will add it to the queue.
1026   SimulateGestureFlingStartEvent(0, -10, source_device);
1027   merged_event = GestureEventLastQueueEvent();
1028   EXPECT_EQ(WebInputEvent::GestureFlingStart, merged_event.type);
1029   EXPECT_TRUE(FlingInProgress());
1030   EXPECT_EQ(4U, GestureEventQueueSize());
1031
1032   // GFS in queue means that a GFC is added to the queue
1033   SimulateGestureEvent(WebInputEvent::GestureFlingCancel, source_device);
1034   merged_event = GestureEventLastQueueEvent();
1035   EXPECT_EQ(WebInputEvent::GestureFlingCancel, merged_event.type);
1036   EXPECT_FALSE(FlingInProgress());
1037   EXPECT_EQ(5U, GestureEventQueueSize());
1038
1039   // Adding another GFC with a GFC already there is dropped.
1040   SimulateGestureEvent(WebInputEvent::GestureFlingCancel, source_device);
1041   merged_event = GestureEventLastQueueEvent();
1042   EXPECT_EQ(WebInputEvent::GestureFlingCancel, merged_event.type);
1043   EXPECT_FALSE(FlingInProgress());
1044   EXPECT_EQ(5U, GestureEventQueueSize());
1045 }
1046
1047 INSTANTIATE_TEST_CASE_P(AllSources,
1048                         GestureEventQueueWithSourceTest,
1049                         testing::Values(blink::WebGestureDeviceTouchscreen,
1050                                         blink::WebGestureDeviceTouchpad));
1051 #endif  // GTEST_HAS_PARAM_TEST
1052
1053 // Test that a GestureScrollEnd | GestureFlingStart are deferred during the
1054 // debounce interval, that Scrolls are not and that the deferred events are
1055 // sent after that timer fires.
1056 TEST_F(GestureEventQueueTest, DebounceDefersFollowingGestureEvents) {
1057   SetUpForDebounce(3);
1058
1059   SimulateGestureEvent(WebInputEvent::GestureScrollUpdate,
1060                        blink::WebGestureDeviceTouchscreen);
1061   EXPECT_EQ(1U, GetAndResetSentGestureEventCount());
1062   EXPECT_EQ(1U, GestureEventQueueSize());
1063   EXPECT_EQ(0U, GestureEventDebouncingQueueSize());
1064   EXPECT_TRUE(ScrollingInProgress());
1065
1066   SimulateGestureEvent(WebInputEvent::GestureScrollUpdate,
1067                        blink::WebGestureDeviceTouchscreen);
1068   EXPECT_EQ(0U, GetAndResetSentGestureEventCount());
1069   EXPECT_EQ(2U, GestureEventQueueSize());
1070   EXPECT_EQ(0U, GestureEventDebouncingQueueSize());
1071   EXPECT_TRUE(ScrollingInProgress());
1072
1073   SimulateGestureEvent(WebInputEvent::GestureScrollEnd,
1074                        blink::WebGestureDeviceTouchscreen);
1075   EXPECT_EQ(0U, GetAndResetSentGestureEventCount());
1076   EXPECT_EQ(2U, GestureEventQueueSize());
1077   EXPECT_EQ(1U, GestureEventDebouncingQueueSize());
1078
1079   SimulateGestureFlingStartEvent(0, 10, blink::WebGestureDeviceTouchscreen);
1080   EXPECT_EQ(0U, GetAndResetSentGestureEventCount());
1081   EXPECT_EQ(2U, GestureEventQueueSize());
1082   EXPECT_EQ(2U, GestureEventDebouncingQueueSize());
1083
1084   SimulateGestureEvent(WebInputEvent::GestureTapDown,
1085                        blink::WebGestureDeviceTouchscreen);
1086   EXPECT_EQ(0U, GetAndResetSentGestureEventCount());
1087   EXPECT_EQ(2U, GestureEventQueueSize());
1088   EXPECT_EQ(3U, GestureEventDebouncingQueueSize());
1089
1090   base::MessageLoop::current()->PostDelayedTask(
1091       FROM_HERE,
1092       base::MessageLoop::QuitClosure(),
1093       TimeDelta::FromMilliseconds(5));
1094   base::MessageLoop::current()->Run();
1095
1096   // The deferred events are correctly queued in coalescing queue.
1097   EXPECT_EQ(0U, GetAndResetSentGestureEventCount());
1098   EXPECT_EQ(5U, GestureEventQueueSize());
1099   EXPECT_EQ(0U, GestureEventDebouncingQueueSize());
1100   EXPECT_FALSE(ScrollingInProgress());
1101
1102   // Verify that the coalescing queue contains the correct events.
1103   WebInputEvent::Type expected[] = {
1104       WebInputEvent::GestureScrollUpdate,
1105       WebInputEvent::GestureScrollUpdate,
1106       WebInputEvent::GestureScrollEnd,
1107       WebInputEvent::GestureFlingStart};
1108
1109   for (unsigned i = 0; i < sizeof(expected) / sizeof(WebInputEvent::Type);
1110       i++) {
1111     WebGestureEvent merged_event = GestureEventQueueEventAt(i);
1112     EXPECT_EQ(expected[i], merged_event.type);
1113   }
1114 }
1115
1116 // Test that non-scroll events are deferred while scrolling during the debounce
1117 // interval and are discarded if a GestureScrollUpdate event arrives before the
1118 // interval end.
1119 TEST_F(GestureEventQueueTest, DebounceDropsDeferredEvents) {
1120   SetUpForDebounce(3);
1121
1122   EXPECT_FALSE(ScrollingInProgress());
1123
1124   SimulateGestureEvent(WebInputEvent::GestureScrollUpdate,
1125                        blink::WebGestureDeviceTouchscreen);
1126   EXPECT_EQ(1U, GetAndResetSentGestureEventCount());
1127   EXPECT_EQ(1U, GestureEventQueueSize());
1128   EXPECT_EQ(0U, GestureEventDebouncingQueueSize());
1129   EXPECT_TRUE(ScrollingInProgress());
1130
1131   // This event should get discarded.
1132   SimulateGestureEvent(WebInputEvent::GestureScrollEnd,
1133                        blink::WebGestureDeviceTouchscreen);
1134   EXPECT_EQ(0U, GetAndResetSentGestureEventCount());
1135   EXPECT_EQ(1U, GestureEventQueueSize());
1136   EXPECT_EQ(1U, GestureEventDebouncingQueueSize());
1137
1138   SimulateGestureEvent(WebInputEvent::GestureScrollUpdate,
1139                        blink::WebGestureDeviceTouchscreen);
1140   EXPECT_EQ(0U, GetAndResetSentGestureEventCount());
1141   EXPECT_EQ(2U, GestureEventQueueSize());
1142   EXPECT_EQ(0U, GestureEventDebouncingQueueSize());
1143   EXPECT_TRUE(ScrollingInProgress());
1144
1145   // Verify that the coalescing queue contains the correct events.
1146   WebInputEvent::Type expected[] = {
1147       WebInputEvent::GestureScrollUpdate,
1148       WebInputEvent::GestureScrollUpdate};
1149
1150   for (unsigned i = 0; i < sizeof(expected) / sizeof(WebInputEvent::Type);
1151       i++) {
1152     WebGestureEvent merged_event = GestureEventQueueEventAt(i);
1153     EXPECT_EQ(expected[i], merged_event.type);
1154   }
1155 }
1156
1157 }  // namespace content