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

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