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   // Queue another TouchStart.
 863   PressTouchPoint(20, 20);
 864   EXPECT_EQ(2U, queued_event_count());
 865   EXPECT_EQ(0U, GetAndResetSentEventCount());
 866   EXPECT_EQ(WebInputEvent::TouchStart, latest_event().type);
 867
 868   // GestureScrollBegin inserts a synthetic TouchCancel before the TouchStart.
 869   WebGestureEvent followup_scroll;
 870   followup_scroll.type = WebInputEvent::GestureScrollBegin;
 871   SetFollowupEvent(followup_scroll);
 872   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
 873   EXPECT_EQ(1U, GetAndResetSentEventCount());
 874   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 875   EXPECT_EQ(2U, queued_event_count());
 876   EXPECT_EQ(WebInputEvent::TouchCancel, sent_event().type);
 877   EXPECT_FALSE(sent_event().cancelable);
 878   EXPECT_EQ(WebInputEvent::TouchStart, latest_event().type);
 879
 880   // Acking the TouchCancel will result in dispatch of the next TouchStart.
 881   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
 882   // The synthetic TouchCancel should not reach client, only the TouchStart.
 883   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 884   EXPECT_EQ(0U, GetAndResetSentEventCount());
 885   EXPECT_EQ(WebInputEvent::TouchStart, acked_event().type);
 886
 887   // TouchMove should not be sent to the renderer.
 888   MoveTouchPoint(0, 30, 5);
 889   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 890   EXPECT_EQ(0U, GetAndResetSentEventCount());
 891   EXPECT_EQ(INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS, acked_event_state());
 892
 893   // GestureScrollUpdates should not change affect touch forwarding.
 894   SendGestureEvent(WebInputEvent::GestureScrollUpdate);
 895
 896   // TouchEnd should not be sent to the renderer.
 897   ReleaseTouchPoint(0);
 898   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 899   EXPECT_EQ(0U, GetAndResetSentEventCount());
 900   EXPECT_EQ(INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS, acked_event_state());
 901
 902   ReleaseTouchPoint(0);
 903   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 904   EXPECT_EQ(0U, GetAndResetSentEventCount());
 905   EXPECT_EQ(INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS, acked_event_state());
 906
 907   // Touch events from a new gesture sequence should be forwarded normally.
 908   PressTouchPoint(80, 10);
 909   EXPECT_EQ(1U, GetAndResetSentEventCount());
 910   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
 911   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 912
 913   MoveTouchPoint(0, 80, 20);
 914   EXPECT_EQ(1U, GetAndResetSentEventCount());
 915   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
 916   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 917
 918   ReleaseTouchPoint(0);
 919   EXPECT_EQ(1U, GetAndResetSentEventCount());
 920   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
 921   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 922 }
 923
 924 // Tests that a scroll event will not insert a synthetic TouchCancel if there
 925 // was no consumer for the current touch sequence.
 926 TEST_F(TouchEventQueueTest, NoTouchCancelOnScrollIfNoConsumer) {
 927   SetTouchScrollingMode(TouchEventQueue::TOUCH_SCROLLING_MODE_TOUCHCANCEL);
 928
 929   // Queue a TouchStart.
 930   PressTouchPoint(0, 1);
 931   EXPECT_EQ(1U, GetAndResetSentEventCount());
 932   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS);
 933   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 934   EXPECT_EQ(WebInputEvent::TouchStart, sent_event().type);
 935
 936   // Queue a TouchMove that turns into a GestureScrollBegin.
 937   WebGestureEvent followup_scroll;
 938   followup_scroll.type = WebInputEvent::GestureScrollBegin;
 939   SetFollowupEvent(followup_scroll);
 940   MoveTouchPoint(0, 20, 5);
 941
 942   // The TouchMove has no consumer, and should be ack'ed immediately. However,
 943   // *no* synthetic TouchCancel should be inserted as the touch sequence
 944   // had no consumer.
 945   EXPECT_EQ(0U, queued_event_count());
 946   EXPECT_EQ(0U, GetAndResetSentEventCount());
 947   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 948   EXPECT_EQ(0U, queued_event_count());
 949   EXPECT_EQ(WebInputEvent::TouchStart, sent_event().type);
 950
 951   // Subsequent TouchMove's should not be sent to the renderer.
 952   MoveTouchPoint(0, 30, 5);
 953   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 954   EXPECT_EQ(0U, GetAndResetSentEventCount());
 955   EXPECT_EQ(INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS, acked_event_state());
 956
 957   // TouchEnd should not be sent to the renderer.
 958   ReleaseTouchPoint(0);
 959   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 960   EXPECT_EQ(0U, GetAndResetSentEventCount());
 961   EXPECT_EQ(INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS, acked_event_state());
 962
 963   // Touch events from a new gesture sequence should be forwarded normally.
 964   PressTouchPoint(80, 10);
 965   EXPECT_EQ(1U, GetAndResetSentEventCount());
 966   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
 967   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 968 }
 969
 970 // Tests that IsTouchStartPendingAck works correctly.
 971 TEST_F(TouchEventQueueTest, PendingStart) {
 972
 973   EXPECT_FALSE(IsPendingAckTouchStart());
 974
 975   // Send the touchstart for one point (#1).
 976   PressTouchPoint(1, 1);
 977   EXPECT_EQ(1U, queued_event_count());
 978   EXPECT_TRUE(IsPendingAckTouchStart());
 979
 980   // Send a touchmove for that point (#2).
 981   MoveTouchPoint(0, 5, 5);
 982   EXPECT_EQ(2U, queued_event_count());
 983   EXPECT_TRUE(IsPendingAckTouchStart());
 984
 985   // Ack the touchstart (#1).
 986   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
 987   EXPECT_EQ(1U, queued_event_count());
 988   EXPECT_FALSE(IsPendingAckTouchStart());
 989
 990   // Send a touchstart for another point (#3).
 991   PressTouchPoint(10, 10);
 992   EXPECT_EQ(2U, queued_event_count());
 993   EXPECT_FALSE(IsPendingAckTouchStart());
 994
 995   // Ack the touchmove (#2).
 996   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
 997   EXPECT_EQ(1U, queued_event_count());
 998   EXPECT_TRUE(IsPendingAckTouchStart());
 999
1000   // Send a touchstart for a third point (#4).
1001   PressTouchPoint(15, 15);
1002   EXPECT_EQ(2U, queued_event_count());
1003   EXPECT_TRUE(IsPendingAckTouchStart());
1004
1005   // Ack the touchstart for the second point (#3).
1006   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1007   EXPECT_EQ(1U, queued_event_count());
1008   EXPECT_TRUE(IsPendingAckTouchStart());
1009
1010   // Ack the touchstart for the third point (#4).
1011   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1012   EXPECT_EQ(0U, queued_event_count());
1013   EXPECT_FALSE(IsPendingAckTouchStart());
1014 }
1015
1016 // Tests that the touch timeout is started when sending certain touch types.
1017 TEST_F(TouchEventQueueTest, TouchTimeoutTypes) {
1018   SetUpForTimeoutTesting(DefaultTouchTimeoutDelay());
1019
1020   // Sending a TouchStart will start the timeout.
1021   PressTouchPoint(0, 1);
1022   EXPECT_TRUE(IsTimeoutRunning());
1023   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1024   EXPECT_FALSE(IsTimeoutRunning());
1025
1026   // A TouchMove should start the timeout.
1027   MoveTouchPoint(0, 5, 5);
1028   EXPECT_TRUE(IsTimeoutRunning());
1029   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1030   EXPECT_FALSE(IsTimeoutRunning());
1031
1032   // A TouchEnd should not start the timeout.
1033   ReleaseTouchPoint(0);
1034   EXPECT_FALSE(IsTimeoutRunning());
1035   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1036   EXPECT_FALSE(IsTimeoutRunning());
1037
1038   // A TouchCancel should not start the timeout.
1039   PressTouchPoint(0, 1);
1040   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1041   ASSERT_FALSE(IsTimeoutRunning());
1042   CancelTouchPoint(0);
1043   EXPECT_FALSE(IsTimeoutRunning());
1044   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1045   EXPECT_FALSE(IsTimeoutRunning());
1046 }
1047
1048 // Tests that a delayed TouchEvent ack will trigger a TouchCancel timeout,
1049 // disabling touch forwarding until the next TouchStart is received after
1050 // the timeout events are ack'ed.
1051 TEST_F(TouchEventQueueTest, TouchTimeoutBasic) {
1052   SetUpForTimeoutTesting(DefaultTouchTimeoutDelay());
1053
1054   // Queue a TouchStart.
1055   GetAndResetSentEventCount();
1056   GetAndResetAckedEventCount();
1057   PressTouchPoint(0, 1);
1058   ASSERT_EQ(1U, GetAndResetSentEventCount());
1059   ASSERT_EQ(0U, GetAndResetAckedEventCount());
1060   EXPECT_TRUE(IsTimeoutRunning());
1061
1062   // Delay the ack.
1063   RunTasksAndWait(DefaultTouchTimeoutDelay() * 2);
1064
1065   // The timeout should have fired, synthetically ack'ing the timed-out event.
1066   // TouchEvent forwarding is disabled until the ack is received for the
1067   // timed-out event and the future cancel event.
1068   EXPECT_FALSE(IsTimeoutRunning());
1069   EXPECT_EQ(0U, GetAndResetSentEventCount());
1070   EXPECT_EQ(1U, GetAndResetAckedEventCount());
1071
1072   // Ack'ing the original event should trigger a cancel event.
1073   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1074   EXPECT_FALSE(IsTimeoutRunning());
1075   EXPECT_EQ(0U, GetAndResetAckedEventCount());
1076   EXPECT_EQ(1U, GetAndResetSentEventCount());
1077   EXPECT_EQ(WebInputEvent::TouchCancel, sent_event().type);
1078   EXPECT_FALSE(sent_event().cancelable);
1079
1080   // Touch events should not be forwarded until we receive the cancel acks.
1081   MoveTouchPoint(0, 1, 1);
1082   ASSERT_EQ(0U, GetAndResetSentEventCount());
1083   ASSERT_EQ(1U, GetAndResetAckedEventCount());
1084
1085   ReleaseTouchPoint(0);
1086   ASSERT_EQ(0U, GetAndResetSentEventCount());
1087   ASSERT_EQ(1U, GetAndResetAckedEventCount());
1088
1089   // The synthetic TouchCancel ack should not reach the client, but should
1090   // resume touch forwarding.
1091   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1092   EXPECT_EQ(0U, GetAndResetSentEventCount());
1093   EXPECT_EQ(0U, GetAndResetAckedEventCount());
1094
1095   // Subsequent events should be handled normally.
1096   PressTouchPoint(0, 1);
1097   EXPECT_EQ(1U, GetAndResetSentEventCount());
1098   EXPECT_EQ(0U, GetAndResetAckedEventCount());
1099   EXPECT_EQ(WebInputEvent::TouchStart, sent_event().type);
1100   EXPECT_TRUE(sent_event().cancelable);
1101 }
1102
1103 // Tests that the timeout is never started if the renderer consumes
1104 // a TouchEvent from the current touch sequence.
1105 TEST_F(TouchEventQueueTest, NoTouchTimeoutIfRendererIsConsumingGesture) {
1106   SetUpForTimeoutTesting(DefaultTouchTimeoutDelay());
1107
1108   // Queue a TouchStart.
1109   PressTouchPoint(0, 1);
1110   ASSERT_TRUE(IsTimeoutRunning());
1111
1112   // Mark the event as consumed. This should prevent the timeout from
1113   // being activated on subsequent TouchEvents in this gesture.
1114   SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
1115   EXPECT_FALSE(IsTimeoutRunning());
1116
1117   // A TouchMove should not start the timeout.
1118   MoveTouchPoint(0, 5, 5);
1119   EXPECT_FALSE(IsTimeoutRunning());
1120   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1121
1122   // A secondary TouchStart should not start the timeout.
1123   PressTouchPoint(1, 0);
1124   EXPECT_FALSE(IsTimeoutRunning());
1125   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1126
1127   // A TouchEnd should not start the timeout.
1128   ReleaseTouchPoint(1);
1129   EXPECT_FALSE(IsTimeoutRunning());
1130   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1131
1132   // A TouchCancel should not start the timeout.
1133   CancelTouchPoint(0);
1134   EXPECT_FALSE(IsTimeoutRunning());
1135 }
1136
1137 // Tests that the timeout is never started if the renderer consumes
1138 // a TouchEvent from the current touch sequence.
1139 TEST_F(TouchEventQueueTest, NoTouchTimeoutIfDisabledAfterTouchStart) {
1140   SetUpForTimeoutTesting(DefaultTouchTimeoutDelay());
1141
1142   // Queue a TouchStart.
1143   PressTouchPoint(0, 1);
1144   ASSERT_TRUE(IsTimeoutRunning());
1145
1146   // Send the ack immediately. The timeout should not have fired.
1147   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1148   EXPECT_FALSE(IsTimeoutRunning());
1149   EXPECT_TRUE(IsTimeoutEnabled());
1150   EXPECT_EQ(1U, GetAndResetSentEventCount());
1151   EXPECT_EQ(1U, GetAndResetAckedEventCount());
1152
1153   // Now explicitly disable the timeout.
1154   SetAckTimeoutDisabled();
1155   EXPECT_FALSE(IsTimeoutRunning());
1156   EXPECT_FALSE(IsTimeoutEnabled());
1157
1158   // A TouchMove should not start or trigger the timeout.
1159   MoveTouchPoint(0, 5, 5);
1160   EXPECT_FALSE(IsTimeoutRunning());
1161   EXPECT_EQ(1U, GetAndResetSentEventCount());
1162   RunTasksAndWait(DefaultTouchTimeoutDelay() * 2);
1163   EXPECT_EQ(0U, GetAndResetAckedEventCount());
1164 }
1165
1166 // Tests that the timeout is never started if the ack is synchronous.
1167 TEST_F(TouchEventQueueTest, NoTouchTimeoutIfAckIsSynchronous) {
1168   SetUpForTimeoutTesting(DefaultTouchTimeoutDelay());
1169
1170   // Queue a TouchStart.
1171   SetSyncAckResult(INPUT_EVENT_ACK_STATE_CONSUMED);
1172   ASSERT_FALSE(IsTimeoutRunning());
1173   PressTouchPoint(0, 1);
1174   EXPECT_FALSE(IsTimeoutRunning());
1175 }
1176
1177 // Tests that the timeout is disabled if the touch handler disappears.
1178 TEST_F(TouchEventQueueTest, NoTouchTimeoutIfTouchHandlerRemoved) {
1179   SetUpForTimeoutTesting(DefaultTouchTimeoutDelay());
1180
1181   // Queue a TouchStart.
1182   PressTouchPoint(0, 1);
1183   ASSERT_TRUE(IsTimeoutRunning());
1184
1185   // Unload the touch handler.
1186   OnHasTouchEventHandlers(false);
1187   EXPECT_FALSE(IsTimeoutRunning());
1188 }
1189
1190 // Tests that the timeout does not fire if explicitly disabled while an event
1191 // is in-flight.
1192 TEST_F(TouchEventQueueTest, NoTouchTimeoutIfDisabledWhileTimerIsActive) {
1193   SetUpForTimeoutTesting(DefaultTouchTimeoutDelay());
1194
1195   // Queue a TouchStart.
1196   PressTouchPoint(0, 1);
1197   ASSERT_TRUE(IsTimeoutRunning());
1198
1199   // Verify that disabling the timeout also turns off the timer.
1200   SetAckTimeoutDisabled();
1201   EXPECT_FALSE(IsTimeoutRunning());
1202   RunTasksAndWait(DefaultTouchTimeoutDelay() * 2);
1203   EXPECT_EQ(0U, GetAndResetAckedEventCount());
1204 }
1205
1206 // Tests that a TouchCancel timeout plays nice when the timed out touch stream
1207 // turns into a scroll gesture sequence.
1208 TEST_F(TouchEventQueueTest, TouchTimeoutWithFollowupGesture) {
1209   SetUpForTimeoutTesting(DefaultTouchTimeoutDelay());
1210
1211   // Queue a TouchStart.
1212   PressTouchPoint(0, 1);
1213   EXPECT_TRUE(IsTimeoutRunning());
1214   EXPECT_EQ(1U, GetAndResetSentEventCount());
1215
1216   // The cancelled sequence may turn into a scroll gesture.
1217   WebGestureEvent followup_scroll;
1218   followup_scroll.type = WebInputEvent::GestureScrollBegin;
1219   SetFollowupEvent(followup_scroll);
1220
1221   // Delay the ack.
1222   RunTasksAndWait(DefaultTouchTimeoutDelay() * 2);
1223
1224   // The timeout should have fired, disabling touch forwarding until both acks
1225   // are received, acking the timed out event.
1226   EXPECT_FALSE(IsTimeoutRunning());
1227   EXPECT_EQ(0U, GetAndResetSentEventCount());
1228   EXPECT_EQ(1U, GetAndResetAckedEventCount());
1229
1230   // Ack the original event, triggering a TouchCancel.
1231   SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
1232   EXPECT_FALSE(IsTimeoutRunning());
1233   EXPECT_EQ(1U, GetAndResetSentEventCount());
1234   EXPECT_EQ(0U, GetAndResetAckedEventCount());
1235
1236   // Ack the cancel event.  Normally, this would resume touch forwarding,
1237   // but we're still within a scroll gesture so it remains disabled.
1238   SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
1239   EXPECT_FALSE(IsTimeoutRunning());
1240   EXPECT_EQ(0U, GetAndResetSentEventCount());
1241   EXPECT_EQ(0U, GetAndResetAckedEventCount());
1242
1243   // Try to forward touch events for the current sequence.
1244   GetAndResetSentEventCount();
1245   GetAndResetAckedEventCount();
1246   MoveTouchPoint(0, 1, 1);
1247   ReleaseTouchPoint(0);
1248   EXPECT_FALSE(IsTimeoutRunning());
1249   EXPECT_EQ(0U, GetAndResetSentEventCount());
1250   EXPECT_EQ(2U, GetAndResetAckedEventCount());
1251
1252   // Now end the scroll sequence, resuming touch handling.
1253   SendGestureEvent(blink::WebInputEvent::GestureScrollEnd);
1254   PressTouchPoint(0, 1);
1255   EXPECT_TRUE(IsTimeoutRunning());
1256   EXPECT_EQ(1U, GetAndResetSentEventCount());
1257   EXPECT_EQ(0U, GetAndResetAckedEventCount());
1258 }
1259
1260 // Tests that a TouchCancel timeout plays nice when the timed out touch stream
1261 // turns into a scroll gesture sequence, but the original event acks are
1262 // significantly delayed.
1263 TEST_F(TouchEventQueueTest, TouchTimeoutWithFollowupGestureAndDelayedAck) {
1264   SetUpForTimeoutTesting(DefaultTouchTimeoutDelay());
1265
1266   // Queue a TouchStart.
1267   PressTouchPoint(0, 1);
1268   EXPECT_TRUE(IsTimeoutRunning());
1269   EXPECT_EQ(1U, GetAndResetSentEventCount());
1270
1271   // The cancelled sequence may turn into a scroll gesture.
1272   WebGestureEvent followup_scroll;
1273   followup_scroll.type = WebInputEvent::GestureScrollBegin;
1274   SetFollowupEvent(followup_scroll);
1275
1276   // Delay the ack.
1277   RunTasksAndWait(DefaultTouchTimeoutDelay() * 2);
1278
1279   // The timeout should have fired, disabling touch forwarding until both acks
1280   // are received and acking the timed out event.
1281   EXPECT_FALSE(IsTimeoutRunning());
1282   EXPECT_EQ(0U, GetAndResetSentEventCount());
1283   EXPECT_EQ(1U, GetAndResetAckedEventCount());
1284
1285   // Try to forward a touch event.
1286   GetAndResetSentEventCount();
1287   GetAndResetAckedEventCount();
1288   MoveTouchPoint(0, 1, 1);
1289   EXPECT_FALSE(IsTimeoutRunning());
1290   EXPECT_EQ(0U, GetAndResetSentEventCount());
1291   EXPECT_EQ(1U, GetAndResetAckedEventCount());
1292
1293   // Now end the scroll sequence.  Events will not be forwarded until the two
1294   // outstanding touch acks are received.
1295   SendGestureEvent(blink::WebInputEvent::GestureScrollEnd);
1296   MoveTouchPoint(0, 2, 2);
1297   ReleaseTouchPoint(0);
1298   EXPECT_FALSE(IsTimeoutRunning());
1299   EXPECT_EQ(0U, GetAndResetSentEventCount());
1300   EXPECT_EQ(2U, GetAndResetAckedEventCount());
1301
1302   // Ack the original event, triggering a cancel.
1303   SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
1304   EXPECT_EQ(1U, GetAndResetSentEventCount());
1305   EXPECT_EQ(0U, GetAndResetAckedEventCount());
1306
1307   // Ack the cancel event, resuming touch forwarding.
1308   SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
1309   EXPECT_EQ(0U, GetAndResetSentEventCount());
1310   EXPECT_EQ(0U, GetAndResetAckedEventCount());
1311
1312   PressTouchPoint(0, 1);
1313   EXPECT_TRUE(IsTimeoutRunning());
1314   EXPECT_EQ(1U, GetAndResetSentEventCount());
1315 }
1316
1317 // Tests that a delayed TouchEvent ack will not trigger a TouchCancel timeout if
1318 // the timed-out event had no consumer.
1319 TEST_F(TouchEventQueueTest, NoCancelOnTouchTimeoutWithoutConsumer) {
1320   SetUpForTimeoutTesting(DefaultTouchTimeoutDelay());
1321
1322   // Queue a TouchStart.
1323   PressTouchPoint(0, 1);
1324   ASSERT_EQ(1U, GetAndResetSentEventCount());
1325   ASSERT_EQ(0U, GetAndResetAckedEventCount());
1326   EXPECT_TRUE(IsTimeoutRunning());
1327
1328   // Delay the ack.
1329   RunTasksAndWait(DefaultTouchTimeoutDelay() * 2);
1330
1331   // The timeout should have fired, synthetically ack'ing the timed out event.
1332   // TouchEvent forwarding is disabled until the original ack is received.
1333   EXPECT_FALSE(IsTimeoutRunning());
1334   EXPECT_EQ(0U, GetAndResetSentEventCount());
1335   EXPECT_EQ(1U, GetAndResetAckedEventCount());
1336
1337   // Touch events should not be forwarded until we receive the original ack.
1338   MoveTouchPoint(0, 1, 1);
1339   ReleaseTouchPoint(0);
1340   ASSERT_EQ(0U, GetAndResetSentEventCount());
1341   ASSERT_EQ(2U, GetAndResetAckedEventCount());
1342
1343   // Ack'ing the original event should not trigger a cancel event, as the
1344   // TouchStart had no consumer.  However, it should re-enable touch forwarding.
1345   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS);
1346   EXPECT_FALSE(IsTimeoutRunning());
1347   EXPECT_EQ(0U, GetAndResetAckedEventCount());
1348   EXPECT_EQ(0U, GetAndResetSentEventCount());
1349
1350   // Subsequent events should be handled normally.
1351   PressTouchPoint(0, 1);
1352   EXPECT_EQ(1U, GetAndResetSentEventCount());
1353   EXPECT_EQ(0U, GetAndResetAckedEventCount());
1354 }
1355
1356 // Tests that TouchMove's are dropped if within the boundary-inclusive slop
1357 // suppression region for an unconsumed TouchStart.
1358 TEST_F(TouchEventQueueTest, TouchMoveSuppressionIncludingSlopBoundary) {
1359   const double kSlopLengthDips = 10.;
1360   const double kHalfSlopLengthDips = kSlopLengthDips / 2;
1361   const bool slop_includes_boundary = true;
1362   SetUpForTouchMoveSlopTesting(kSlopLengthDips, slop_includes_boundary);
1363
1364   // Queue a TouchStart.
1365   PressTouchPoint(0, 0);
1366   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1367   ASSERT_EQ(1U, GetAndResetSentEventCount());
1368   ASSERT_EQ(1U, GetAndResetAckedEventCount());
1369
1370   // TouchMove's within the region should be suppressed.
1371   MoveTouchPoint(0, 0, kHalfSlopLengthDips);
1372   EXPECT_EQ(0U, queued_event_count());
1373   EXPECT_EQ(0U, GetAndResetSentEventCount());
1374   EXPECT_EQ(1U, GetAndResetAckedEventCount());
1375   EXPECT_EQ(INPUT_EVENT_ACK_STATE_NOT_CONSUMED, acked_event_state());
1376
1377   MoveTouchPoint(0, kHalfSlopLengthDips, 0);
1378   EXPECT_EQ(0U, queued_event_count());
1379   EXPECT_EQ(0U, GetAndResetSentEventCount());
1380   EXPECT_EQ(1U, GetAndResetAckedEventCount());
1381   EXPECT_EQ(INPUT_EVENT_ACK_STATE_NOT_CONSUMED, acked_event_state());
1382
1383   MoveTouchPoint(0, -kHalfSlopLengthDips, 0);
1384   EXPECT_EQ(0U, queued_event_count());
1385   EXPECT_EQ(0U, GetAndResetSentEventCount());
1386   EXPECT_EQ(1U, GetAndResetAckedEventCount());
1387   EXPECT_EQ(INPUT_EVENT_ACK_STATE_NOT_CONSUMED, acked_event_state());
1388
1389   MoveTouchPoint(0, -kSlopLengthDips, 0);
1390   EXPECT_EQ(0U, queued_event_count());
1391   EXPECT_EQ(0U, GetAndResetSentEventCount());
1392   EXPECT_EQ(1U, GetAndResetAckedEventCount());
1393   EXPECT_EQ(INPUT_EVENT_ACK_STATE_NOT_CONSUMED, acked_event_state());
1394
1395   MoveTouchPoint(0, 0, kSlopLengthDips);
1396   EXPECT_EQ(0U, queued_event_count());
1397   EXPECT_EQ(0U, GetAndResetSentEventCount());
1398   EXPECT_EQ(1U, GetAndResetAckedEventCount());
1399   EXPECT_EQ(INPUT_EVENT_ACK_STATE_NOT_CONSUMED, acked_event_state());
1400
1401   // As soon as a TouchMove exceeds the (Euclidean) distance, no more
1402   // TouchMove's should be suppressed.
1403   const double kFortyFiveDegreeSlopLengthXY =
1404       kSlopLengthDips * std::sqrt(2.) / 2.;
1405   MoveTouchPoint(0, kFortyFiveDegreeSlopLengthXY + .2,
1406                     kFortyFiveDegreeSlopLengthXY + .2);
1407   EXPECT_EQ(1U, queued_event_count());
1408   EXPECT_EQ(1U, GetAndResetSentEventCount());
1409   EXPECT_EQ(0U, GetAndResetAckedEventCount());
1410   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1411   EXPECT_EQ(1U, GetAndResetAckedEventCount());
1412
1413   // Even TouchMove's within the original slop region should now be forwarded.
1414   MoveTouchPoint(0, 0, 0);
1415   EXPECT_EQ(1U, queued_event_count());
1416   EXPECT_EQ(1U, GetAndResetSentEventCount());
1417   EXPECT_EQ(0U, GetAndResetAckedEventCount());
1418   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1419   EXPECT_EQ(1U, GetAndResetAckedEventCount());
1420
1421   // A new touch sequence should reset suppression.
1422   ReleaseTouchPoint(0);
1423   PressTouchPoint(0, 0);
1424   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1425   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1426   ASSERT_EQ(2U, GetAndResetSentEventCount());
1427   ASSERT_EQ(2U, GetAndResetAckedEventCount());
1428   ASSERT_EQ(0U, queued_event_count());
1429
1430   // The slop region is boundary-inclusive.
1431   MoveTouchPoint(0, kSlopLengthDips - 1., 0);
1432   EXPECT_EQ(0U, queued_event_count());
1433   EXPECT_EQ(0U, GetAndResetSentEventCount());
1434   EXPECT_EQ(1U, GetAndResetAckedEventCount());
1435
1436   MoveTouchPoint(0, kSlopLengthDips, 0);
1437   EXPECT_EQ(0U, queued_event_count());
1438   EXPECT_EQ(0U, GetAndResetSentEventCount());
1439   EXPECT_EQ(1U, GetAndResetAckedEventCount());
1440 }
1441
1442 // Tests that TouchMove's are dropped if within the boundary-exclusive slop
1443 // suppression region for an unconsumed TouchStart.
1444 TEST_F(TouchEventQueueTest, TouchMoveSuppressionExcludingSlopBoundary) {
1445   const double kSlopLengthDips = 10.;
1446   const double kHalfSlopLengthDips = kSlopLengthDips / 2;
1447   const bool slop_includes_boundary = false;
1448   SetUpForTouchMoveSlopTesting(kSlopLengthDips, slop_includes_boundary);
1449
1450   // Queue a TouchStart.
1451   PressTouchPoint(0, 0);
1452   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1453   ASSERT_EQ(1U, GetAndResetSentEventCount());
1454   ASSERT_EQ(1U, GetAndResetAckedEventCount());
1455
1456   // TouchMove's within the region should be suppressed.
1457   MoveTouchPoint(0, 0, kHalfSlopLengthDips);
1458   EXPECT_EQ(0U, queued_event_count());
1459   EXPECT_EQ(0U, GetAndResetSentEventCount());
1460   EXPECT_EQ(1U, GetAndResetAckedEventCount());
1461   EXPECT_EQ(INPUT_EVENT_ACK_STATE_NOT_CONSUMED, acked_event_state());
1462
1463   MoveTouchPoint(0, kSlopLengthDips - 0.2f, 0);
1464   EXPECT_EQ(0U, queued_event_count());
1465   EXPECT_EQ(0U, GetAndResetSentEventCount());
1466   EXPECT_EQ(1U, GetAndResetAckedEventCount());
1467   EXPECT_EQ(INPUT_EVENT_ACK_STATE_NOT_CONSUMED, acked_event_state());
1468
1469   // As soon as a TouchMove reaches the (Euclidean) slop distance, no more
1470   // TouchMove's should be suppressed.
1471   MoveTouchPoint(0, kSlopLengthDips, 0);
1472   EXPECT_EQ(1U, queued_event_count());
1473   EXPECT_EQ(1U, GetAndResetSentEventCount());
1474   EXPECT_EQ(0U, GetAndResetAckedEventCount());
1475   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1476   EXPECT_EQ(1U, GetAndResetAckedEventCount());
1477
1478   MoveTouchPoint(0, kHalfSlopLengthDips, 0);
1479   EXPECT_EQ(1U, queued_event_count());
1480   EXPECT_EQ(1U, GetAndResetSentEventCount());
1481   EXPECT_EQ(0U, GetAndResetAckedEventCount());
1482   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1483   EXPECT_EQ(1U, GetAndResetAckedEventCount());
1484 }
1485
1486 // Tests that TouchMove's are not dropped within the slop suppression region if
1487 // the touchstart was consumed.
1488 TEST_F(TouchEventQueueTest, NoTouchMoveSuppressionAfterTouchConsumed) {
1489   const double kSlopLengthDips = 10.;
1490   const double kHalfSlopLengthDips = kSlopLengthDips / 2;
1491   const bool slop_includes_boundary = true;
1492   SetUpForTouchMoveSlopTesting(kSlopLengthDips, slop_includes_boundary);
1493
1494   // Queue a TouchStart.
1495   PressTouchPoint(0, 0);
1496   SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
1497   ASSERT_EQ(1U, GetAndResetSentEventCount());
1498   ASSERT_EQ(1U, GetAndResetAckedEventCount());
1499
1500   // TouchMove's within the region should not be suppressed, as a touch was
1501   // consumed.
1502   MoveTouchPoint(0, 0, kHalfSlopLengthDips);
1503   EXPECT_EQ(1U, queued_event_count());
1504   EXPECT_EQ(1U, GetAndResetSentEventCount());
1505   EXPECT_EQ(0U, GetAndResetAckedEventCount());
1506 }
1507
1508 // Tests that TouchMove's are not dropped due to incorrect handling of DPI
1509 // scaling.
1510 TEST_F(TouchEventQueueTest, TouchMoveSuppressionWithDIPScaling) {
1511   const float kSlopLengthPixels = 7.f;
1512   const float kDPIScale = 3.f;
1513   const bool slop_includes_boundary = true;
1514   SetUpForTouchMoveSlopTesting(kSlopLengthPixels / kDPIScale,
1515                                slop_includes_boundary);
1516
1517   // Queue a TouchStart.
1518   PressTouchPoint(0, 0);
1519   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1520   ASSERT_EQ(1U, GetAndResetSentEventCount());
1521   ASSERT_EQ(1U, GetAndResetAckedEventCount());
1522
1523   // TouchMove's along the slop boundary should be suppresed.
1524   MoveTouchPoint(0, 0, kSlopLengthPixels / kDPIScale);
1525   EXPECT_EQ(0U, queued_event_count());
1526   EXPECT_EQ(0U, GetAndResetSentEventCount());
1527   EXPECT_EQ(1U, GetAndResetAckedEventCount());
1528
1529   // Reset the touch sequence.
1530   ReleaseTouchPoint(0);
1531   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1532   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1533   GetAndResetSentEventCount();
1534   GetAndResetAckedEventCount();
1535
1536   // Queue a TouchStart.
1537   PressTouchPoint(0, 0);
1538   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1539   ASSERT_EQ(1U, GetAndResetSentEventCount());
1540   ASSERT_EQ(1U, GetAndResetAckedEventCount());
1541
1542   // TouchMove's outside the region should not be suppressed.
1543   const float kPixelCoordOutsideSlopRegion = kSlopLengthPixels + 0.5f;
1544   MoveTouchPoint(0, 0, kPixelCoordOutsideSlopRegion / kDPIScale);
1545   EXPECT_EQ(1U, queued_event_count());
1546   EXPECT_EQ(1U, GetAndResetSentEventCount());
1547   EXPECT_EQ(0U, GetAndResetAckedEventCount());
1548 }
1549
1550 // Tests that TouchMove's are not dropped if a secondary pointer is present
1551 // during any movement.
1552 TEST_F(TouchEventQueueTest, NoTouchMoveSuppressionAfterMultiTouch) {
1553   const double kSlopLengthDips = 10.;
1554   const double kHalfSlopLengthDips = kSlopLengthDips / 2;
1555   const bool slop_includes_boundary = true;
1556   SetUpForTouchMoveSlopTesting(kSlopLengthDips, slop_includes_boundary);
1557
1558   // Queue a TouchStart.
1559   PressTouchPoint(0, 0);
1560   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1561   ASSERT_EQ(1U, GetAndResetSentEventCount());
1562   ASSERT_EQ(1U, GetAndResetAckedEventCount());
1563
1564   // TouchMove's within the region should be suppressed.
1565   MoveTouchPoint(0, 0, kHalfSlopLengthDips);
1566   EXPECT_EQ(0U, queued_event_count());
1567   EXPECT_EQ(0U, GetAndResetSentEventCount());
1568   EXPECT_EQ(1U, GetAndResetAckedEventCount());
1569
1570   // Simulate a secondary pointer press.
1571   PressTouchPoint(kSlopLengthDips, 0);
1572   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1573   EXPECT_EQ(1U, GetAndResetSentEventCount());
1574   EXPECT_EQ(1U, GetAndResetAckedEventCount());
1575
1576   // TouchMove with a secondary pointer should not be suppressed.
1577   MoveTouchPoint(1, kSlopLengthDips, 0);
1578   EXPECT_EQ(1U, queued_event_count());
1579   EXPECT_EQ(1U, GetAndResetSentEventCount());
1580   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1581   EXPECT_EQ(1U, GetAndResetAckedEventCount());
1582
1583   // Release the secondary pointer.
1584   ReleaseTouchPoint(0);
1585   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1586   EXPECT_EQ(1U, GetAndResetSentEventCount());
1587   EXPECT_EQ(1U, GetAndResetAckedEventCount());
1588
1589   // TouchMove's should not should be suppressed, even with the original
1590   // unmoved pointer.
1591   MoveTouchPoint(0, 0, 0);
1592   EXPECT_EQ(1U, queued_event_count());
1593   EXPECT_EQ(1U, GetAndResetSentEventCount());
1594   EXPECT_EQ(0U, GetAndResetAckedEventCount());
1595 }
1596
1597 // Tests that secondary touch points can be forwarded even if the primary touch
1598 // point had no consumer.
1599 TEST_F(TouchEventQueueTest, SecondaryTouchForwardedAfterPrimaryHadNoConsumer) {
1600   // Queue a TouchStart.
1601   PressTouchPoint(0, 0);
1602   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS);
1603   ASSERT_EQ(1U, GetAndResetSentEventCount());
1604   ASSERT_EQ(1U, GetAndResetAckedEventCount());
1605
1606   // Events should not be forwarded, as the point had no consumer.
1607   MoveTouchPoint(0, 0, 15);
1608   EXPECT_EQ(0U, queued_event_count());
1609   EXPECT_EQ(0U, GetAndResetSentEventCount());
1610   EXPECT_EQ(1U, GetAndResetAckedEventCount());
1611
1612   // Simulate a secondary pointer press.
1613   PressTouchPoint(20, 0);
1614   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1615   EXPECT_EQ(1U, GetAndResetSentEventCount());
1616   EXPECT_EQ(1U, GetAndResetAckedEventCount());
1617
1618   // TouchMove with a secondary pointer should not be suppressed.
1619   MoveTouchPoint(1, 25, 0);
1620   EXPECT_EQ(1U, queued_event_count());
1621   EXPECT_EQ(1U, GetAndResetSentEventCount());
1622   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1623   EXPECT_EQ(1U, GetAndResetAckedEventCount());
1624 }
1625
1626 // Tests that no touch points will be forwarded after scrolling begins while no
1627 // touch points have a consumer.
1628 TEST_F(TouchEventQueueTest, NoForwardingAfterScrollWithNoTouchConsumers) {
1629   // Queue a TouchStart.
1630   PressTouchPoint(0, 0);
1631   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS);
1632   ASSERT_EQ(1U, GetAndResetSentEventCount());
1633   ASSERT_EQ(1U, GetAndResetAckedEventCount());
1634
1635   WebGestureEvent followup_scroll;
1636   followup_scroll.type = WebInputEvent::GestureScrollBegin;
1637   SetFollowupEvent(followup_scroll);
1638   MoveTouchPoint(0, 20, 5);
1639   EXPECT_EQ(0U, GetAndResetSentEventCount());
1640   EXPECT_EQ(1U, GetAndResetAckedEventCount());
1641   EXPECT_EQ(INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS, acked_event_state());
1642
1643   // The secondary pointer press should not be forwarded.
1644   PressTouchPoint(20, 0);
1645   EXPECT_EQ(0U, GetAndResetSentEventCount());
1646   EXPECT_EQ(1U, GetAndResetAckedEventCount());
1647   EXPECT_EQ(INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS, acked_event_state());
1648
1649   // Neither should any further touchmoves be forwarded.
1650   MoveTouchPoint(1, 25, 0);
1651   EXPECT_EQ(0U, GetAndResetSentEventCount());
1652   EXPECT_EQ(1U, GetAndResetAckedEventCount());
1653   EXPECT_EQ(INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS, acked_event_state());
1654 }
1655
1656 TEST_F(TouchEventQueueTest, SyncTouchMoveDoesntCancelTouchOnScroll) {
1657  SetTouchScrollingMode(TouchEventQueue::TOUCH_SCROLLING_MODE_SYNC_TOUCHMOVE);
1658  // Queue a TouchStart.
1659  PressTouchPoint(0, 1);
1660  EXPECT_EQ(1U, GetAndResetSentEventCount());
1661  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1662  EXPECT_EQ(1U, GetAndResetAckedEventCount());
1663
1664  MoveTouchPoint(0, 20, 5);
1665  EXPECT_EQ(1U, queued_event_count());
1666  EXPECT_EQ(1U, GetAndResetSentEventCount());
1667
1668  // GestureScrollBegin doesn't insert a synthetic TouchCancel.
1669  WebGestureEvent followup_scroll;
1670  followup_scroll.type = WebInputEvent::GestureScrollBegin;
1671  SetFollowupEvent(followup_scroll);
1672  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1673  EXPECT_EQ(0U, GetAndResetSentEventCount());
1674  EXPECT_EQ(1U, GetAndResetAckedEventCount());
1675  EXPECT_EQ(0U, queued_event_count());
1676 }
1677
1678 TEST_F(TouchEventQueueTest, AsyncTouch) {
1679   SetTouchScrollingMode(TouchEventQueue::TOUCH_SCROLLING_MODE_ASYNC_TOUCHMOVE);
1680
1681   // Queue a TouchStart.
1682   PressTouchPoint(0, 1);
1683   EXPECT_EQ(1U, GetAndResetSentEventCount());
1684   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1685   EXPECT_EQ(1U, GetAndResetAckedEventCount());
1686
1687   for (int i = 0; i < 3; ++i) {
1688    SendGestureEventAck(WebInputEvent::GestureScrollUpdate,
1689                        INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1690
1691    MoveTouchPoint(0, 10, 5);
1692    SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1693    EXPECT_FALSE(HasPendingAsyncTouchMove());
1694    EXPECT_TRUE(sent_event().cancelable);
1695    EXPECT_EQ(0U, queued_event_count());
1696    EXPECT_EQ(1U, GetAndResetSentEventCount());
1697
1698    // Consuming a scroll event will throttle subsequent touchmoves.
1699    SendGestureEventAck(WebInputEvent::GestureScrollUpdate,
1700                        INPUT_EVENT_ACK_STATE_CONSUMED);
1701    MoveTouchPoint(0, 10, 5);
1702    SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1703    EXPECT_TRUE(HasPendingAsyncTouchMove());
1704    EXPECT_EQ(0U, queued_event_count());
1705    EXPECT_EQ(0U, GetAndResetSentEventCount());
1706   }
1707 }
1708
1709 // Ensure that touchmove's are appropriately throttled during a typical
1710 // scroll sequences that transitions between scrolls consumed and unconsumed.
1711 TEST_F(TouchEventQueueTest, AsyncTouchThrottledAfterScroll) {
1712   SetTouchScrollingMode(TouchEventQueue::TOUCH_SCROLLING_MODE_ASYNC_TOUCHMOVE);
1713
1714   // Process a TouchStart
1715   PressTouchPoint(0, 1);
1716   EXPECT_EQ(1U, GetAndResetSentEventCount());
1717   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1718   EXPECT_EQ(1U, GetAndResetAckedEventCount());
1719
1720   // Now send the first touch move and associated GestureScrollBegin,
1721   // but don't ACK the gesture event yet.
1722   MoveTouchPoint(0, 0, 5);
1723   WebGestureEvent followup_scroll;
1724   followup_scroll.type = WebInputEvent::GestureScrollBegin;
1725   SetFollowupEvent(followup_scroll);
1726   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1727   EXPECT_EQ(1U, GetAndResetSentEventCount());
1728   EXPECT_EQ(1U, GetAndResetAckedEventCount());
1729
1730   // Now queue a second touchmove and verify it's not (yet) dispatched.
1731   MoveTouchPoint(0, 0, 10);
1732   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1733   EXPECT_TRUE(HasPendingAsyncTouchMove());
1734   EXPECT_EQ(0U, queued_event_count());
1735   EXPECT_EQ(0U, GetAndResetSentEventCount());
1736   EXPECT_EQ(1U, GetAndResetAckedEventCount());
1737
1738   // Queuing the final touchend should flush the pending, async touchmove.
1739   ReleaseTouchPoint(0);
1740   EXPECT_EQ(WebInputEvent::TouchMove, sent_event().type);
1741   EXPECT_FALSE(HasPendingAsyncTouchMove());
1742   EXPECT_FALSE(sent_event().cancelable);
1743   EXPECT_EQ(1U, GetAndResetSentEventCount());
1744   EXPECT_EQ(2U, queued_event_count());
1745
1746   // Ack the flushed, async touchmove. The ack should not reach the client, but
1747   // it should trigger sending of the (now non-cancelable) touchend.
1748   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1749   EXPECT_EQ(WebInputEvent::TouchEnd, sent_event().type);
1750   EXPECT_FALSE(sent_event().cancelable);
1751   EXPECT_EQ(1U, GetAndResetSentEventCount());
1752   EXPECT_EQ(0U, GetAndResetAckedEventCount());
1753   EXPECT_EQ(1U, queued_event_count());
1754
1755   // Ack the touchend.
1756   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1757   EXPECT_EQ(0U, queued_event_count());
1758   EXPECT_EQ(0U, GetAndResetSentEventCount());
1759   EXPECT_EQ(1U, GetAndResetAckedEventCount());
1760
1761   // Now mark the scroll as not consumed (which would cause future
1762   // touchmoves in the active sequence to be sent if there was one).
1763   SendGestureEventAck(WebInputEvent::GestureScrollBegin,
1764       INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1765
1766   // Start a new touch sequence and verify that throttling has been reset.
1767   // Touch moves after the start of scrolling will again be throttled.
1768   PressTouchPoint(0, 0);
1769   EXPECT_EQ(1U, GetAndResetSentEventCount());
1770   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1771   EXPECT_EQ(1U, GetAndResetAckedEventCount());
1772   MoveTouchPoint(0, 0, 5);
1773   SetFollowupEvent(followup_scroll);
1774   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1775   EXPECT_EQ(1U, GetAndResetSentEventCount());
1776   EXPECT_EQ(1U, GetAndResetAckedEventCount());
1777   MoveTouchPoint(0, 0, 10);
1778   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1779   EXPECT_TRUE(HasPendingAsyncTouchMove());
1780   EXPECT_EQ(0U, queued_event_count());
1781   EXPECT_EQ(0U, GetAndResetSentEventCount());
1782   EXPECT_EQ(1U, GetAndResetAckedEventCount());
1783
1784   // As soon as a touchmove exceeds the outer slop region it will be forwarded
1785   // immediately.
1786   MoveTouchPoint(0, 0, 20);
1787   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1788   EXPECT_FALSE(HasPendingAsyncTouchMove());
1789   EXPECT_FALSE(sent_event().cancelable);
1790   EXPECT_EQ(0U, queued_event_count());
1791   EXPECT_EQ(1U, GetAndResetSentEventCount());
1792   EXPECT_EQ(1U, GetAndResetAckedEventCount());
1793
1794   // Subsequent touchmove's should be deferred.
1795   MoveTouchPoint(0, 0, 25);
1796   EXPECT_TRUE(HasPendingAsyncTouchMove());
1797   EXPECT_EQ(0U, queued_event_count());
1798   EXPECT_EQ(0U, GetAndResetSentEventCount());
1799   EXPECT_EQ(1U, GetAndResetAckedEventCount());
1800
1801   // The pending touchmove should be flushed with the the new touchmove if
1802   // sufficient time has passed.
1803   AdvanceTouchTime(kMinSecondsBetweenThrottledTouchmoves + 0.1);
1804   MoveTouchPoint(0, 0, 15);
1805   EXPECT_FALSE(HasPendingAsyncTouchMove());
1806   EXPECT_FALSE(sent_event().cancelable);
1807   EXPECT_EQ(1U, queued_event_count());
1808   EXPECT_EQ(1U, GetAndResetSentEventCount());
1809   EXPECT_EQ(0U, GetAndResetAckedEventCount());
1810   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1811   EXPECT_EQ(0U, queued_event_count());
1812   EXPECT_EQ(0U, GetAndResetSentEventCount());
1813   EXPECT_EQ(1U, GetAndResetAckedEventCount());
1814
1815   // Non-touchmove events should always flush any pending touchmove events.
1816   MoveTouchPoint(0, 0, 25);
1817   EXPECT_TRUE(HasPendingAsyncTouchMove());
1818   EXPECT_EQ(0U, queued_event_count());
1819   EXPECT_EQ(0U, GetAndResetSentEventCount());
1820   EXPECT_EQ(1U, GetAndResetAckedEventCount());
1821   PressTouchPoint(30, 30);
1822   EXPECT_FALSE(HasPendingAsyncTouchMove());
1823   EXPECT_FALSE(sent_event().cancelable);
1824   EXPECT_EQ(WebInputEvent::TouchMove, sent_event().type);
1825   EXPECT_EQ(1U, GetAndResetSentEventCount());
1826   EXPECT_EQ(2U, queued_event_count());
1827
1828   // Ack'ing the flushed, async touchmove will dispatch the touchstart. Note
1829   // that the flushed touchmove's ack will not reach the client (its
1830   // constituent events have already been ack'ed).
1831   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1832   EXPECT_FALSE(sent_event().cancelable);
1833   EXPECT_EQ(WebInputEvent::TouchStart, sent_event().type);
1834   EXPECT_EQ(1U, queued_event_count());
1835   EXPECT_EQ(1U, GetAndResetSentEventCount());
1836   EXPECT_EQ(0U, GetAndResetAckedEventCount());
1837
1838   // Ack the touchstart.
1839   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1840   EXPECT_EQ(0U, queued_event_count());
1841   EXPECT_EQ(0U, GetAndResetSentEventCount());
1842   EXPECT_EQ(1U, GetAndResetAckedEventCount());
1843
1844   // Send a secondary touchmove.
1845   MoveTouchPoint(1, 0, 25);
1846   EXPECT_TRUE(HasPendingAsyncTouchMove());
1847   EXPECT_EQ(0U, queued_event_count());
1848   EXPECT_EQ(0U, GetAndResetSentEventCount());
1849   EXPECT_EQ(1U, GetAndResetAckedEventCount());
1850
1851   // An unconsumed scroll should resume synchronous touch handling.
1852   SendGestureEventAck(WebInputEvent::GestureScrollUpdate,
1853                       INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1854
1855   // The pending touchmove should be coalesced with the next (now synchronous)
1856   // touchmove.
1857   MoveTouchPoint(0, 0, 25);
1858   EXPECT_TRUE(sent_event().cancelable);
1859   EXPECT_FALSE(HasPendingAsyncTouchMove());
1860   EXPECT_EQ(WebInputEvent::TouchMove, sent_event().type);
1861   EXPECT_EQ(WebTouchPoint::StateMoved, sent_event().touches[0].state);
1862   EXPECT_EQ(WebTouchPoint::StateMoved, sent_event().touches[1].state);
1863   EXPECT_EQ(1U, queued_event_count());
1864   EXPECT_EQ(1U, GetAndResetSentEventCount());
1865   EXPECT_EQ(0U, GetAndResetAckedEventCount());
1866
1867   // Subsequent touches will queue until the preceding, synchronous touches are
1868   // ack'ed.
1869   ReleaseTouchPoint(1);
1870   EXPECT_EQ(2U, queued_event_count());
1871   ReleaseTouchPoint(0);
1872   EXPECT_EQ(3U, queued_event_count());
1873   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1874   EXPECT_TRUE(sent_event().cancelable);
1875   EXPECT_EQ(WebInputEvent::TouchEnd, sent_event().type);
1876   EXPECT_EQ(2U, queued_event_count());
1877   EXPECT_EQ(1U, GetAndResetSentEventCount());
1878   EXPECT_EQ(1U, GetAndResetAckedEventCount());
1879
1880   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1881   EXPECT_TRUE(sent_event().cancelable);
1882   EXPECT_EQ(WebInputEvent::TouchEnd, sent_event().type);
1883   EXPECT_EQ(1U, queued_event_count());
1884   EXPECT_EQ(1U, GetAndResetSentEventCount());
1885   EXPECT_EQ(1U, GetAndResetAckedEventCount());
1886
1887   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1888   EXPECT_EQ(0U, queued_event_count());
1889   EXPECT_EQ(0U, GetAndResetSentEventCount());
1890   EXPECT_EQ(1U, GetAndResetAckedEventCount());
1891 }
1892
1893 // Ensure that async touch dispatch and touch ack timeout interactions work
1894 // appropriately.
1895 TEST_F(TouchEventQueueTest, AsyncTouchWithAckTimeout) {
1896   SetTouchScrollingMode(TouchEventQueue::TOUCH_SCROLLING_MODE_ASYNC_TOUCHMOVE);
1897   SetUpForTimeoutTesting(DefaultTouchTimeoutDelay());
1898
1899   // The touchstart should start the timeout.
1900   PressTouchPoint(0, 0);
1901   EXPECT_EQ(1U, GetAndResetSentEventCount());
1902   EXPECT_TRUE(IsTimeoutRunning());
1903   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1904   EXPECT_EQ(1U, GetAndResetAckedEventCount());
1905   EXPECT_FALSE(IsTimeoutRunning());
1906
1907   // The start of a scroll gesture should trigger async touch event dispatch.
1908   MoveTouchPoint(0, 1, 1);
1909   EXPECT_EQ(1U, GetAndResetSentEventCount());
1910   EXPECT_TRUE(IsTimeoutRunning());
1911   WebGestureEvent followup_scroll;
1912   followup_scroll.type = WebInputEvent::GestureScrollBegin;
1913   SetFollowupEvent(followup_scroll);
1914   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1915   EXPECT_FALSE(IsTimeoutRunning());
1916   EXPECT_EQ(1U, GetAndResetAckedEventCount());
1917
1918   SendGestureEventAck(WebInputEvent::GestureScrollUpdate,
1919                       INPUT_EVENT_ACK_STATE_CONSUMED);
1920
1921   // An async touch should fire after the throttling interval has expired, but
1922   // it should not start the touch ack timeout.
1923   MoveTouchPoint(0, 5, 5);
1924   EXPECT_TRUE(HasPendingAsyncTouchMove());
1925   EXPECT_EQ(1U, GetAndResetAckedEventCount());
1926
1927   AdvanceTouchTime(kMinSecondsBetweenThrottledTouchmoves + 0.1);
1928   MoveTouchPoint(0, 5, 5);
1929   EXPECT_FALSE(IsTimeoutRunning());
1930   EXPECT_FALSE(HasPendingAsyncTouchMove());
1931   EXPECT_FALSE(sent_event().cancelable);
1932   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1933   EXPECT_EQ(1U, GetAndResetAckedEventCount());
1934   EXPECT_EQ(1U, GetAndResetSentEventCount());
1935
1936   // An unconsumed scroll event will resume synchronous touchmoves, which are
1937   // subject to the ack timeout.
1938   SendGestureEventAck(WebInputEvent::GestureScrollUpdate,
1939                       INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1940   MoveTouchPoint(0, 20, 5);
1941   EXPECT_TRUE(IsTimeoutRunning());
1942   EXPECT_TRUE(sent_event().cancelable);
1943   EXPECT_EQ(1U, GetAndResetSentEventCount());
1944
1945   // The timeout should fire, disabling touch forwarding until both acks are
1946   // received and acking the timed out event.
1947   RunTasksAndWait(DefaultTouchTimeoutDelay() * 2);
1948   EXPECT_FALSE(IsTimeoutRunning());
1949   EXPECT_EQ(1U, GetAndResetAckedEventCount());
1950   EXPECT_EQ(0U, GetAndResetSentEventCount());
1951
1952   // Ack'ing the original event should trigger a cancel event.
1953   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1954   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1955   EXPECT_FALSE(sent_event().cancelable);
1956   EXPECT_EQ(0U, GetAndResetAckedEventCount());
1957   EXPECT_EQ(1U, GetAndResetSentEventCount());
1958
1959   // Subsequent touchmove's should not be forwarded, even as the scroll gesture
1960   // goes from unconsumed to consumed.
1961   SendGestureEventAck(WebInputEvent::GestureScrollUpdate,
1962                       INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1963   MoveTouchPoint(0, 20, 5);
1964   EXPECT_FALSE(HasPendingAsyncTouchMove());
1965   EXPECT_EQ(1U, GetAndResetAckedEventCount());
1966   EXPECT_EQ(0U, GetAndResetSentEventCount());
1967
1968   SendGestureEventAck(WebInputEvent::GestureScrollUpdate,
1969                       INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1970   MoveTouchPoint(0, 25, 5);
1971   EXPECT_FALSE(HasPendingAsyncTouchMove());
1972   EXPECT_EQ(1U, GetAndResetAckedEventCount());
1973   EXPECT_EQ(0U, GetAndResetSentEventCount());
1974 }
1975
1976 // Ensure that if the touch ack for an async touchmove triggers a follow-up
1977 // touch event, that follow-up touch will be forwarded appropriately.
1978 TEST_F(TouchEventQueueTest, AsyncTouchWithTouchCancelAfterAck) {
1979   SetTouchScrollingMode(TouchEventQueue::TOUCH_SCROLLING_MODE_ASYNC_TOUCHMOVE);
1980
1981   PressTouchPoint(0, 0);
1982   EXPECT_EQ(1U, GetAndResetSentEventCount());
1983   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1984   EXPECT_EQ(1U, GetAndResetAckedEventCount());
1985
1986   // The start of a scroll gesture should trigger async touch event dispatch.
1987   MoveTouchPoint(0, 1, 1);
1988   EXPECT_EQ(1U, GetAndResetSentEventCount());
1989   WebGestureEvent followup_scroll;
1990   followup_scroll.type = WebInputEvent::GestureScrollBegin;
1991   SetFollowupEvent(followup_scroll);
1992   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
1993   EXPECT_EQ(1U, GetAndResetAckedEventCount());
1994   EXPECT_EQ(0U, queued_event_count());
1995
1996   // The async touchmove should be ack'ed immediately, but not forwarded.
1997   // However, because the ack triggers a touchcancel, both the pending touch and
1998   // the queued touchcancel should be flushed.
1999   WebTouchEvent followup_cancel;
2000   followup_cancel.type = WebInputEvent::TouchCancel;
2001   followup_cancel.touchesLength = 1;
2002   followup_cancel.touches[0].state = WebTouchPoint::StateCancelled;
2003   SetFollowupEvent(followup_cancel);
2004   MoveTouchPoint(0, 5, 5);
2005   EXPECT_EQ(2U, queued_event_count());
2006   EXPECT_FALSE(sent_event().cancelable);
2007   EXPECT_FALSE(HasPendingAsyncTouchMove());
2008   EXPECT_EQ(WebInputEvent::TouchMove, acked_event().type);
2009   EXPECT_EQ(WebInputEvent::TouchMove, sent_event().type);
2010   EXPECT_EQ(1U, GetAndResetAckedEventCount());
2011   EXPECT_EQ(1U, GetAndResetSentEventCount());
2012
2013   // The ack for the asnc touchmove should not reach the client, as it has
2014   // already been ack'ed.
2015   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
2016   EXPECT_FALSE(sent_event().cancelable);
2017   EXPECT_EQ(1U, queued_event_count());
2018   EXPECT_EQ(WebInputEvent::TouchCancel, sent_event().type);
2019   EXPECT_EQ(0U, GetAndResetAckedEventCount());
2020   EXPECT_EQ(1U, GetAndResetSentEventCount());
2021
2022   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
2023   EXPECT_EQ(0U, queued_event_count());
2024   EXPECT_EQ(WebInputEvent::TouchCancel, acked_event().type);
2025   EXPECT_EQ(1U, GetAndResetAckedEventCount());
2026   EXPECT_EQ(0U, GetAndResetSentEventCount());
2027 }
2028
2029 }  // namespace content