src/content/browser/renderer_host/input/touch_event_queue_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 "base/basictypes.h"
   6 #include "base/logging.h"
   7 #include "base/memory/scoped_ptr.h"
   8 #include "base/message_loop/message_loop.h"
   9 #include "content/browser/renderer_host/input/timeout_monitor.h"
  10 #include "content/browser/renderer_host/input/touch_event_queue.h"
  11 #include "content/common/input/synthetic_web_input_event_builders.h"
  12 #include "testing/gtest/include/gtest/gtest.h"
  13 #include "third_party/WebKit/public/web/WebInputEvent.h"
  14
  15 using blink::WebGestureEvent;
  16 using blink::WebInputEvent;
  17 using blink::WebTouchEvent;
  18 using blink::WebTouchPoint;
  19
  20 namespace content {
  21 namespace {
  22
  23 const double kMinSecondsBetweenThrottledTouchmoves = 0.2;
  24
  25 base::TimeDelta DefaultTouchTimeoutDelay() {
  26   return base::TimeDelta::FromMilliseconds(1);
  27 }
  28 }  // namespace
  29
  30 class TouchEventQueueTest : public testing::Test,
  31                             public TouchEventQueueClient {
  32  public:
  33   TouchEventQueueTest()
  34       : sent_event_count_(0),
  35         acked_event_count_(0),
  36         last_acked_event_state_(INPUT_EVENT_ACK_STATE_UNKNOWN),
  37         slop_length_dips_(0),
  38         slop_includes_boundary_(true),
  39         touch_scrolling_mode_(TouchEventQueue::TOUCH_SCROLLING_MODE_DEFAULT) {}
  40
  41   virtual ~TouchEventQueueTest() {}
  42
  43   // testing::Test
  44   virtual void SetUp() OVERRIDE { ResetQueueWithConfig(CreateConfig()); }
  45
  46   virtual void TearDown() OVERRIDE {
  47     queue_.reset();
  48   }
  49
  50   // TouchEventQueueClient
  51   virtual void SendTouchEventImmediately(
  52       const TouchEventWithLatencyInfo& event) OVERRIDE {
  53     ++sent_event_count_;
  54     last_sent_event_ = event.event;
  55     if (sync_ack_result_)
  56       SendTouchEventAck(*sync_ack_result_.Pass());
  57   }
  58
  59   virtual void OnTouchEventAck(
  60       const TouchEventWithLatencyInfo& event,
  61       InputEventAckState ack_result) OVERRIDE {
  62     ++acked_event_count_;
  63     last_acked_event_ = event.event;
  64     last_acked_event_state_ = ack_result;
  65     if (followup_touch_event_) {
  66       scoped_ptr<WebTouchEvent> followup_touch_event =
  67           followup_touch_event_.Pass();
  68       SendTouchEvent(*followup_touch_event);
  69     }
  70     if (followup_gesture_event_) {
  71       scoped_ptr<WebGestureEvent> followup_gesture_event =
  72           followup_gesture_event_.Pass();
  73       queue_->OnGestureScrollEvent(
  74           GestureEventWithLatencyInfo(*followup_gesture_event,
  75                                       ui::LatencyInfo()));
  76     }
  77   }
  78
  79  protected:
  80   TouchEventQueue::Config CreateConfig() {
  81     TouchEventQueue::Config config;
  82     config.touch_scrolling_mode = touch_scrolling_mode_;
  83     config.touchmove_slop_suppression_length_dips = slop_length_dips_;
  84     config.touchmove_slop_suppression_region_includes_boundary =
  85         slop_includes_boundary_;
  86     return config;
  87   }
  88
  89   void SetTouchScrollingMode(TouchEventQueue::TouchScrollingMode mode) {
  90     touch_scrolling_mode_ = mode;
  91     ResetQueueWithConfig(CreateConfig());
  92   }
  93
  94   void SetUpForTouchMoveSlopTesting(double slop_length_dips,
  95                                     bool slop_includes_boundary) {
  96     slop_length_dips_ = slop_length_dips;
  97     slop_includes_boundary_ = slop_includes_boundary;
  98     ResetQueueWithConfig(CreateConfig());
  99   }
 100
 101   void SetUpForTimeoutTesting(base::TimeDelta timeout_delay) {
 102     TouchEventQueue::Config config = CreateConfig();
 103     config.touch_ack_timeout_delay = timeout_delay;
 104     config.touch_ack_timeout_supported = true;
 105     ResetQueueWithConfig(config);
 106   }
 107
 108   void SendTouchEvent(const WebTouchEvent& event) {
 109     queue_->QueueEvent(TouchEventWithLatencyInfo(event, ui::LatencyInfo()));
 110   }
 111
 112   void SendGestureEvent(WebInputEvent::Type type) {
 113     WebGestureEvent event;
 114     event.type = type;
 115     queue_->OnGestureScrollEvent(
 116         GestureEventWithLatencyInfo(event, ui::LatencyInfo()));
 117   }
 118
 119   void SendTouchEventAck(InputEventAckState ack_result) {
 120     queue_->ProcessTouchAck(ack_result, ui::LatencyInfo());
 121   }
 122
 123   void SendGestureEventAck(WebInputEvent::Type type,
 124                            InputEventAckState ack_result) {
 125     blink::WebGestureEvent gesture_event;
 126     gesture_event.type = type;
 127     GestureEventWithLatencyInfo event(gesture_event, ui::LatencyInfo());
 128     queue_->OnGestureEventAck(event, ack_result);
 129   }
 130
 131   void SetFollowupEvent(const WebTouchEvent& event) {
 132     followup_touch_event_.reset(new WebTouchEvent(event));
 133   }
 134
 135   void SetFollowupEvent(const WebGestureEvent& event) {
 136     followup_gesture_event_.reset(new WebGestureEvent(event));
 137   }
 138
 139   void SetSyncAckResult(InputEventAckState sync_ack_result) {
 140     sync_ack_result_.reset(new InputEventAckState(sync_ack_result));
 141   }
 142
 143   void PressTouchPoint(float x, float y) {
 144     touch_event_.PressPoint(x, y);
 145     SendTouchEvent();
 146   }
 147
 148   void MoveTouchPoint(int index, float x, float y) {
 149     touch_event_.MovePoint(index, x, y);
 150     SendTouchEvent();
 151   }
 152
 153   void MoveTouchPoints(int index0,
 154                        float x0,
 155                        float y0,
 156                        int index1,
 157                        float x1,
 158                        float y1) {
 159     touch_event_.MovePoint(index0, x0, y0);
 160     touch_event_.MovePoint(index1, x1, y1);
 161     SendTouchEvent();
 162   }
 163
 164   void ReleaseTouchPoint(int index) {
 165     touch_event_.ReleasePoint(index);
 166     SendTouchEvent();
 167   }
 168
 169   void CancelTouchPoint(int index) {
 170     touch_event_.CancelPoint(index);
 171     SendTouchEvent();
 172   }
 173
 174   void AdvanceTouchTime(double seconds) {
 175     touch_event_.timeStampSeconds += seconds;
 176   }
 177
 178   size_t GetAndResetAckedEventCount() {
 179     size_t count = acked_event_count_;
 180     acked_event_count_ = 0;
 181     return count;
 182   }
 183
 184   size_t GetAndResetSentEventCount() {
 185     size_t count = sent_event_count_;
 186     sent_event_count_ = 0;
 187     return count;
 188   }
 189
 190   bool IsPendingAckTouchStart() const {
 191     return queue_->IsPendingAckTouchStart();
 192   }
 193
 194   void OnHasTouchEventHandlers(bool has_handlers) {
 195     queue_->OnHasTouchEventHandlers(has_handlers);
 196   }
 197
 198   void SetAckTimeoutDisabled() { queue_->SetAckTimeoutEnabled(false); }
 199
 200   bool IsTimeoutEnabled() const { return queue_->ack_timeout_enabled(); }
 201
 202   bool IsTimeoutRunning() const { return queue_->IsTimeoutRunningForTesting(); }
 203
 204   bool HasPendingAsyncTouchMove() const {
 205     return queue_->HasPendingAsyncTouchMoveForTesting();
 206   }
 207
 208   size_t queued_event_count() const {
 209     return queue_->size();
 210   }
 211
 212   const WebTouchEvent& latest_event() const {
 213     return queue_->GetLatestEventForTesting().event;
 214   }
 215
 216   const WebTouchEvent& acked_event() const {
 217     return last_acked_event_;
 218   }
 219
 220   const WebTouchEvent& sent_event() const {
 221     return last_sent_event_;
 222   }
 223
 224   InputEventAckState acked_event_state() const {
 225     return last_acked_event_state_;
 226   }
 227
 228   static void RunTasksAndWait(base::TimeDelta delay) {
 229     base::MessageLoop::current()->PostDelayedTask(
 230         FROM_HERE, base::MessageLoop::QuitClosure(), delay);
 231     base::MessageLoop::current()->Run();
 232   }
 233
 234  private:
 235   void SendTouchEvent() {
 236     SendTouchEvent(touch_event_);
 237     touch_event_.ResetPoints();
 238   }
 239
 240   void ResetQueueWithConfig(const TouchEventQueue::Config& config) {
 241     queue_.reset(new TouchEventQueue(this, config));
 242     queue_->OnHasTouchEventHandlers(true);
 243   }
 244
 245   scoped_ptr<TouchEventQueue> queue_;
 246   size_t sent_event_count_;
 247   size_t acked_event_count_;
 248   WebTouchEvent last_sent_event_;
 249   WebTouchEvent last_acked_event_;
 250   InputEventAckState last_acked_event_state_;
 251   SyntheticWebTouchEvent touch_event_;
 252   scoped_ptr<WebTouchEvent> followup_touch_event_;
 253   scoped_ptr<WebGestureEvent> followup_gesture_event_;
 254   scoped_ptr<InputEventAckState> sync_ack_result_;
 255   double slop_length_dips_;
 256   bool slop_includes_boundary_;
 257   TouchEventQueue::TouchScrollingMode touch_scrolling_mode_;
 258   base::MessageLoopForUI message_loop_;
 259 };
 260
 261
 262 // Tests that touch-events are queued properly.
 263 TEST_F(TouchEventQueueTest, Basic) {
 264   PressTouchPoint(1, 1);
 265   EXPECT_EQ(1U, queued_event_count());
 266   EXPECT_EQ(1U, GetAndResetSentEventCount());
 267
 268   // The second touch should not be sent since one is already in queue.
 269   MoveTouchPoint(0, 5, 5);
 270   EXPECT_EQ(2U, queued_event_count());
 271   EXPECT_EQ(0U, GetAndResetSentEventCount());
 272
 273   // Receive an ACK for the first touch-event.
 274   SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
 275   EXPECT_EQ(1U, queued_event_count());
 276   EXPECT_EQ(1U, GetAndResetSentEventCount());
 277   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 278   EXPECT_EQ(WebInputEvent::TouchStart, acked_event().type);
 279   EXPECT_TRUE(acked_event().cancelable);
 280
 281   // Receive an ACK for the second touch-event.
 282   SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
 283   EXPECT_EQ(0U, queued_event_count());
 284   EXPECT_EQ(0U, GetAndResetSentEventCount());
 285   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 286   EXPECT_EQ(WebInputEvent::TouchMove, acked_event().type);
 287   EXPECT_TRUE(acked_event().cancelable);
 288 }
 289
 290 // Tests that the touch-queue is emptied if a page stops listening for touch
 291 // events.
 292 TEST_F(TouchEventQueueTest, QueueFlushedWhenHandlersRemoved) {
 293   OnHasTouchEventHandlers(true);
 294   EXPECT_EQ(0U, queued_event_count());
 295   EXPECT_EQ(0U, GetAndResetSentEventCount());
 296
 297   // Send a touch-press event.
 298   PressTouchPoint(1, 1);
 299   EXPECT_EQ(1U, GetAndResetSentEventCount());
 300
 301   ReleaseTouchPoint(0);
 302
 303   // Events will be queued until the first sent event is ack'ed.
 304   for (int i = 5; i < 15; ++i) {
 305     PressTouchPoint(1, 1);
 306     MoveTouchPoint(0, i, i);
 307     ReleaseTouchPoint(0);
 308   }
 309   EXPECT_EQ(32U, queued_event_count());
 310   EXPECT_EQ(0U, GetAndResetSentEventCount());
 311
 312   // Receive an ACK for the first touch-event. One of the queued touch-event
 313   // should be forwarded.
 314   SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
 315   EXPECT_EQ(31U, queued_event_count());
 316   EXPECT_EQ(1U, GetAndResetSentEventCount());
 317   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 318   EXPECT_EQ(WebInputEvent::TouchStart, acked_event().type);
 319
 320   // Flush the queue. The touch-event queue should now be emptied, but none of
 321   // the queued touch-events should be sent to the renderer.
 322   OnHasTouchEventHandlers(false);
 323   EXPECT_EQ(0U, queued_event_count());
 324   EXPECT_EQ(0U, GetAndResetSentEventCount());
 325   EXPECT_EQ(31U, GetAndResetAckedEventCount());
 326 }
 327
 328 // Tests that addition of a touch handler during a touch sequence will not cause
 329 // the remaining sequence to be forwarded.
 330 TEST_F(TouchEventQueueTest, ActiveSequenceNotForwardedWhenHandlersAdded) {
 331   OnHasTouchEventHandlers(false);
 332
 333   // Send a touch-press event while there is no handler.
 334   PressTouchPoint(1, 1);
 335   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 336   EXPECT_EQ(0U, GetAndResetSentEventCount());
 337   EXPECT_EQ(0U, queued_event_count());
 338
 339   OnHasTouchEventHandlers(true);
 340
 341   // The remaining touch sequence should not be forwarded.
 342   MoveTouchPoint(0, 5, 5);
 343   ReleaseTouchPoint(0);
 344   EXPECT_EQ(2U, GetAndResetAckedEventCount());
 345   EXPECT_EQ(0U, GetAndResetSentEventCount());
 346   EXPECT_EQ(0U, queued_event_count());
 347
 348   // A new touch sequence should resume forwarding.
 349   PressTouchPoint(1, 1);
 350   EXPECT_EQ(1U, queued_event_count());
 351   EXPECT_EQ(1U, GetAndResetSentEventCount());
 352 }
 353
 354 // Tests that removal of a touch handler during a touch sequence will prevent
 355 // the remaining sequence from being forwarded, even if another touch handler is
 356 // registered during the same touch sequence.
 357 TEST_F(TouchEventQueueTest, ActiveSequenceDroppedWhenHandlersRemoved) {
 358   // Send a touch-press event.
 359   PressTouchPoint(1, 1);
 360   EXPECT_EQ(1U, GetAndResetSentEventCount());
 361   EXPECT_EQ(1U, queued_event_count());
 362
 363   // Queue a touch-move event.
 364   MoveTouchPoint(0, 5, 5);
 365   EXPECT_EQ(2U, queued_event_count());
 366   EXPECT_EQ(0U, GetAndResetAckedEventCount());
 367   EXPECT_EQ(0U, GetAndResetSentEventCount());
 368
 369   // Touch handle deregistration should flush the queue.
 370   OnHasTouchEventHandlers(false);
 371   EXPECT_EQ(2U, GetAndResetAckedEventCount());
 372   EXPECT_EQ(0U, queued_event_count());
 373
 374   // The ack should be ignored as the touch queue is now empty.
 375   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS);
 376   EXPECT_EQ(0U, GetAndResetAckedEventCount());
 377   EXPECT_EQ(0U, queued_event_count());
 378
 379   // Events should be dropped while there is no touch handler.
 380   MoveTouchPoint(0, 10, 10);
 381   EXPECT_EQ(0U, queued_event_count());
 382   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 383   EXPECT_EQ(0U, GetAndResetSentEventCount());
 384
 385   // Simulate touch handler registration in the middle of a touch sequence.
 386   OnHasTouchEventHandlers(true);
 387
 388   // The touch end for the interrupted sequence should be dropped.
 389   ReleaseTouchPoint(0);
 390   EXPECT_EQ(0U, queued_event_count());
 391   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 392   EXPECT_EQ(0U, GetAndResetSentEventCount());
 393
 394   // A new touch sequence should be forwarded properly.
 395   PressTouchPoint(1, 1);
 396   EXPECT_EQ(1U, queued_event_count());
 397   EXPECT_EQ(1U, GetAndResetSentEventCount());
 398 }
 399
 400 // Tests that touch-events are coalesced properly in the queue.
 401 TEST_F(TouchEventQueueTest, Coalesce) {
 402   // Send a touch-press event.
 403   PressTouchPoint(1, 1);
 404   EXPECT_EQ(1U, GetAndResetSentEventCount());
 405
 406   // Send a few touch-move events, followed by a touch-release event. All the
 407   // touch-move events should be coalesced into a single event.
 408   for (int i = 5; i < 15; ++i)
 409     MoveTouchPoint(0, i, i);
 410
 411   EXPECT_EQ(0U, GetAndResetSentEventCount());
 412   ReleaseTouchPoint(0);
 413   EXPECT_EQ(0U, GetAndResetSentEventCount());
 414   EXPECT_EQ(3U, queued_event_count());
 415
 416   // ACK the press.  Coalesced touch-move events should be sent.
 417   SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
 418   EXPECT_EQ(2U, queued_event_count());
 419   EXPECT_EQ(1U, GetAndResetSentEventCount());
 420   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 421   EXPECT_EQ(WebInputEvent::TouchStart, acked_event().type);
 422   EXPECT_EQ(INPUT_EVENT_ACK_STATE_CONSUMED, acked_event_state());
 423
 424   // ACK the moves.
 425   SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
 426   EXPECT_EQ(1U, queued_event_count());
 427   EXPECT_EQ(1U, GetAndResetSentEventCount());
 428   EXPECT_EQ(10U, GetAndResetAckedEventCount());
 429   EXPECT_EQ(WebInputEvent::TouchMove, acked_event().type);
 430
 431   // ACK the release.
 432   SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
 433   EXPECT_EQ(0U, queued_event_count());
 434   EXPECT_EQ(0U, GetAndResetSentEventCount());
 435   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 436   EXPECT_EQ(WebInputEvent::TouchEnd, acked_event().type);
 437 }
 438
 439 // Tests that an event that has already been sent but hasn't been ack'ed yet
 440 // doesn't get coalesced with newer events.
 441 TEST_F(TouchEventQueueTest, SentTouchEventDoesNotCoalesce) {
 442   // Send a touch-press event.
 443   PressTouchPoint(1, 1);
 444   EXPECT_EQ(1U, GetAndResetSentEventCount());
 445
 446   // Send a few touch-move events, followed by a touch-release event. All the
 447   // touch-move events should be coalesced into a single event.
 448   for (int i = 5; i < 15; ++i)
 449     MoveTouchPoint(0, i, i);
 450
 451   EXPECT_EQ(0U, GetAndResetSentEventCount());
 452   EXPECT_EQ(2U, queued_event_count());
 453
 454   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
 455   EXPECT_EQ(1U, GetAndResetSentEventCount());
 456   EXPECT_EQ(1U, queued_event_count());
 457
 458   // The coalesced touch-move event has been sent to the renderer. Any new
 459   // touch-move event should not be coalesced with the sent event.
 460   MoveTouchPoint(0, 5, 5);
 461   EXPECT_EQ(2U, queued_event_count());
 462
 463   MoveTouchPoint(0, 7, 7);
 464   EXPECT_EQ(2U, queued_event_count());
 465 }
 466
 467 // Tests that coalescing works correctly for multi-touch events.
 468 TEST_F(TouchEventQueueTest, MultiTouch) {
 469   // Press the first finger.
 470   PressTouchPoint(1, 1);
 471   EXPECT_EQ(1U, GetAndResetSentEventCount());
 472
 473   // Move the finger.
 474   MoveTouchPoint(0, 5, 5);
 475   EXPECT_EQ(2U, queued_event_count());
 476
 477   // Now press a second finger.
 478   PressTouchPoint(2, 2);
 479   EXPECT_EQ(3U, queued_event_count());
 480
 481   // Move both fingers.
 482   MoveTouchPoints(0, 10, 10, 1, 20, 20);
 483   MoveTouchPoint(1, 20, 20);
 484   EXPECT_EQ(4U, queued_event_count());
 485
 486   // Move only one finger now.
 487   MoveTouchPoint(0, 15, 15);
 488   EXPECT_EQ(4U, queued_event_count());
 489
 490   // Move the other finger.
 491   MoveTouchPoint(1, 25, 25);
 492   EXPECT_EQ(4U, queued_event_count());
 493
 494   // Make sure both fingers are marked as having been moved in the coalesced
 495   // event.
 496   const WebTouchEvent& event = latest_event();
 497   EXPECT_EQ(WebTouchPoint::StateMoved, event.touches[0].state);
 498   EXPECT_EQ(WebTouchPoint::StateMoved, event.touches[1].state);
 499 }
 500
 501 // Tests that if a touch-event queue is destroyed in response to a touch-event
 502 // in the renderer, then there is no crash when the ACK for that touch-event
 503 // comes back.
 504 TEST_F(TouchEventQueueTest, AckAfterQueueFlushed) {
 505   // Send some touch-events to the renderer.
 506   PressTouchPoint(1, 1);
 507   EXPECT_EQ(1U, GetAndResetSentEventCount());
 508   EXPECT_EQ(1U, queued_event_count());
 509
 510   MoveTouchPoint(0, 10, 10);
 511   EXPECT_EQ(0U, GetAndResetSentEventCount());
 512   EXPECT_EQ(2U, queued_event_count());
 513
 514   // Receive an ACK for the press. This should cause the queued touch-move to
 515   // be sent to the renderer.
 516   SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
 517   EXPECT_EQ(1U, GetAndResetSentEventCount());
 518   EXPECT_EQ(1U, queued_event_count());
 519
 520   OnHasTouchEventHandlers(false);
 521   EXPECT_EQ(0U, GetAndResetSentEventCount());
 522   EXPECT_EQ(0U, queued_event_count());
 523
 524   // Now receive an ACK for the move.
 525   SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
 526   EXPECT_EQ(0U, GetAndResetSentEventCount());
 527   EXPECT_EQ(0U, queued_event_count());
 528 }
 529
 530 // Tests that touch-move events are not sent to the renderer if the preceding
 531 // touch-press event did not have a consumer (and consequently, did not hit the
 532 // main thread in the renderer). Also tests that all queued/coalesced touch
 533 // events are flushed immediately when the ACK for the touch-press comes back
 534 // with NO_CONSUMER status.
 535 TEST_F(TouchEventQueueTest, NoConsumer) {
 536   // The first touch-press should reach the renderer.
 537   PressTouchPoint(1, 1);
 538   EXPECT_EQ(1U, GetAndResetSentEventCount());
 539
 540   // The second touch should not be sent since one is already in queue.
 541   MoveTouchPoint(0, 5, 5);
 542   EXPECT_EQ(0U, GetAndResetSentEventCount());
 543   EXPECT_EQ(2U, queued_event_count());
 544
 545   // Receive an ACK for the first touch-event. This should release the queued
 546   // touch-event, but it should not be sent to the renderer.
 547   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS);
 548   EXPECT_EQ(0U, queued_event_count());
 549   EXPECT_EQ(WebInputEvent::TouchMove, acked_event().type);
 550   EXPECT_EQ(2U, GetAndResetAckedEventCount());
 551   EXPECT_EQ(0U, GetAndResetSentEventCount());
 552
 553   // Send a release event. This should not reach the renderer.
 554   ReleaseTouchPoint(0);
 555   EXPECT_EQ(0U, GetAndResetSentEventCount());
 556   EXPECT_EQ(WebInputEvent::TouchEnd, acked_event().type);
 557   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 558
 559   // Send a press-event, followed by move and release events, and another press
 560   // event, before the ACK for the first press event comes back. All of the
 561   // events should be queued first. After the NO_CONSUMER ack for the first
 562   // touch-press, all events upto the second touch-press should be flushed.
 563   PressTouchPoint(10, 10);
 564   EXPECT_EQ(1U, GetAndResetSentEventCount());
 565
 566   MoveTouchPoint(0, 5, 5);
 567   MoveTouchPoint(0, 6, 5);
 568   ReleaseTouchPoint(0);
 569
 570   PressTouchPoint(6, 5);
 571   EXPECT_EQ(0U, GetAndResetSentEventCount());
 572   // The queue should hold the first sent touch-press event, the coalesced
 573   // touch-move event, the touch-end event and the second touch-press event.
 574   EXPECT_EQ(4U, queued_event_count());
 575
 576   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS);
 577   EXPECT_EQ(1U, GetAndResetSentEventCount());
 578   EXPECT_EQ(WebInputEvent::TouchEnd, acked_event().type);
 579   EXPECT_EQ(4U, GetAndResetAckedEventCount());
 580   EXPECT_EQ(1U, queued_event_count());
 581
 582   // ACK the second press event as NO_CONSUMER too.
 583   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS);
 584   EXPECT_EQ(0U, GetAndResetSentEventCount());
 585   EXPECT_EQ(WebInputEvent::TouchStart, acked_event().type);
 586   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 587   EXPECT_EQ(0U, queued_event_count());
 588
 589   // Send a second press event. Even though the first touch press had
 590   // NO_CONSUMER, this press event should reach the renderer.
 591   PressTouchPoint(1, 1);
 592   EXPECT_EQ(1U, GetAndResetSentEventCount());
 593   EXPECT_EQ(1U, queued_event_count());
 594   SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
 595   EXPECT_EQ(WebInputEvent::TouchStart, acked_event().type);
 596   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 597 }
 598
 599 TEST_F(TouchEventQueueTest, ConsumerIgnoreMultiFinger) {
 600   // Press two touch points and move them around a bit. The renderer consumes
 601   // the events for the first touch point, but returns NO_CONSUMER_EXISTS for
 602   // the second touch point.
 603
 604   PressTouchPoint(1, 1);
 605   EXPECT_EQ(1U, GetAndResetSentEventCount());
 606
 607   MoveTouchPoint(0, 5, 5);
 608
 609   PressTouchPoint(10, 10);
 610
 611   MoveTouchPoint(0, 2, 2);
 612
 613   MoveTouchPoint(1, 4, 10);
 614
 615   MoveTouchPoints(0, 10, 10, 1, 20, 20);
 616
 617   // Since the first touch-press is still pending ACK, no other event should
 618   // have been sent to the renderer.
 619   EXPECT_EQ(0U, GetAndResetSentEventCount());
 620   // The queue includes the two presses, the first touch-move of the first
 621   // point, and a coalesced touch-move of both points.
 622   EXPECT_EQ(4U, queued_event_count());
 623
 624   // ACK the first press as CONSUMED. This should cause the first touch-move of
 625   // the first touch-point to be dispatched.
 626   SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
 627   EXPECT_EQ(1U, GetAndResetSentEventCount());
 628   EXPECT_EQ(3U, queued_event_count());
 629
 630   // ACK the first move as CONSUMED.
 631   SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
 632   EXPECT_EQ(1U, GetAndResetSentEventCount());
 633   EXPECT_EQ(2U, queued_event_count());
 634
 635   // ACK the second press as NO_CONSUMER_EXISTS. This will dequeue the coalesced
 636   // touch-move event (which contains both touch points). Although the second
 637   // touch-point does not need to be sent to the renderer, the first touch-point
 638   // did move, and so the coalesced touch-event will be sent to the renderer.
 639   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS);
 640   EXPECT_EQ(1U, GetAndResetSentEventCount());
 641   EXPECT_EQ(1U, queued_event_count());
 642
 643   // ACK the coalesced move as NOT_CONSUMED.
 644   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
 645   EXPECT_EQ(0U, GetAndResetSentEventCount());
 646   EXPECT_EQ(0U, queued_event_count());
 647
 648   // Move just the second touch point. Because the first touch point did not
 649   // move, this event should not reach the renderer.
 650   MoveTouchPoint(1, 30, 30);
 651   EXPECT_EQ(0U, GetAndResetSentEventCount());
 652   EXPECT_EQ(0U, queued_event_count());
 653
 654   // Move just the first touch point. This should reach the renderer.
 655   MoveTouchPoint(0, 10, 10);
 656   EXPECT_EQ(1U, GetAndResetSentEventCount());
 657   EXPECT_EQ(1U, queued_event_count());
 658
 659   // Move both fingers. This event should reach the renderer (after the ACK of
 660   // the previous move event is received), because the first touch point did
 661   // move.
 662   MoveTouchPoints(0, 15, 15, 1, 25, 25);
 663   EXPECT_EQ(0U, GetAndResetSentEventCount());
 664
 665   SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
 666   EXPECT_EQ(1U, GetAndResetSentEventCount());
 667   EXPECT_EQ(1U, queued_event_count());
 668
 669   SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
 670   EXPECT_EQ(0U, GetAndResetSentEventCount());
 671   EXPECT_EQ(0U, queued_event_count());
 672
 673   // Release the first finger. Then move the second finger around some, then
 674   // press another finger. Once the release event is ACKed, the move events of
 675   // the second finger should be immediately released to the view, and the
 676   // touch-press event should be dispatched to the renderer.
 677   ReleaseTouchPoint(0);
 678   EXPECT_EQ(1U, GetAndResetSentEventCount());
 679   EXPECT_EQ(1U, queued_event_count());
 680
 681   MoveTouchPoint(1, 40, 40);
 682
 683   MoveTouchPoint(1, 50, 50);
 684
 685   PressTouchPoint(1, 1);
 686
 687   MoveTouchPoint(1, 30, 30);
 688   EXPECT_EQ(0U, GetAndResetSentEventCount());
 689   EXPECT_EQ(4U, queued_event_count());
 690
 691   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
 692   EXPECT_EQ(1U, GetAndResetSentEventCount());
 693   EXPECT_EQ(2U, queued_event_count());
 694   EXPECT_EQ(WebInputEvent::TouchMove, acked_event().type);
 695
 696   // ACK the press with NO_CONSUMED_EXISTS. This should release the queued
 697   // touch-move events to the view.
 698   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS);
 699   EXPECT_EQ(0U, GetAndResetSentEventCount());
 700   EXPECT_EQ(0U, queued_event_count());
 701   EXPECT_EQ(WebInputEvent::TouchMove, acked_event().type);
 702
 703   ReleaseTouchPoint(2);
 704   ReleaseTouchPoint(1);
 705   EXPECT_EQ(0U, GetAndResetSentEventCount());
 706   EXPECT_EQ(0U, queued_event_count());
 707 }
 708
 709 // Tests that touch-event's enqueued via a touch ack are properly handled.
 710 TEST_F(TouchEventQueueTest, AckWithFollowupEvents) {
 711   // Queue a touch down.
 712   PressTouchPoint(1, 1);
 713   EXPECT_EQ(1U, queued_event_count());
 714   EXPECT_EQ(1U, GetAndResetSentEventCount());
 715   EXPECT_EQ(0U, GetAndResetAckedEventCount());
 716
 717   // Create a touch event that will be queued synchronously by a touch ack.
 718   // Note, this will be triggered by all subsequent touch acks.
 719   WebTouchEvent followup_event;
 720   followup_event.type = WebInputEvent::TouchStart;
 721   followup_event.touchesLength = 1;
 722   followup_event.touches[0].id = 1;
 723   followup_event.touches[0].state = WebTouchPoint::StatePressed;
 724   SetFollowupEvent(followup_event);
 725
 726   // Receive an ACK for the press. This should cause the followup touch-move to
 727   // be sent to the renderer.
 728   SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
 729   EXPECT_EQ(1U, queued_event_count());
 730   EXPECT_EQ(1U, GetAndResetSentEventCount());
 731   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 732   EXPECT_EQ(INPUT_EVENT_ACK_STATE_CONSUMED, acked_event_state());
 733   EXPECT_EQ(WebInputEvent::TouchStart, acked_event().type);
 734
 735   // Queue another event.
 736   MoveTouchPoint(0, 2, 2);
 737   EXPECT_EQ(2U, queued_event_count());
 738
 739   // Receive an ACK for the touch-move followup event. This should cause the
 740   // subsequent touch move event be sent to the renderer.
 741   SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
 742   EXPECT_EQ(1U, queued_event_count());
 743   EXPECT_EQ(1U, GetAndResetSentEventCount());
 744   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 745 }
 746
 747 // Tests that touch-events can be synchronously ack'ed.
 748 TEST_F(TouchEventQueueTest, SynchronousAcks) {
 749   // TouchStart
 750   SetSyncAckResult(INPUT_EVENT_ACK_STATE_CONSUMED);
 751   PressTouchPoint(1, 1);
 752   EXPECT_EQ(0U, queued_event_count());
 753   EXPECT_EQ(1U, GetAndResetSentEventCount());
 754   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 755
 756   // TouchMove
 757   SetSyncAckResult(INPUT_EVENT_ACK_STATE_CONSUMED);
 758   MoveTouchPoint(0, 2, 2);
 759   EXPECT_EQ(0U, queued_event_count());
 760   EXPECT_EQ(1U, GetAndResetSentEventCount());
 761   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 762
 763   // TouchEnd
 764   SetSyncAckResult(INPUT_EVENT_ACK_STATE_CONSUMED);
 765   ReleaseTouchPoint(0);
 766   EXPECT_EQ(0U, queued_event_count());
 767   EXPECT_EQ(1U, GetAndResetSentEventCount());
 768   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 769
 770   // TouchCancel (first inserting a TouchStart so the TouchCancel will be sent)
 771   PressTouchPoint(1, 1);
 772   SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
 773   EXPECT_EQ(0U, queued_event_count());
 774   EXPECT_EQ(1U, GetAndResetSentEventCount());
 775   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 776
 777   SetSyncAckResult(INPUT_EVENT_ACK_STATE_CONSUMED);
 778   CancelTouchPoint(0);
 779   EXPECT_EQ(0U, queued_event_count());
 780   EXPECT_EQ(1U, GetAndResetSentEventCount());
 781   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 782 }
 783
 784 // Tests that followup events triggered by an immediate ack from
 785 // TouchEventQueue::QueueEvent() are properly handled.
 786 TEST_F(TouchEventQueueTest, ImmediateAckWithFollowupEvents) {
 787   // Create a touch event that will be queued synchronously by a touch ack.
 788   WebTouchEvent followup_event;
 789   followup_event.type = WebInputEvent::TouchStart;
 790   followup_event.touchesLength = 1;
 791   followup_event.touches[0].id = 1;
 792   followup_event.touches[0].state = WebTouchPoint::StatePressed;
 793   SetFollowupEvent(followup_event);
 794
 795   // Now, enqueue a stationary touch that will not be forwarded.  This should be
 796   // immediately ack'ed with "NO_CONSUMER_EXISTS".  The followup event should
 797   // then be enqueued and immediately sent to the renderer.
 798   WebTouchEvent stationary_event;
 799   stationary_event.touchesLength = 1;
 800   stationary_event.type = WebInputEvent::TouchMove;
 801   stationary_event.touches[0].id = 1;
 802   stationary_event.touches[0].state = WebTouchPoint::StateStationary;
 803   SendTouchEvent(stationary_event);
 804
 805   EXPECT_EQ(1U, queued_event_count());
 806   EXPECT_EQ(1U, GetAndResetSentEventCount());
 807   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 808   EXPECT_EQ(INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS, acked_event_state());
 809   EXPECT_EQ(WebInputEvent::TouchMove, acked_event().type);
 810 }
 811
 812 // Tests basic TouchEvent forwarding suppression.
 813 TEST_F(TouchEventQueueTest, NoTouchBasic) {
 814   // Disable TouchEvent forwarding.
 815   OnHasTouchEventHandlers(false);
 816   PressTouchPoint(30, 5);
 817   EXPECT_EQ(0U, GetAndResetSentEventCount());
 818   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 819
 820   // TouchMove should not be sent to renderer.
 821   MoveTouchPoint(0, 65, 10);
 822   EXPECT_EQ(0U, GetAndResetSentEventCount());
 823   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 824
 825   // TouchEnd should not be sent to renderer.
 826   ReleaseTouchPoint(0);
 827   EXPECT_EQ(0U, GetAndResetSentEventCount());
 828   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 829
 830   // Enable TouchEvent forwarding.
 831   OnHasTouchEventHandlers(true);
 832
 833   PressTouchPoint(80, 10);
 834   EXPECT_EQ(1U, GetAndResetSentEventCount());
 835   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
 836   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 837
 838   MoveTouchPoint(0, 80, 20);
 839   EXPECT_EQ(1U, GetAndResetSentEventCount());
 840   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
 841   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 842
 843   ReleaseTouchPoint(0);
 844   EXPECT_EQ(1U, GetAndResetSentEventCount());
 845   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
 846   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 847 }
 848
 849 // Tests that no TouchEvents are sent to renderer during scrolling.
 850 TEST_F(TouchEventQueueTest, TouchCancelOnScroll) {
 851   SetTouchScrollingMode(TouchEventQueue::TOUCH_SCROLLING_MODE_TOUCHCANCEL);
 852   // Queue a TouchStart.
 853   PressTouchPoint(0, 1);
 854   EXPECT_EQ(1U, GetAndResetSentEventCount());
 855   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
 856   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 857
 858   MoveTouchPoint(0, 20, 5);
 859   EXPECT_EQ(1U, queued_event_count());
 860   EXPECT_EQ(1U, GetAndResetSentEventCount());
 861
 862   MoveTouchPoint(0, 30, 15);
 863   EXPECT_EQ(2U, queued_event_count());
 864   EXPECT_EQ(0U, GetAndResetSentEventCount());
 865
 866   // Queue another TouchStart.
 867   PressTouchPoint(20, 20);
 868   EXPECT_EQ(3U, queued_event_count());
 869   EXPECT_EQ(0U, GetAndResetSentEventCount());
 870   EXPECT_EQ(WebInputEvent::TouchStart, latest_event().type);
 871
 872   WebGestureEvent followup_scroll;
 873   followup_scroll.type = WebInputEvent::GestureScrollBegin;
 874   SetFollowupEvent(followup_scroll);
 875   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
 876   EXPECT_EQ(1U, GetAndResetSentEventCount());
 877   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 878   EXPECT_EQ(2U, queued_event_count());
 879   EXPECT_TRUE(sent_event().cancelable);
 880   EXPECT_EQ(WebInputEvent::TouchMove, sent_event().type);
 881
 882   // GestureScrollUpdate inserts a synthetic TouchCancel before the TouchStart.
 883   followup_scroll.type = WebInputEvent::GestureScrollUpdate;
 884   SetFollowupEvent(followup_scroll);
 885   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
 886   EXPECT_EQ(1U, GetAndResetSentEventCount());
 887   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 888   EXPECT_EQ(2U, queued_event_count());
 889   EXPECT_EQ(WebInputEvent::TouchCancel, sent_event().type);
 890   EXPECT_FALSE(sent_event().cancelable);
 891   EXPECT_EQ(WebInputEvent::TouchStart, latest_event().type);
 892
 893   // Acking the TouchCancel will result in dispatch of the next TouchStart.
 894   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
 895   // The synthetic TouchCancel should not reach client, only the TouchStart.
 896   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 897   EXPECT_EQ(0U, GetAndResetSentEventCount());
 898   EXPECT_EQ(WebInputEvent::TouchStart, acked_event().type);
 899
 900   // TouchMove should not be sent to the renderer.
 901   MoveTouchPoint(0, 30, 5);
 902   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 903   EXPECT_EQ(0U, GetAndResetSentEventCount());
 904   EXPECT_EQ(INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS, acked_event_state());
 905
 906   // GestureScrollUpdates should not change affect touch forwarding.
 907   SendGestureEvent(WebInputEvent::GestureScrollUpdate);
 908
 909   // TouchEnd should not be sent to the renderer.
 910   ReleaseTouchPoint(0);
 911   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 912   EXPECT_EQ(0U, GetAndResetSentEventCount());
 913   EXPECT_EQ(INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS, acked_event_state());
 914
 915   ReleaseTouchPoint(0);
 916   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 917   EXPECT_EQ(0U, GetAndResetSentEventCount());
 918   EXPECT_EQ(INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS, acked_event_state());
 919
 920   // Touch events from a new gesture sequence should be forwarded normally.
 921   PressTouchPoint(80, 10);
 922   EXPECT_EQ(1U, GetAndResetSentEventCount());
 923   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
 924   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 925
 926   MoveTouchPoint(0, 80, 20);
 927   EXPECT_EQ(1U, GetAndResetSentEventCount());
 928   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
 929   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 930
 931   ReleaseTouchPoint(0);
 932   EXPECT_EQ(1U, GetAndResetSentEventCount());
 933   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
 934   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 935 }
 936
 937 // Tests that a scroll event will not insert a synthetic TouchCancel if there
 938 // was no consumer for the current touch sequence.
 939 TEST_F(TouchEventQueueTest, NoTouchCancelOnScrollIfNoConsumer) {
 940   SetTouchScrollingMode(TouchEventQueue::TOUCH_SCROLLING_MODE_TOUCHCANCEL);
 941
 942   // Queue a TouchStart.
 943   PressTouchPoint(0, 1);
 944   EXPECT_EQ(1U, GetAndResetSentEventCount());
 945   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS);
 946   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 947   EXPECT_EQ(WebInputEvent::TouchStart, sent_event().type);
 948
 949   // Queue a TouchMove that turns into a GestureScrollBegin.
 950   WebGestureEvent followup_scroll;
 951   followup_scroll.type = WebInputEvent::GestureScrollBegin;
 952   SetFollowupEvent(followup_scroll);
 953   MoveTouchPoint(0, 20, 5);
 954
 955   // The TouchMove has no consumer, and should be ack'ed immediately. However,
 956   // *no* synthetic TouchCancel should be inserted as the touch sequence
 957   // had no consumer.
 958   EXPECT_EQ(0U, queued_event_count());
 959   EXPECT_EQ(0U, GetAndResetSentEventCount());
 960   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 961   EXPECT_EQ(0U, queued_event_count());
 962   EXPECT_EQ(WebInputEvent::TouchStart, sent_event().type);
 963
 964   // Subsequent TouchMove's should not be sent to the renderer.
 965   MoveTouchPoint(0, 30, 5);
 966   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 967   EXPECT_EQ(0U, GetAndResetSentEventCount());
 968   EXPECT_EQ(INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS, acked_event_state());
 969
 970   // TouchEnd should not be sent to the renderer.
 971   ReleaseTouchPoint(0);
 972   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 973   EXPECT_EQ(0U, GetAndResetSentEventCount());
 974   EXPECT_EQ(INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS, acked_event_state());
 975
 976   // Touch events from a new gesture sequence should be forwarded normally.
 977   PressTouchPoint(80, 10);
 978   EXPECT_EQ(1U, GetAndResetSentEventCount());
 979   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
 980   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 981 }
 982
 983 // Tests that IsTouchStartPendingAck works correctly.
 984 TEST_F(TouchEventQueueTest, PendingStart) {
 985
 986   EXPECT_FALSE(IsPendingAckTouchStart());
 987
 988   // Send the touchstart for one point (#1).
 989   PressTouchPoint(1, 1);
 990   EXPECT_EQ(1U, queued_event_count());
 991   EXPECT_TRUE(IsPendingAckTouchStart());
 992
 993   // Send a touchmove for that point (#2).
 994   MoveTouchPoint(0, 5, 5);
 995   EXPECT_EQ(2U, queued_event_count());
 996   EXPECT_TRUE(IsPendingAckTouchStart());
 997
 998   // Ack the touchstart (#1).
 999   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1000   EXPECT_EQ(1U, queued_event_count());
1001   EXPECT_FALSE(IsPendingAckTouchStart());
1002
1003   // Send a touchstart for another point (#3).
1004   PressTouchPoint(10, 10);
1005   EXPECT_EQ(2U, queued_event_count());
1006   EXPECT_FALSE(IsPendingAckTouchStart());
1007
1008   // Ack the touchmove (#2).
1009   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1010   EXPECT_EQ(1U, queued_event_count());
1011   EXPECT_TRUE(IsPendingAckTouchStart());
1012
1013   // Send a touchstart for a third point (#4).
1014   PressTouchPoint(15, 15);
1015   EXPECT_EQ(2U, queued_event_count());
1016   EXPECT_TRUE(IsPendingAckTouchStart());
1017
1018   // Ack the touchstart for the second point (#3).
1019   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1020   EXPECT_EQ(1U, queued_event_count());
1021   EXPECT_TRUE(IsPendingAckTouchStart());
1022
1023   // Ack the touchstart for the third point (#4).
1024   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1025   EXPECT_EQ(0U, queued_event_count());
1026   EXPECT_FALSE(IsPendingAckTouchStart());
1027 }
1028
1029 // Tests that the touch timeout is started when sending certain touch types.
1030 TEST_F(TouchEventQueueTest, TouchTimeoutTypes) {
1031   SetUpForTimeoutTesting(DefaultTouchTimeoutDelay());
1032
1033   // Sending a TouchStart will start the timeout.
1034   PressTouchPoint(0, 1);
1035   EXPECT_TRUE(IsTimeoutRunning());
1036   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1037   EXPECT_FALSE(IsTimeoutRunning());
1038
1039   // A TouchMove should start the timeout.
1040   MoveTouchPoint(0, 5, 5);
1041   EXPECT_TRUE(IsTimeoutRunning());
1042   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1043   EXPECT_FALSE(IsTimeoutRunning());
1044
1045   // A TouchEnd should not start the timeout.
1046   ReleaseTouchPoint(0);
1047   EXPECT_FALSE(IsTimeoutRunning());
1048   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1049   EXPECT_FALSE(IsTimeoutRunning());
1050
1051   // A TouchCancel should not start the timeout.
1052   PressTouchPoint(0, 1);
1053   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1054   ASSERT_FALSE(IsTimeoutRunning());
1055   CancelTouchPoint(0);
1056   EXPECT_FALSE(IsTimeoutRunning());
1057   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1058   EXPECT_FALSE(IsTimeoutRunning());
1059 }
1060
1061 // Tests that a delayed TouchEvent ack will trigger a TouchCancel timeout,
1062 // disabling touch forwarding until the next TouchStart is received after
1063 // the timeout events are ack'ed.
1064 TEST_F(TouchEventQueueTest, TouchTimeoutBasic) {
1065   SetUpForTimeoutTesting(DefaultTouchTimeoutDelay());
1066
1067   // Queue a TouchStart.
1068   GetAndResetSentEventCount();
1069   GetAndResetAckedEventCount();
1070   PressTouchPoint(0, 1);
1071   ASSERT_EQ(1U, GetAndResetSentEventCount());
1072   ASSERT_EQ(0U, GetAndResetAckedEventCount());
1073   EXPECT_TRUE(IsTimeoutRunning());
1074
1075   // Delay the ack.
1076   RunTasksAndWait(DefaultTouchTimeoutDelay() * 2);
1077
1078   // The timeout should have fired, synthetically ack'ing the timed-out event.
1079   // TouchEvent forwarding is disabled until the ack is received for the
1080   // timed-out event and the future cancel event.
1081   EXPECT_FALSE(IsTimeoutRunning());
1082   EXPECT_EQ(0U, GetAndResetSentEventCount());
1083   EXPECT_EQ(1U, GetAndResetAckedEventCount());
1084
1085   // Ack'ing the original event should trigger a cancel event.
1086   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1087   EXPECT_FALSE(IsTimeoutRunning());
1088   EXPECT_EQ(0U, GetAndResetAckedEventCount());
1089   EXPECT_EQ(1U, GetAndResetSentEventCount());
1090   EXPECT_EQ(WebInputEvent::TouchCancel, sent_event().type);
1091   EXPECT_FALSE(sent_event().cancelable);
1092
1093   // Touch events should not be forwarded until we receive the cancel acks.
1094   MoveTouchPoint(0, 1, 1);
1095   ASSERT_EQ(0U, GetAndResetSentEventCount());
1096   ASSERT_EQ(1U, GetAndResetAckedEventCount());
1097
1098   ReleaseTouchPoint(0);
1099   ASSERT_EQ(0U, GetAndResetSentEventCount());
1100   ASSERT_EQ(1U, GetAndResetAckedEventCount());
1101
1102   // The synthetic TouchCancel ack should not reach the client, but should
1103   // resume touch forwarding.
1104   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1105   EXPECT_EQ(0U, GetAndResetSentEventCount());
1106   EXPECT_EQ(0U, GetAndResetAckedEventCount());
1107
1108   // Subsequent events should be handled normally.
1109   PressTouchPoint(0, 1);
1110   EXPECT_EQ(1U, GetAndResetSentEventCount());
1111   EXPECT_EQ(0U, GetAndResetAckedEventCount());
1112   EXPECT_EQ(WebInputEvent::TouchStart, sent_event().type);
1113   EXPECT_TRUE(sent_event().cancelable);
1114 }
1115
1116 // Tests that the timeout is never started if the renderer consumes
1117 // a TouchEvent from the current touch sequence.
1118 TEST_F(TouchEventQueueTest, NoTouchTimeoutIfRendererIsConsumingGesture) {
1119   SetUpForTimeoutTesting(DefaultTouchTimeoutDelay());
1120
1121   // Queue a TouchStart.
1122   PressTouchPoint(0, 1);
1123   ASSERT_TRUE(IsTimeoutRunning());
1124
1125   // Mark the event as consumed. This should prevent the timeout from
1126   // being activated on subsequent TouchEvents in this gesture.
1127   SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
1128   EXPECT_FALSE(IsTimeoutRunning());
1129
1130   // A TouchMove should not start the timeout.
1131   MoveTouchPoint(0, 5, 5);
1132   EXPECT_FALSE(IsTimeoutRunning());
1133   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1134
1135   // A secondary TouchStart should not start the timeout.
1136   PressTouchPoint(1, 0);
1137   EXPECT_FALSE(IsTimeoutRunning());
1138   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1139
1140   // A TouchEnd should not start the timeout.
1141   ReleaseTouchPoint(1);
1142   EXPECT_FALSE(IsTimeoutRunning());
1143   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1144
1145   // A TouchCancel should not start the timeout.
1146   CancelTouchPoint(0);
1147   EXPECT_FALSE(IsTimeoutRunning());
1148 }
1149
1150 // Tests that the timeout is never started if the renderer consumes
1151 // a TouchEvent from the current touch sequence.
1152 TEST_F(TouchEventQueueTest, NoTouchTimeoutIfDisabledAfterTouchStart) {
1153   SetUpForTimeoutTesting(DefaultTouchTimeoutDelay());
1154
1155   // Queue a TouchStart.
1156   PressTouchPoint(0, 1);
1157   ASSERT_TRUE(IsTimeoutRunning());
1158
1159   // Send the ack immediately. The timeout should not have fired.
1160   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1161   EXPECT_FALSE(IsTimeoutRunning());
1162   EXPECT_TRUE(IsTimeoutEnabled());
1163   EXPECT_EQ(1U, GetAndResetSentEventCount());
1164   EXPECT_EQ(1U, GetAndResetAckedEventCount());
1165
1166   // Now explicitly disable the timeout.
1167   SetAckTimeoutDisabled();
1168   EXPECT_FALSE(IsTimeoutRunning());
1169   EXPECT_FALSE(IsTimeoutEnabled());
1170
1171   // A TouchMove should not start or trigger the timeout.
1172   MoveTouchPoint(0, 5, 5);
1173   EXPECT_FALSE(IsTimeoutRunning());
1174   EXPECT_EQ(1U, GetAndResetSentEventCount());
1175   RunTasksAndWait(DefaultTouchTimeoutDelay() * 2);
1176   EXPECT_EQ(0U, GetAndResetAckedEventCount());
1177 }
1178
1179 // Tests that the timeout is never started if the ack is synchronous.
1180 TEST_F(TouchEventQueueTest, NoTouchTimeoutIfAckIsSynchronous) {
1181   SetUpForTimeoutTesting(DefaultTouchTimeoutDelay());
1182
1183   // Queue a TouchStart.
1184   SetSyncAckResult(INPUT_EVENT_ACK_STATE_CONSUMED);
1185   ASSERT_FALSE(IsTimeoutRunning());
1186   PressTouchPoint(0, 1);
1187   EXPECT_FALSE(IsTimeoutRunning());
1188 }
1189
1190 // Tests that the timeout is disabled if the touch handler disappears.
1191 TEST_F(TouchEventQueueTest, NoTouchTimeoutIfTouchHandlerRemoved) {
1192   SetUpForTimeoutTesting(DefaultTouchTimeoutDelay());
1193
1194   // Queue a TouchStart.
1195   PressTouchPoint(0, 1);
1196   ASSERT_TRUE(IsTimeoutRunning());
1197
1198   // Unload the touch handler.
1199   OnHasTouchEventHandlers(false);
1200   EXPECT_FALSE(IsTimeoutRunning());
1201 }
1202
1203 // Tests that the timeout does not fire if explicitly disabled while an event
1204 // is in-flight.
1205 TEST_F(TouchEventQueueTest, NoTouchTimeoutIfDisabledWhileTimerIsActive) {
1206   SetUpForTimeoutTesting(DefaultTouchTimeoutDelay());
1207
1208   // Queue a TouchStart.
1209   PressTouchPoint(0, 1);
1210   ASSERT_TRUE(IsTimeoutRunning());
1211
1212   // Verify that disabling the timeout also turns off the timer.
1213   SetAckTimeoutDisabled();
1214   EXPECT_FALSE(IsTimeoutRunning());
1215   RunTasksAndWait(DefaultTouchTimeoutDelay() * 2);
1216   EXPECT_EQ(0U, GetAndResetAckedEventCount());
1217 }
1218
1219 // Tests that a TouchCancel timeout plays nice when the timed out touch stream
1220 // turns into a scroll gesture sequence.
1221 TEST_F(TouchEventQueueTest, TouchTimeoutWithFollowupGesture) {
1222   SetUpForTimeoutTesting(DefaultTouchTimeoutDelay());
1223
1224   // Queue a TouchStart.
1225   PressTouchPoint(0, 1);
1226   EXPECT_TRUE(IsTimeoutRunning());
1227   EXPECT_EQ(1U, GetAndResetSentEventCount());
1228
1229   // The cancelled sequence may turn into a scroll gesture.
1230   WebGestureEvent followup_scroll;
1231   followup_scroll.type = WebInputEvent::GestureScrollBegin;
1232   SetFollowupEvent(followup_scroll);
1233
1234   // Delay the ack.
1235   RunTasksAndWait(DefaultTouchTimeoutDelay() * 2);
1236
1237   // The timeout should have fired, disabling touch forwarding until both acks
1238   // are received, acking the timed out event.
1239   EXPECT_FALSE(IsTimeoutRunning());
1240   EXPECT_EQ(0U, GetAndResetSentEventCount());
1241   EXPECT_EQ(1U, GetAndResetAckedEventCount());
1242
1243   // Ack the original event, triggering a TouchCancel.
1244   SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
1245   EXPECT_FALSE(IsTimeoutRunning());
1246   EXPECT_EQ(1U, GetAndResetSentEventCount());
1247   EXPECT_EQ(0U, GetAndResetAckedEventCount());
1248
1249   // Ack the cancel event.  Normally, this would resume touch forwarding,
1250   // but we're still within a scroll gesture so it remains disabled.
1251   SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
1252   EXPECT_FALSE(IsTimeoutRunning());
1253   EXPECT_EQ(0U, GetAndResetSentEventCount());
1254   EXPECT_EQ(0U, GetAndResetAckedEventCount());
1255
1256   // Try to forward touch events for the current sequence.
1257   GetAndResetSentEventCount();
1258   GetAndResetAckedEventCount();
1259   MoveTouchPoint(0, 1, 1);
1260   ReleaseTouchPoint(0);
1261   EXPECT_FALSE(IsTimeoutRunning());
1262   EXPECT_EQ(0U, GetAndResetSentEventCount());
1263   EXPECT_EQ(2U, GetAndResetAckedEventCount());
1264
1265   // Now end the scroll sequence, resuming touch handling.
1266   SendGestureEvent(blink::WebInputEvent::GestureScrollEnd);
1267   PressTouchPoint(0, 1);
1268   EXPECT_TRUE(IsTimeoutRunning());
1269   EXPECT_EQ(1U, GetAndResetSentEventCount());
1270   EXPECT_EQ(0U, GetAndResetAckedEventCount());
1271 }
1272
1273 // Tests that a TouchCancel timeout plays nice when the timed out touch stream
1274 // turns into a scroll gesture sequence, but the original event acks are
1275 // significantly delayed.
1276 TEST_F(TouchEventQueueTest, TouchTimeoutWithFollowupGestureAndDelayedAck) {
1277   SetUpForTimeoutTesting(DefaultTouchTimeoutDelay());
1278
1279   // Queue a TouchStart.
1280   PressTouchPoint(0, 1);
1281   EXPECT_TRUE(IsTimeoutRunning());
1282   EXPECT_EQ(1U, GetAndResetSentEventCount());
1283
1284   // The cancelled sequence may turn into a scroll gesture.
1285   WebGestureEvent followup_scroll;
1286   followup_scroll.type = WebInputEvent::GestureScrollBegin;
1287   SetFollowupEvent(followup_scroll);
1288
1289   // Delay the ack.
1290   RunTasksAndWait(DefaultTouchTimeoutDelay() * 2);
1291
1292   // The timeout should have fired, disabling touch forwarding until both acks
1293   // are received and acking the timed out event.
1294   EXPECT_FALSE(IsTimeoutRunning());
1295   EXPECT_EQ(0U, GetAndResetSentEventCount());
1296   EXPECT_EQ(1U, GetAndResetAckedEventCount());
1297
1298   // Try to forward a touch event.
1299   GetAndResetSentEventCount();
1300   GetAndResetAckedEventCount();
1301   MoveTouchPoint(0, 1, 1);
1302   EXPECT_FALSE(IsTimeoutRunning());
1303   EXPECT_EQ(0U, GetAndResetSentEventCount());
1304   EXPECT_EQ(1U, GetAndResetAckedEventCount());
1305
1306   // Now end the scroll sequence.  Events will not be forwarded until the two
1307   // outstanding touch acks are received.
1308   SendGestureEvent(blink::WebInputEvent::GestureScrollEnd);
1309   MoveTouchPoint(0, 2, 2);
1310   ReleaseTouchPoint(0);
1311   EXPECT_FALSE(IsTimeoutRunning());
1312   EXPECT_EQ(0U, GetAndResetSentEventCount());
1313   EXPECT_EQ(2U, GetAndResetAckedEventCount());
1314
1315   // Ack the original event, triggering a cancel.
1316   SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
1317   EXPECT_EQ(1U, GetAndResetSentEventCount());
1318   EXPECT_EQ(0U, GetAndResetAckedEventCount());
1319
1320   // Ack the cancel event, resuming touch forwarding.
1321   SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
1322   EXPECT_EQ(0U, GetAndResetSentEventCount());
1323   EXPECT_EQ(0U, GetAndResetAckedEventCount());
1324
1325   PressTouchPoint(0, 1);
1326   EXPECT_TRUE(IsTimeoutRunning());
1327   EXPECT_EQ(1U, GetAndResetSentEventCount());
1328 }
1329
1330 // Tests that a delayed TouchEvent ack will not trigger a TouchCancel timeout if
1331 // the timed-out event had no consumer.
1332 TEST_F(TouchEventQueueTest, NoCancelOnTouchTimeoutWithoutConsumer) {
1333   SetUpForTimeoutTesting(DefaultTouchTimeoutDelay());
1334
1335   // Queue a TouchStart.
1336   PressTouchPoint(0, 1);
1337   ASSERT_EQ(1U, GetAndResetSentEventCount());
1338   ASSERT_EQ(0U, GetAndResetAckedEventCount());
1339   EXPECT_TRUE(IsTimeoutRunning());
1340
1341   // Delay the ack.
1342   RunTasksAndWait(DefaultTouchTimeoutDelay() * 2);
1343
1344   // The timeout should have fired, synthetically ack'ing the timed out event.
1345   // TouchEvent forwarding is disabled until the original ack is received.
1346   EXPECT_FALSE(IsTimeoutRunning());
1347   EXPECT_EQ(0U, GetAndResetSentEventCount());
1348   EXPECT_EQ(1U, GetAndResetAckedEventCount());
1349
1350   // Touch events should not be forwarded until we receive the original ack.
1351   MoveTouchPoint(0, 1, 1);
1352   ReleaseTouchPoint(0);
1353   ASSERT_EQ(0U, GetAndResetSentEventCount());
1354   ASSERT_EQ(2U, GetAndResetAckedEventCount());
1355
1356   // Ack'ing the original event should not trigger a cancel event, as the
1357   // TouchStart had no consumer.  However, it should re-enable touch forwarding.
1358   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS);
1359   EXPECT_FALSE(IsTimeoutRunning());
1360   EXPECT_EQ(0U, GetAndResetAckedEventCount());
1361   EXPECT_EQ(0U, GetAndResetSentEventCount());
1362
1363   // Subsequent events should be handled normally.
1364   PressTouchPoint(0, 1);
1365   EXPECT_EQ(1U, GetAndResetSentEventCount());
1366   EXPECT_EQ(0U, GetAndResetAckedEventCount());
1367 }
1368
1369 // Tests that TouchMove's are dropped if within the boundary-inclusive slop
1370 // suppression region for an unconsumed TouchStart.
1371 TEST_F(TouchEventQueueTest, TouchMoveSuppressionIncludingSlopBoundary) {
1372   const double kSlopLengthDips = 10.;
1373   const double kHalfSlopLengthDips = kSlopLengthDips / 2;
1374   const bool slop_includes_boundary = true;
1375   SetUpForTouchMoveSlopTesting(kSlopLengthDips, slop_includes_boundary);
1376
1377   // Queue a TouchStart.
1378   PressTouchPoint(0, 0);
1379   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1380   ASSERT_EQ(1U, GetAndResetSentEventCount());
1381   ASSERT_EQ(1U, GetAndResetAckedEventCount());
1382
1383   // TouchMove's within the region should be suppressed.
1384   MoveTouchPoint(0, 0, kHalfSlopLengthDips);
1385   EXPECT_EQ(0U, queued_event_count());
1386   EXPECT_EQ(0U, GetAndResetSentEventCount());
1387   EXPECT_EQ(1U, GetAndResetAckedEventCount());
1388   EXPECT_EQ(INPUT_EVENT_ACK_STATE_NOT_CONSUMED, acked_event_state());
1389
1390   MoveTouchPoint(0, kHalfSlopLengthDips, 0);
1391   EXPECT_EQ(0U, queued_event_count());
1392   EXPECT_EQ(0U, GetAndResetSentEventCount());
1393   EXPECT_EQ(1U, GetAndResetAckedEventCount());
1394   EXPECT_EQ(INPUT_EVENT_ACK_STATE_NOT_CONSUMED, acked_event_state());
1395
1396   MoveTouchPoint(0, -kHalfSlopLengthDips, 0);
1397   EXPECT_EQ(0U, queued_event_count());
1398   EXPECT_EQ(0U, GetAndResetSentEventCount());
1399   EXPECT_EQ(1U, GetAndResetAckedEventCount());
1400   EXPECT_EQ(INPUT_EVENT_ACK_STATE_NOT_CONSUMED, acked_event_state());
1401
1402   MoveTouchPoint(0, -kSlopLengthDips, 0);
1403   EXPECT_EQ(0U, queued_event_count());
1404   EXPECT_EQ(0U, GetAndResetSentEventCount());
1405   EXPECT_EQ(1U, GetAndResetAckedEventCount());
1406   EXPECT_EQ(INPUT_EVENT_ACK_STATE_NOT_CONSUMED, acked_event_state());
1407
1408   MoveTouchPoint(0, 0, kSlopLengthDips);
1409   EXPECT_EQ(0U, queued_event_count());
1410   EXPECT_EQ(0U, GetAndResetSentEventCount());
1411   EXPECT_EQ(1U, GetAndResetAckedEventCount());
1412   EXPECT_EQ(INPUT_EVENT_ACK_STATE_NOT_CONSUMED, acked_event_state());
1413
1414   // As soon as a TouchMove exceeds the (Euclidean) distance, no more
1415   // TouchMove's should be suppressed.
1416   const double kFortyFiveDegreeSlopLengthXY =
1417       kSlopLengthDips * std::sqrt(2.) / 2.;
1418   MoveTouchPoint(0, kFortyFiveDegreeSlopLengthXY + .2,
1419                     kFortyFiveDegreeSlopLengthXY + .2);
1420   EXPECT_EQ(1U, queued_event_count());
1421   EXPECT_EQ(1U, GetAndResetSentEventCount());
1422   EXPECT_EQ(0U, GetAndResetAckedEventCount());
1423   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1424   EXPECT_EQ(1U, GetAndResetAckedEventCount());
1425
1426   // Even TouchMove's within the original slop region should now be forwarded.
1427   MoveTouchPoint(0, 0, 0);
1428   EXPECT_EQ(1U, queued_event_count());
1429   EXPECT_EQ(1U, GetAndResetSentEventCount());
1430   EXPECT_EQ(0U, GetAndResetAckedEventCount());
1431   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1432   EXPECT_EQ(1U, GetAndResetAckedEventCount());
1433
1434   // A new touch sequence should reset suppression.
1435   ReleaseTouchPoint(0);
1436   PressTouchPoint(0, 0);
1437   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1438   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1439   ASSERT_EQ(2U, GetAndResetSentEventCount());
1440   ASSERT_EQ(2U, GetAndResetAckedEventCount());
1441   ASSERT_EQ(0U, queued_event_count());
1442
1443   // The slop region is boundary-inclusive.
1444   MoveTouchPoint(0, kSlopLengthDips - 1., 0);
1445   EXPECT_EQ(0U, queued_event_count());
1446   EXPECT_EQ(0U, GetAndResetSentEventCount());
1447   EXPECT_EQ(1U, GetAndResetAckedEventCount());
1448
1449   MoveTouchPoint(0, kSlopLengthDips, 0);
1450   EXPECT_EQ(0U, queued_event_count());
1451   EXPECT_EQ(0U, GetAndResetSentEventCount());
1452   EXPECT_EQ(1U, GetAndResetAckedEventCount());
1453 }
1454
1455 // Tests that TouchMove's are dropped if within the boundary-exclusive slop
1456 // suppression region for an unconsumed TouchStart.
1457 TEST_F(TouchEventQueueTest, TouchMoveSuppressionExcludingSlopBoundary) {
1458   const double kSlopLengthDips = 10.;
1459   const double kHalfSlopLengthDips = kSlopLengthDips / 2;
1460   const bool slop_includes_boundary = false;
1461   SetUpForTouchMoveSlopTesting(kSlopLengthDips, slop_includes_boundary);
1462
1463   // Queue a TouchStart.
1464   PressTouchPoint(0, 0);
1465   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1466   ASSERT_EQ(1U, GetAndResetSentEventCount());
1467   ASSERT_EQ(1U, GetAndResetAckedEventCount());
1468
1469   // TouchMove's within the region should be suppressed.
1470   MoveTouchPoint(0, 0, kHalfSlopLengthDips);
1471   EXPECT_EQ(0U, queued_event_count());
1472   EXPECT_EQ(0U, GetAndResetSentEventCount());
1473   EXPECT_EQ(1U, GetAndResetAckedEventCount());
1474   EXPECT_EQ(INPUT_EVENT_ACK_STATE_NOT_CONSUMED, acked_event_state());
1475
1476   MoveTouchPoint(0, kSlopLengthDips - 0.2f, 0);
1477   EXPECT_EQ(0U, queued_event_count());
1478   EXPECT_EQ(0U, GetAndResetSentEventCount());
1479   EXPECT_EQ(1U, GetAndResetAckedEventCount());
1480   EXPECT_EQ(INPUT_EVENT_ACK_STATE_NOT_CONSUMED, acked_event_state());
1481
1482   // As soon as a TouchMove reaches the (Euclidean) slop distance, no more
1483   // TouchMove's should be suppressed.
1484   MoveTouchPoint(0, kSlopLengthDips, 0);
1485   EXPECT_EQ(1U, queued_event_count());
1486   EXPECT_EQ(1U, GetAndResetSentEventCount());
1487   EXPECT_EQ(0U, GetAndResetAckedEventCount());
1488   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1489   EXPECT_EQ(1U, GetAndResetAckedEventCount());
1490
1491   MoveTouchPoint(0, kHalfSlopLengthDips, 0);
1492   EXPECT_EQ(1U, queued_event_count());
1493   EXPECT_EQ(1U, GetAndResetSentEventCount());
1494   EXPECT_EQ(0U, GetAndResetAckedEventCount());
1495   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1496   EXPECT_EQ(1U, GetAndResetAckedEventCount());
1497 }
1498
1499 // Tests that TouchMove's are not dropped within the slop suppression region if
1500 // the touchstart was consumed.
1501 TEST_F(TouchEventQueueTest, NoTouchMoveSuppressionAfterTouchConsumed) {
1502   const double kSlopLengthDips = 10.;
1503   const double kHalfSlopLengthDips = kSlopLengthDips / 2;
1504   const bool slop_includes_boundary = true;
1505   SetUpForTouchMoveSlopTesting(kSlopLengthDips, slop_includes_boundary);
1506
1507   // Queue a TouchStart.
1508   PressTouchPoint(0, 0);
1509   SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
1510   ASSERT_EQ(1U, GetAndResetSentEventCount());
1511   ASSERT_EQ(1U, GetAndResetAckedEventCount());
1512
1513   // TouchMove's within the region should not be suppressed, as a touch was
1514   // consumed.
1515   MoveTouchPoint(0, 0, kHalfSlopLengthDips);
1516   EXPECT_EQ(1U, queued_event_count());
1517   EXPECT_EQ(1U, GetAndResetSentEventCount());
1518   EXPECT_EQ(0U, GetAndResetAckedEventCount());
1519 }
1520
1521 // Tests that TouchMove's are not dropped due to incorrect handling of DPI
1522 // scaling.
1523 TEST_F(TouchEventQueueTest, TouchMoveSuppressionWithDIPScaling) {
1524   const float kSlopLengthPixels = 7.f;
1525   const float kDPIScale = 3.f;
1526   const bool slop_includes_boundary = true;
1527   SetUpForTouchMoveSlopTesting(kSlopLengthPixels / kDPIScale,
1528                                slop_includes_boundary);
1529
1530   // Queue a TouchStart.
1531   PressTouchPoint(0, 0);
1532   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1533   ASSERT_EQ(1U, GetAndResetSentEventCount());
1534   ASSERT_EQ(1U, GetAndResetAckedEventCount());
1535
1536   // TouchMove's along the slop boundary should be suppresed.
1537   MoveTouchPoint(0, 0, kSlopLengthPixels / kDPIScale);
1538   EXPECT_EQ(0U, queued_event_count());
1539   EXPECT_EQ(0U, GetAndResetSentEventCount());
1540   EXPECT_EQ(1U, GetAndResetAckedEventCount());
1541
1542   // Reset the touch sequence.
1543   ReleaseTouchPoint(0);
1544   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1545   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1546   GetAndResetSentEventCount();
1547   GetAndResetAckedEventCount();
1548
1549   // Queue a TouchStart.
1550   PressTouchPoint(0, 0);
1551   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1552   ASSERT_EQ(1U, GetAndResetSentEventCount());
1553   ASSERT_EQ(1U, GetAndResetAckedEventCount());
1554
1555   // TouchMove's outside the region should not be suppressed.
1556   const float kPixelCoordOutsideSlopRegion = kSlopLengthPixels + 0.5f;
1557   MoveTouchPoint(0, 0, kPixelCoordOutsideSlopRegion / kDPIScale);
1558   EXPECT_EQ(1U, queued_event_count());
1559   EXPECT_EQ(1U, GetAndResetSentEventCount());
1560   EXPECT_EQ(0U, GetAndResetAckedEventCount());
1561 }
1562
1563 // Tests that TouchMove's are not dropped if a secondary pointer is present
1564 // during any movement.
1565 TEST_F(TouchEventQueueTest, NoTouchMoveSuppressionAfterMultiTouch) {
1566   const double kSlopLengthDips = 10.;
1567   const double kHalfSlopLengthDips = kSlopLengthDips / 2;
1568   const bool slop_includes_boundary = true;
1569   SetUpForTouchMoveSlopTesting(kSlopLengthDips, slop_includes_boundary);
1570
1571   // Queue a TouchStart.
1572   PressTouchPoint(0, 0);
1573   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1574   ASSERT_EQ(1U, GetAndResetSentEventCount());
1575   ASSERT_EQ(1U, GetAndResetAckedEventCount());
1576
1577   // TouchMove's within the region should be suppressed.
1578   MoveTouchPoint(0, 0, kHalfSlopLengthDips);
1579   EXPECT_EQ(0U, queued_event_count());
1580   EXPECT_EQ(0U, GetAndResetSentEventCount());
1581   EXPECT_EQ(1U, GetAndResetAckedEventCount());
1582
1583   // Simulate a secondary pointer press.
1584   PressTouchPoint(kSlopLengthDips, 0);
1585   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1586   EXPECT_EQ(1U, GetAndResetSentEventCount());
1587   EXPECT_EQ(1U, GetAndResetAckedEventCount());
1588
1589   // TouchMove with a secondary pointer should not be suppressed.
1590   MoveTouchPoint(1, kSlopLengthDips, 0);
1591   EXPECT_EQ(1U, queued_event_count());
1592   EXPECT_EQ(1U, GetAndResetSentEventCount());
1593   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1594   EXPECT_EQ(1U, GetAndResetAckedEventCount());
1595
1596   // Release the secondary pointer.
1597   ReleaseTouchPoint(0);
1598   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1599   EXPECT_EQ(1U, GetAndResetSentEventCount());
1600   EXPECT_EQ(1U, GetAndResetAckedEventCount());
1601
1602   // TouchMove's should not should be suppressed, even with the original
1603   // unmoved pointer.
1604   MoveTouchPoint(0, 0, 0);
1605   EXPECT_EQ(1U, queued_event_count());
1606   EXPECT_EQ(1U, GetAndResetSentEventCount());
1607   EXPECT_EQ(0U, GetAndResetAckedEventCount());
1608 }
1609
1610 // Tests that secondary touch points can be forwarded even if the primary touch
1611 // point had no consumer.
1612 TEST_F(TouchEventQueueTest, SecondaryTouchForwardedAfterPrimaryHadNoConsumer) {
1613   // Queue a TouchStart.
1614   PressTouchPoint(0, 0);
1615   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS);
1616   ASSERT_EQ(1U, GetAndResetSentEventCount());
1617   ASSERT_EQ(1U, GetAndResetAckedEventCount());
1618
1619   // Events should not be forwarded, as the point had no consumer.
1620   MoveTouchPoint(0, 0, 15);
1621   EXPECT_EQ(0U, queued_event_count());
1622   EXPECT_EQ(0U, GetAndResetSentEventCount());
1623   EXPECT_EQ(1U, GetAndResetAckedEventCount());
1624
1625   // Simulate a secondary pointer press.
1626   PressTouchPoint(20, 0);
1627   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1628   EXPECT_EQ(1U, GetAndResetSentEventCount());
1629   EXPECT_EQ(1U, GetAndResetAckedEventCount());
1630
1631   // TouchMove with a secondary pointer should not be suppressed.
1632   MoveTouchPoint(1, 25, 0);
1633   EXPECT_EQ(1U, queued_event_count());
1634   EXPECT_EQ(1U, GetAndResetSentEventCount());
1635   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1636   EXPECT_EQ(1U, GetAndResetAckedEventCount());
1637 }
1638
1639 // Tests that no touch points will be forwarded after scrolling begins while no
1640 // touch points have a consumer.
1641 TEST_F(TouchEventQueueTest, NoForwardingAfterScrollWithNoTouchConsumers) {
1642   // Queue a TouchStart.
1643   PressTouchPoint(0, 0);
1644   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS);
1645   ASSERT_EQ(1U, GetAndResetSentEventCount());
1646   ASSERT_EQ(1U, GetAndResetAckedEventCount());
1647
1648   WebGestureEvent followup_scroll;
1649   followup_scroll.type = WebInputEvent::GestureScrollBegin;
1650   SetFollowupEvent(followup_scroll);
1651   MoveTouchPoint(0, 20, 5);
1652   EXPECT_EQ(0U, GetAndResetSentEventCount());
1653   EXPECT_EQ(1U, GetAndResetAckedEventCount());
1654   EXPECT_EQ(INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS, acked_event_state());
1655
1656   // The secondary pointer press should not be forwarded.
1657   PressTouchPoint(20, 0);
1658   EXPECT_EQ(0U, GetAndResetSentEventCount());
1659   EXPECT_EQ(1U, GetAndResetAckedEventCount());
1660   EXPECT_EQ(INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS, acked_event_state());
1661
1662   // Neither should any further touchmoves be forwarded.
1663   MoveTouchPoint(1, 25, 0);
1664   EXPECT_EQ(0U, GetAndResetSentEventCount());
1665   EXPECT_EQ(1U, GetAndResetAckedEventCount());
1666   EXPECT_EQ(INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS, acked_event_state());
1667 }
1668
1669 TEST_F(TouchEventQueueTest, SyncTouchMoveDoesntCancelTouchOnScroll) {
1670  SetTouchScrollingMode(TouchEventQueue::TOUCH_SCROLLING_MODE_SYNC_TOUCHMOVE);
1671  // Queue a TouchStart.
1672  PressTouchPoint(0, 1);
1673  EXPECT_EQ(1U, GetAndResetSentEventCount());
1674  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1675  EXPECT_EQ(1U, GetAndResetAckedEventCount());
1676
1677  MoveTouchPoint(0, 20, 5);
1678  EXPECT_EQ(1U, queued_event_count());
1679  EXPECT_EQ(1U, GetAndResetSentEventCount());
1680
1681  // GestureScrollBegin doesn't insert a synthetic TouchCancel.
1682  WebGestureEvent followup_scroll;
1683  followup_scroll.type = WebInputEvent::GestureScrollBegin;
1684  SetFollowupEvent(followup_scroll);
1685  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1686  EXPECT_EQ(0U, GetAndResetSentEventCount());
1687  EXPECT_EQ(1U, GetAndResetAckedEventCount());
1688  EXPECT_EQ(0U, queued_event_count());
1689 }
1690
1691 TEST_F(TouchEventQueueTest, AsyncTouch) {
1692   SetTouchScrollingMode(TouchEventQueue::TOUCH_SCROLLING_MODE_ASYNC_TOUCHMOVE);
1693
1694   // Queue a TouchStart.
1695   PressTouchPoint(0, 1);
1696   EXPECT_EQ(1U, GetAndResetSentEventCount());
1697   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1698   EXPECT_EQ(1U, GetAndResetAckedEventCount());
1699
1700   for (int i = 0; i < 3; ++i) {
1701    SendGestureEventAck(WebInputEvent::GestureScrollUpdate,
1702                        INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1703
1704    MoveTouchPoint(0, 10, 5);
1705    SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1706    EXPECT_FALSE(HasPendingAsyncTouchMove());
1707    EXPECT_TRUE(sent_event().cancelable);
1708    EXPECT_EQ(0U, queued_event_count());
1709    EXPECT_EQ(1U, GetAndResetSentEventCount());
1710
1711    // Consuming a scroll event will throttle subsequent touchmoves.
1712    SendGestureEventAck(WebInputEvent::GestureScrollUpdate,
1713                        INPUT_EVENT_ACK_STATE_CONSUMED);
1714    MoveTouchPoint(0, 10, 5);
1715    SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1716    EXPECT_TRUE(HasPendingAsyncTouchMove());
1717    EXPECT_EQ(0U, queued_event_count());
1718    EXPECT_EQ(0U, GetAndResetSentEventCount());
1719   }
1720 }
1721
1722 // Ensure that touchmove's are appropriately throttled during a typical
1723 // scroll sequences that transitions between scrolls consumed and unconsumed.
1724 TEST_F(TouchEventQueueTest, AsyncTouchThrottledAfterScroll) {
1725   SetTouchScrollingMode(TouchEventQueue::TOUCH_SCROLLING_MODE_ASYNC_TOUCHMOVE);
1726
1727   // Process a TouchStart
1728   PressTouchPoint(0, 1);
1729   EXPECT_EQ(1U, GetAndResetSentEventCount());
1730   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1731   EXPECT_EQ(1U, GetAndResetAckedEventCount());
1732
1733   // Now send the first touch move and associated GestureScrollBegin.
1734   MoveTouchPoint(0, 0, 5);
1735   WebGestureEvent followup_scroll;
1736   followup_scroll.type = WebInputEvent::GestureScrollBegin;
1737   SetFollowupEvent(followup_scroll);
1738   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1739   EXPECT_EQ(1U, GetAndResetSentEventCount());
1740   EXPECT_EQ(1U, GetAndResetAckedEventCount());
1741   SendGestureEventAck(WebInputEvent::GestureScrollBegin,
1742                       INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1743
1744   // Send the second touch move and associated GestureScrollUpdate, but don't
1745   // ACK the gesture event yet.
1746   MoveTouchPoint(0, 0, 50);
1747   followup_scroll.type = WebInputEvent::GestureScrollUpdate;
1748   SetFollowupEvent(followup_scroll);
1749   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1750   EXPECT_EQ(1U, GetAndResetSentEventCount());
1751   EXPECT_EQ(1U, GetAndResetAckedEventCount());
1752
1753   // Now queue a second touchmove and verify it's not (yet) dispatched.
1754   MoveTouchPoint(0, 0, 100);
1755   SetFollowupEvent(followup_scroll);
1756   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1757   EXPECT_TRUE(HasPendingAsyncTouchMove());
1758   EXPECT_EQ(0U, queued_event_count());
1759   EXPECT_EQ(0U, GetAndResetSentEventCount());
1760   EXPECT_EQ(1U, GetAndResetAckedEventCount());
1761
1762   // Queuing the final touchend should flush the pending, async touchmove.
1763   ReleaseTouchPoint(0);
1764   followup_scroll.type = WebInputEvent::GestureScrollEnd;
1765   SetFollowupEvent(followup_scroll);
1766   EXPECT_EQ(WebInputEvent::TouchMove, sent_event().type);
1767   EXPECT_FALSE(HasPendingAsyncTouchMove());
1768   EXPECT_FALSE(sent_event().cancelable);
1769   EXPECT_EQ(1U, GetAndResetSentEventCount());
1770   EXPECT_EQ(2U, queued_event_count());
1771
1772   // Ack the flushed, async touchmove. The ack should not reach the client, but
1773   // it should trigger sending of the (now non-cancelable) touchend.
1774   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1775   EXPECT_EQ(WebInputEvent::TouchEnd, sent_event().type);
1776   EXPECT_FALSE(sent_event().cancelable);
1777   EXPECT_EQ(1U, GetAndResetSentEventCount());
1778   EXPECT_EQ(0U, GetAndResetAckedEventCount());
1779   EXPECT_EQ(1U, queued_event_count());
1780
1781   // Ack the touchend.
1782   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1783   EXPECT_EQ(0U, queued_event_count());
1784   EXPECT_EQ(0U, GetAndResetSentEventCount());
1785   EXPECT_EQ(1U, GetAndResetAckedEventCount());
1786
1787   // Now mark the scrolls as not consumed (which would cause future touchmoves
1788   // in the active sequence to be sent if there was one).
1789   SendGestureEventAck(WebInputEvent::GestureScrollUpdate,
1790                       INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1791   SendGestureEventAck(WebInputEvent::GestureScrollUpdate,
1792                       INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1793
1794   // Start a new touch sequence and verify that throttling has been reset.
1795   // Touch moves after the start of scrolling will again be throttled.
1796   PressTouchPoint(0, 0);
1797   EXPECT_EQ(1U, GetAndResetSentEventCount());
1798   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1799   EXPECT_EQ(1U, GetAndResetAckedEventCount());
1800   MoveTouchPoint(0, 0, 5);
1801   followup_scroll.type = WebInputEvent::GestureScrollBegin;
1802   SetFollowupEvent(followup_scroll);
1803   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1804   EXPECT_EQ(1U, GetAndResetSentEventCount());
1805   EXPECT_EQ(1U, GetAndResetAckedEventCount());
1806
1807   MoveTouchPoint(0, 0, 5);
1808   followup_scroll.type = WebInputEvent::GestureScrollUpdate;
1809   SetFollowupEvent(followup_scroll);
1810   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1811   EXPECT_FALSE(HasPendingAsyncTouchMove());
1812   EXPECT_EQ(1U, GetAndResetSentEventCount());
1813   EXPECT_EQ(1U, GetAndResetAckedEventCount());
1814
1815   MoveTouchPoint(0, 0, 10);
1816   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1817   EXPECT_TRUE(HasPendingAsyncTouchMove());
1818   EXPECT_EQ(0U, queued_event_count());
1819   EXPECT_EQ(0U, GetAndResetSentEventCount());
1820   EXPECT_EQ(1U, GetAndResetAckedEventCount());
1821
1822   // As soon as a touchmove exceeds the outer slop region it will be forwarded
1823   // immediately.
1824   MoveTouchPoint(0, 0, 20);
1825   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1826   EXPECT_FALSE(HasPendingAsyncTouchMove());
1827   EXPECT_FALSE(sent_event().cancelable);
1828   EXPECT_EQ(0U, queued_event_count());
1829   EXPECT_EQ(1U, GetAndResetSentEventCount());
1830   EXPECT_EQ(1U, GetAndResetAckedEventCount());
1831
1832   // Subsequent touchmove's should be deferred.
1833   MoveTouchPoint(0, 0, 25);
1834   EXPECT_TRUE(HasPendingAsyncTouchMove());
1835   EXPECT_EQ(0U, queued_event_count());
1836   EXPECT_EQ(0U, GetAndResetSentEventCount());
1837   EXPECT_EQ(1U, GetAndResetAckedEventCount());
1838
1839   // The pending touchmove should be flushed with the the new touchmove if
1840   // sufficient time has passed.
1841   AdvanceTouchTime(kMinSecondsBetweenThrottledTouchmoves + 0.1);
1842   MoveTouchPoint(0, 0, 15);
1843   EXPECT_FALSE(HasPendingAsyncTouchMove());
1844   EXPECT_FALSE(sent_event().cancelable);
1845   EXPECT_EQ(1U, queued_event_count());
1846   EXPECT_EQ(1U, GetAndResetSentEventCount());
1847   EXPECT_EQ(0U, GetAndResetAckedEventCount());
1848   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1849   EXPECT_EQ(0U, queued_event_count());
1850   EXPECT_EQ(0U, GetAndResetSentEventCount());
1851   EXPECT_EQ(1U, GetAndResetAckedEventCount());
1852
1853   // Non-touchmove events should always flush any pending touchmove events.
1854   MoveTouchPoint(0, 0, 25);
1855   EXPECT_TRUE(HasPendingAsyncTouchMove());
1856   EXPECT_EQ(0U, queued_event_count());
1857   EXPECT_EQ(0U, GetAndResetSentEventCount());
1858   EXPECT_EQ(1U, GetAndResetAckedEventCount());
1859   PressTouchPoint(30, 30);
1860   EXPECT_FALSE(HasPendingAsyncTouchMove());
1861   EXPECT_FALSE(sent_event().cancelable);
1862   EXPECT_EQ(WebInputEvent::TouchMove, sent_event().type);
1863   EXPECT_EQ(1U, GetAndResetSentEventCount());
1864   EXPECT_EQ(2U, queued_event_count());
1865
1866   // Ack'ing the flushed, async touchmove will dispatch the touchstart. Note
1867   // that the flushed touchmove's ack will not reach the client (its
1868   // constituent events have already been ack'ed).
1869   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1870   EXPECT_FALSE(sent_event().cancelable);
1871   EXPECT_EQ(WebInputEvent::TouchStart, sent_event().type);
1872   EXPECT_EQ(1U, queued_event_count());
1873   EXPECT_EQ(1U, GetAndResetSentEventCount());
1874   EXPECT_EQ(0U, GetAndResetAckedEventCount());
1875
1876   // Ack the touchstart.
1877   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1878   EXPECT_EQ(0U, queued_event_count());
1879   EXPECT_EQ(0U, GetAndResetSentEventCount());
1880   EXPECT_EQ(1U, GetAndResetAckedEventCount());
1881
1882   // Send a secondary touchmove.
1883   MoveTouchPoint(1, 0, 25);
1884   EXPECT_TRUE(HasPendingAsyncTouchMove());
1885   EXPECT_EQ(0U, queued_event_count());
1886   EXPECT_EQ(0U, GetAndResetSentEventCount());
1887   EXPECT_EQ(1U, GetAndResetAckedEventCount());
1888
1889   // An unconsumed scroll should resume synchronous touch handling.
1890   SendGestureEventAck(WebInputEvent::GestureScrollUpdate,
1891                       INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1892
1893   // The pending touchmove should be coalesced with the next (now synchronous)
1894   // touchmove.
1895   MoveTouchPoint(0, 0, 25);
1896   EXPECT_TRUE(sent_event().cancelable);
1897   EXPECT_FALSE(HasPendingAsyncTouchMove());
1898   EXPECT_EQ(WebInputEvent::TouchMove, sent_event().type);
1899   EXPECT_EQ(WebTouchPoint::StateMoved, sent_event().touches[0].state);
1900   EXPECT_EQ(WebTouchPoint::StateMoved, sent_event().touches[1].state);
1901   EXPECT_EQ(1U, queued_event_count());
1902   EXPECT_EQ(1U, GetAndResetSentEventCount());
1903   EXPECT_EQ(0U, GetAndResetAckedEventCount());
1904
1905   // Subsequent touches will queue until the preceding, synchronous touches are
1906   // ack'ed.
1907   ReleaseTouchPoint(1);
1908   EXPECT_EQ(2U, queued_event_count());
1909   ReleaseTouchPoint(0);
1910   EXPECT_EQ(3U, queued_event_count());
1911   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1912   EXPECT_TRUE(sent_event().cancelable);
1913   EXPECT_EQ(WebInputEvent::TouchEnd, sent_event().type);
1914   EXPECT_EQ(2U, queued_event_count());
1915   EXPECT_EQ(1U, GetAndResetSentEventCount());
1916   EXPECT_EQ(1U, GetAndResetAckedEventCount());
1917
1918   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1919   EXPECT_TRUE(sent_event().cancelable);
1920   EXPECT_EQ(WebInputEvent::TouchEnd, sent_event().type);
1921   EXPECT_EQ(1U, queued_event_count());
1922   EXPECT_EQ(1U, GetAndResetSentEventCount());
1923   EXPECT_EQ(1U, GetAndResetAckedEventCount());
1924
1925   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1926   EXPECT_EQ(0U, queued_event_count());
1927   EXPECT_EQ(0U, GetAndResetSentEventCount());
1928   EXPECT_EQ(1U, GetAndResetAckedEventCount());
1929 }
1930
1931 // Ensure that async touch dispatch and touch ack timeout interactions work
1932 // appropriately.
1933 TEST_F(TouchEventQueueTest, AsyncTouchWithAckTimeout) {
1934   SetTouchScrollingMode(TouchEventQueue::TOUCH_SCROLLING_MODE_ASYNC_TOUCHMOVE);
1935   SetUpForTimeoutTesting(DefaultTouchTimeoutDelay());
1936
1937   // The touchstart should start the timeout.
1938   PressTouchPoint(0, 0);
1939   EXPECT_EQ(1U, GetAndResetSentEventCount());
1940   EXPECT_TRUE(IsTimeoutRunning());
1941   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1942   EXPECT_EQ(1U, GetAndResetAckedEventCount());
1943   EXPECT_FALSE(IsTimeoutRunning());
1944
1945   // The start of a scroll gesture should trigger async touch event dispatch.
1946   MoveTouchPoint(0, 1, 1);
1947   EXPECT_EQ(1U, GetAndResetSentEventCount());
1948   EXPECT_TRUE(IsTimeoutRunning());
1949   WebGestureEvent followup_scroll;
1950   followup_scroll.type = WebInputEvent::GestureScrollBegin;
1951   SetFollowupEvent(followup_scroll);
1952   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1953   EXPECT_FALSE(IsTimeoutRunning());
1954   EXPECT_EQ(1U, GetAndResetAckedEventCount());
1955
1956   SendGestureEventAck(WebInputEvent::GestureScrollUpdate,
1957                       INPUT_EVENT_ACK_STATE_CONSUMED);
1958
1959   // An async touch should fire after the throttling interval has expired, but
1960   // it should not start the touch ack timeout.
1961   MoveTouchPoint(0, 5, 5);
1962   EXPECT_TRUE(HasPendingAsyncTouchMove());
1963   EXPECT_EQ(1U, GetAndResetAckedEventCount());
1964
1965   AdvanceTouchTime(kMinSecondsBetweenThrottledTouchmoves + 0.1);
1966   MoveTouchPoint(0, 5, 5);
1967   EXPECT_FALSE(IsTimeoutRunning());
1968   EXPECT_FALSE(HasPendingAsyncTouchMove());
1969   EXPECT_FALSE(sent_event().cancelable);
1970   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1971   EXPECT_EQ(1U, GetAndResetAckedEventCount());
1972   EXPECT_EQ(1U, GetAndResetSentEventCount());
1973
1974   // An unconsumed scroll event will resume synchronous touchmoves, which are
1975   // subject to the ack timeout.
1976   SendGestureEventAck(WebInputEvent::GestureScrollUpdate,
1977                       INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1978   MoveTouchPoint(0, 20, 5);
1979   EXPECT_TRUE(IsTimeoutRunning());
1980   EXPECT_TRUE(sent_event().cancelable);
1981   EXPECT_EQ(1U, GetAndResetSentEventCount());
1982
1983   // The timeout should fire, disabling touch forwarding until both acks are
1984   // received and acking the timed out event.
1985   RunTasksAndWait(DefaultTouchTimeoutDelay() * 2);
1986   EXPECT_FALSE(IsTimeoutRunning());
1987   EXPECT_EQ(1U, GetAndResetAckedEventCount());
1988   EXPECT_EQ(0U, GetAndResetSentEventCount());
1989
1990   // Ack'ing the original event should trigger a cancel event.
1991   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1992   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1993   EXPECT_FALSE(sent_event().cancelable);
1994   EXPECT_EQ(0U, GetAndResetAckedEventCount());
1995   EXPECT_EQ(1U, GetAndResetSentEventCount());
1996
1997   // Subsequent touchmove's should not be forwarded, even as the scroll gesture
1998   // goes from unconsumed to consumed.
1999   SendGestureEventAck(WebInputEvent::GestureScrollUpdate,
2000                       INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
2001   MoveTouchPoint(0, 20, 5);
2002   EXPECT_FALSE(HasPendingAsyncTouchMove());
2003   EXPECT_EQ(1U, GetAndResetAckedEventCount());
2004   EXPECT_EQ(0U, GetAndResetSentEventCount());
2005
2006   SendGestureEventAck(WebInputEvent::GestureScrollUpdate,
2007                       INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
2008   MoveTouchPoint(0, 25, 5);
2009   EXPECT_FALSE(HasPendingAsyncTouchMove());
2010   EXPECT_EQ(1U, GetAndResetAckedEventCount());
2011   EXPECT_EQ(0U, GetAndResetSentEventCount());
2012 }
2013
2014 // Ensure that if the touch ack for an async touchmove triggers a follow-up
2015 // touch event, that follow-up touch will be forwarded appropriately.
2016 TEST_F(TouchEventQueueTest, AsyncTouchWithTouchCancelAfterAck) {
2017   SetTouchScrollingMode(TouchEventQueue::TOUCH_SCROLLING_MODE_ASYNC_TOUCHMOVE);
2018
2019   PressTouchPoint(0, 0);
2020   EXPECT_EQ(1U, GetAndResetSentEventCount());
2021   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
2022   EXPECT_EQ(1U, GetAndResetAckedEventCount());
2023
2024   // The start of a scroll gesture should trigger async touch event dispatch.
2025   MoveTouchPoint(0, 1, 1);
2026   EXPECT_EQ(1U, GetAndResetSentEventCount());
2027   WebGestureEvent followup_scroll;
2028   followup_scroll.type = WebInputEvent::GestureScrollBegin;
2029   SetFollowupEvent(followup_scroll);
2030   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
2031   EXPECT_EQ(1U, GetAndResetAckedEventCount());
2032   EXPECT_EQ(0U, queued_event_count());
2033
2034   SendGestureEvent(WebInputEvent::GestureScrollUpdate);
2035
2036   // The async touchmove should be ack'ed immediately, but not forwarded.
2037   // However, because the ack triggers a touchcancel, both the pending touch and
2038   // the queued touchcancel should be flushed.
2039   WebTouchEvent followup_cancel;
2040   followup_cancel.type = WebInputEvent::TouchCancel;
2041   followup_cancel.touchesLength = 1;
2042   followup_cancel.touches[0].state = WebTouchPoint::StateCancelled;
2043   SetFollowupEvent(followup_cancel);
2044   MoveTouchPoint(0, 5, 5);
2045   EXPECT_EQ(2U, queued_event_count());
2046   EXPECT_FALSE(sent_event().cancelable);
2047   EXPECT_FALSE(HasPendingAsyncTouchMove());
2048   EXPECT_EQ(WebInputEvent::TouchMove, acked_event().type);
2049   EXPECT_EQ(WebInputEvent::TouchMove, sent_event().type);
2050   EXPECT_EQ(1U, GetAndResetAckedEventCount());
2051   EXPECT_EQ(1U, GetAndResetSentEventCount());
2052
2053   // The ack for the async touchmove should not reach the client, as it has
2054   // already been ack'ed.
2055   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
2056   EXPECT_FALSE(sent_event().cancelable);
2057   EXPECT_EQ(1U, queued_event_count());
2058   EXPECT_EQ(WebInputEvent::TouchCancel, sent_event().type);
2059   EXPECT_EQ(0U, GetAndResetAckedEventCount());
2060   EXPECT_EQ(1U, GetAndResetSentEventCount());
2061
2062   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
2063   EXPECT_EQ(0U, queued_event_count());
2064   EXPECT_EQ(WebInputEvent::TouchCancel, acked_event().type);
2065   EXPECT_EQ(1U, GetAndResetAckedEventCount());
2066   EXPECT_EQ(0U, GetAndResetSentEventCount());
2067 }
2068
2069 TEST_F(TouchEventQueueTest, TouchAbsorptionWithConsumedFirstMove) {
2070   SetTouchScrollingMode(TouchEventQueue::TOUCH_SCROLLING_MODE_ASYNC_TOUCHMOVE);
2071
2072   // Queue a TouchStart.
2073   PressTouchPoint(0, 1);
2074   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
2075   EXPECT_EQ(0U, queued_event_count());
2076   EXPECT_EQ(1U, GetAndResetAckedEventCount());
2077
2078   MoveTouchPoint(0, 20, 5);
2079   SendGestureEvent(blink::WebInputEvent::GestureScrollBegin);
2080   SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
2081   EXPECT_EQ(0U, queued_event_count());
2082   EXPECT_EQ(2U, GetAndResetSentEventCount());
2083
2084   // Even if the first touchmove event was consumed, subsequent unconsumed
2085   // touchmove events should trigger scrolling.
2086   MoveTouchPoint(0, 60, 5);
2087   SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
2088   EXPECT_EQ(0U, queued_event_count());
2089   EXPECT_TRUE(sent_event().cancelable);
2090   EXPECT_EQ(1U, GetAndResetSentEventCount());
2091
2092   MoveTouchPoint(0, 20, 5);
2093   WebGestureEvent followup_scroll;
2094   followup_scroll.type = WebInputEvent::GestureScrollUpdate;
2095   SetFollowupEvent(followup_scroll);
2096   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
2097   SendGestureEventAck(WebInputEvent::GestureScrollUpdate,
2098                       INPUT_EVENT_ACK_STATE_CONSUMED);
2099   EXPECT_EQ(0U, queued_event_count());
2100   EXPECT_TRUE(sent_event().cancelable);
2101   EXPECT_EQ(1U, GetAndResetSentEventCount());
2102
2103   // Touch move event is throttled.
2104   MoveTouchPoint(0, 60, 5);
2105   SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
2106   EXPECT_EQ(0U, queued_event_count());
2107   EXPECT_EQ(0U, GetAndResetSentEventCount());
2108 }
2109
2110 }  // namespace content