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