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