Add a passthrough touch event queue.

content/browser/renderer_host/input/passthrough_touch_event_queue_unittest.cc

-// Copyright 2013 The Chromium Authors. All rights reserved.
+// Copyright 2017 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "content/browser/renderer_host/input/touch_event_queue.h"
+#include "content/browser/renderer_host/input/passthrough_touch_event_queue.h"
 
 #include <stddef.h>
 
 #include <memory>
 #include <utility>
 
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
-#include "content/browser/renderer_host/input/legacy_touch_event_queue.h"
 #include "content/browser/renderer_host/input/timeout_monitor.h"
 #include "content/common/input/synthetic_web_input_event_builders.h"
 #include "content/common/input/web_touch_event_traits.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/WebKit/public/platform/WebInputEvent.h"
 #include "ui/events/base_event_utils.h"
 
 using blink::WebGestureEvent;
 using blink::WebInputEvent;
 using blink::WebTouchEvent;
 using blink::WebTouchPoint;
 
 namespace content {
 namespace {
 
 const double kMinSecondsBetweenThrottledTouchmoves = 0.2;
 const float kSlopLengthDips = 10;
 const float kHalfSlopLengthDips = kSlopLengthDips / 2;
 
 base::TimeDelta DefaultTouchTimeoutDelay() {
   return base::TimeDelta::FromMilliseconds(1);
 }
 }  // namespace
 
-class TouchEventQueueTest : public testing::Test,
-                            public TouchEventQueueClient {
+class PassthroughTouchEventQueueTest : public testing::Test,
+                                       public TouchEventQueueClient {
  public:
-  TouchEventQueueTest()
+  PassthroughTouchEventQueueTest()
       : acked_event_count_(0),
         last_acked_event_state_(INPUT_EVENT_ACK_STATE_UNKNOWN),
         slop_length_dips_(0) {}
 
-  ~TouchEventQueueTest() override {}
+  ~PassthroughTouchEventQueueTest() override {}
 
   // testing::Test
   void SetUp() override {
     ResetQueueWithConfig(TouchEventQueue::Config());
     sent_events_ids_.clear();
   }
 
   void TearDown() override { queue_.reset(); }
 
   // TouchEventQueueClient
@@ skipping 13 matching lines @@
     last_acked_event_ = event.event;
     last_acked_event_state_ = ack_result;
     if (followup_touch_event_) {
       std::unique_ptr<WebTouchEvent> followup_touch_event =
           std::move(followup_touch_event_);
       SendTouchEvent(*followup_touch_event);
     }
     if (followup_gesture_event_) {
       std::unique_ptr<WebGestureEvent> followup_gesture_event =
           std::move(followup_gesture_event_);
-      queue_->OnGestureScrollEvent(
-          GestureEventWithLatencyInfo(*followup_gesture_event,
-                                      ui::LatencyInfo()));
+      queue_->OnGestureScrollEvent(GestureEventWithLatencyInfo(
+          *followup_gesture_event, ui::LatencyInfo()));
     }
   }
 
   void OnFilteringTouchEvent(const blink::WebTouchEvent& touch_event) override {
   }
 
  protected:
   void SetUpForTouchMoveSlopTesting(double slop_length_dips) {
     slop_length_dips_ = slop_length_dips;
   }
@@ skipping 35 matching lines @@
         GestureEventWithLatencyInfo(event, ui::LatencyInfo()));
   }
 
   void SendTouchEventAck(InputEventAckState ack_result) {
     DCHECK(!sent_events_ids_.empty());
     queue_->ProcessTouchAck(ack_result, ui::LatencyInfo(),
                             sent_events_ids_.front());
     sent_events_ids_.pop_front();
   }
 
+  void SendTouchEventAckLast(InputEventAckState ack_result) {
+    DCHECK(!sent_events_ids_.empty());
+    queue_->ProcessTouchAck(ack_result, ui::LatencyInfo(),
+                            sent_events_ids_.back());
+    sent_events_ids_.pop_back();
+  }
+
   void SendTouchEventAckWithID(InputEventAckState ack_result,
                                int unique_event_id) {
     queue_->ProcessTouchAck(ack_result, ui::LatencyInfo(), unique_event_id);
     sent_events_ids_.erase(std::remove(sent_events_ids_.begin(),
                                        sent_events_ids_.end(), unique_event_id),
                            sent_events_ids_.end());
   }
 
   void SendGestureEventAck(WebInputEvent::Type type,
                            InputEventAckState ack_result) {
@@ skipping 87 matching lines @@
   }
 
   void PrependTouchScrollNotification() {
     queue_->PrependTouchScrollNotification();
   }
 
   void AdvanceTouchTime(double seconds) {
     touch_event_.setTimeStampSeconds(touch_event_.timeStampSeconds() + seconds);
   }
 
-  void ResetTouchEvent() {
-    touch_event_ = SyntheticWebTouchEvent();
-  }
+  void ResetTouchEvent() { touch_event_ = SyntheticWebTouchEvent(); }
 
   size_t GetAndResetAckedEventCount() {
     size_t count = acked_event_count_;
     acked_event_count_ = 0;
     return count;
   }
 
   size_t GetAndResetSentEventCount() {
     size_t count = sent_events_.size();
     sent_events_.clear();
     return count;
   }
 
   bool IsPendingAckTouchStart() const {
     return queue_->IsPendingAckTouchStart();
   }
 
   void OnHasTouchEventHandlers(bool has_handlers) {
     queue_->OnHasTouchEventHandlers(has_handlers);
   }
 
   void SetAckTimeoutDisabled() { queue_->SetAckTimeoutEnabled(false); }
 
   void SetIsMobileOptimizedSite(bool is_mobile_optimized) {
     queue_->SetIsMobileOptimizedSite(is_mobile_optimized);
   }
 
   bool IsTimeoutRunning() const { return queue_->IsTimeoutRunningForTesting(); }
 
-  bool HasPendingAsyncTouchMove() const {
-    return queue_->HasPendingAsyncTouchMoveForTesting();
-  }
-
-  size_t queued_event_count() const {
-    return queue_->size();
-  }
+  size_t queued_event_count() const { return queue_->SizeForTesting(); }
 
   const WebTouchEvent& latest_event() const {
     return queue_->GetLatestEventForTesting().event;
   }
 
-  const WebTouchEvent& acked_event() const {
-    return last_acked_event_;
-  }
+  const WebTouchEvent& acked_event() const { return last_acked_event_; }
 
   const WebTouchEvent& sent_event() const {
     DCHECK(!sent_events_.empty());
     return sent_events_.back();
   }
 
   const std::vector<WebTouchEvent>& all_sent_events() const {
     return sent_events_;
   }
 
   InputEventAckState acked_event_state() const {
     return last_acked_event_state_;
   }
 
   static void RunTasksAndWait(base::TimeDelta delay) {
     base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
         FROM_HERE, base::MessageLoop::QuitWhenIdleClosure(), delay);
     base::RunLoop().Run();
   }
 
-  size_t uncancelable_touch_moves_pending_ack_count() const {
-    return queue_->uncancelable_touch_moves_pending_ack_count();
-  }
-
   int GetUniqueTouchEventID() { return sent_events_ids_.back(); }
 
  private:
   void SendTouchEvent() {
     SendTouchEvent(touch_event_);
     touch_event_.ResetPoints();
   }
 
   void ResetQueueWithConfig(const TouchEventQueue::Config& config) {
-    queue_.reset(new LegacyTouchEventQueue(this, config));
+    queue_.reset(new PassthroughTouchEventQueue(this, config));
     queue_->OnHasTouchEventHandlers(true);
   }
 
-  std::unique_ptr<LegacyTouchEventQueue> queue_;
+  std::unique_ptr<PassthroughTouchEventQueue> queue_;
   size_t acked_event_count_;
   WebTouchEvent last_acked_event_;
   std::vector<WebTouchEvent> sent_events_;
   InputEventAckState last_acked_event_state_;
   SyntheticWebTouchEvent touch_event_;
   std::unique_ptr<WebTouchEvent> followup_touch_event_;
   std::unique_ptr<WebGestureEvent> followup_gesture_event_;
   std::unique_ptr<InputEventAckState> sync_ack_result_;
   double slop_length_dips_;
   gfx::PointF anchor_;
   base::MessageLoopForUI message_loop_;
   std::deque<int> sent_events_ids_;
 };
 
-
 // Tests that touch-events are queued properly.
-TEST_F(TouchEventQueueTest, Basic) {
+TEST_F(PassthroughTouchEventQueueTest, Basic) {
   PressTouchPoint(1, 1);
   EXPECT_EQ(1U, queued_event_count());
   EXPECT_EQ(1U, GetAndResetSentEventCount());
 
-  // The second touch should not be sent since one is already in queue.
+  // The second touch should be sent right away even though
+  // we haven't received an ack for the touch start.
   MoveTouchPoint(0, 5, 5);
   EXPECT_EQ(2U, queued_event_count());
-  EXPECT_EQ(0U, GetAndResetSentEventCount());
+  EXPECT_EQ(1U, GetAndResetSentEventCount());
 
   // Receive an ACK for the first touch-event.
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
   EXPECT_EQ(1U, queued_event_count());
-  EXPECT_EQ(1U, GetAndResetSentEventCount());
+  EXPECT_EQ(0U, GetAndResetSentEventCount());
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
   EXPECT_EQ(WebInputEvent::TouchStart, acked_event().type());
   EXPECT_EQ(WebInputEvent::Blocking, acked_event().dispatchType);
 
   // Receive an ACK for the second touch-event.
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
   EXPECT_EQ(0U, queued_event_count());
   EXPECT_EQ(0U, GetAndResetSentEventCount());
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
   EXPECT_EQ(WebInputEvent::TouchMove, acked_event().type());
   EXPECT_EQ(WebInputEvent::Blocking, acked_event().dispatchType);
 }
 
 // Tests that touch-events with multiple points are queued properly.
-TEST_F(TouchEventQueueTest, BasicMultiTouch) {
+TEST_F(PassthroughTouchEventQueueTest, BasicMultiTouch) {
   const size_t kPointerCount = 10;
   for (float i = 0; i < kPointerCount; ++i)
     PressTouchPoint(i, i);
 
-  EXPECT_EQ(1U, GetAndResetSentEventCount());
+  EXPECT_EQ(kPointerCount, GetAndResetSentEventCount());
   EXPECT_EQ(0U, GetAndResetAckedEventCount());
   EXPECT_EQ(kPointerCount, queued_event_count());
 
   for (int i = 0; i < static_cast<int>(kPointerCount); ++i)
     MoveTouchPoint(i, 1.f + i, 2.f + i);
 
-  EXPECT_EQ(0U, GetAndResetSentEventCount());
+  EXPECT_EQ(kPointerCount, GetAndResetSentEventCount());
   EXPECT_EQ(0U, GetAndResetAckedEventCount());
-  // All moves should coalesce.
-  EXPECT_EQ(kPointerCount + 1, queued_event_count());
+  // No coalescing happens in the queue since they are all sent immediately.
+  EXPECT_EQ(2 * kPointerCount, queued_event_count());
 
   for (int i = 0; i < static_cast<int>(kPointerCount); ++i)
     ReleaseTouchPoint(kPointerCount - 1 - i);
 
-  EXPECT_EQ(0U, GetAndResetSentEventCount());
+  EXPECT_EQ(kPointerCount, GetAndResetSentEventCount());
   EXPECT_EQ(0U, GetAndResetAckedEventCount());
-  EXPECT_EQ(kPointerCount * 2 + 1, queued_event_count());
+  EXPECT_EQ(kPointerCount * 3, queued_event_count());
 
   // Ack all presses.
   for (size_t i = 0; i < kPointerCount; ++i)
     SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
 
   EXPECT_EQ(kPointerCount, GetAndResetAckedEventCount());
-  EXPECT_EQ(kPointerCount, GetAndResetSentEventCount());
+  EXPECT_EQ(0U, GetAndResetSentEventCount());
 
-  // Ack the coalesced move.
-  SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
+  // Ack the touch moves.
+  for (size_t i = 0; i < kPointerCount; ++i)
+    SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
   EXPECT_EQ(kPointerCount, GetAndResetAckedEventCount());
-  EXPECT_EQ(1U, GetAndResetSentEventCount());
+  EXPECT_EQ(0U, GetAndResetSentEventCount());
 
   // Ack all releases.
   for (size_t i = 0; i < kPointerCount; ++i)
     SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
 
   EXPECT_EQ(kPointerCount, GetAndResetAckedEventCount());
-  EXPECT_EQ(kPointerCount - 1, GetAndResetSentEventCount());
+  EXPECT_EQ(0U, GetAndResetSentEventCount());
 }
 
 // Tests that the touch-queue continues delivering events for an active touch
 // sequence after all handlers are removed.
-TEST_F(TouchEventQueueTest, TouchesForwardedIfHandlerRemovedDuringSequence) {
+TEST_F(PassthroughTouchEventQueueTest,
+       TouchesForwardedIfHandlerRemovedDuringSequence) {
   OnHasTouchEventHandlers(true);
   EXPECT_EQ(0U, queued_event_count());
   EXPECT_EQ(0U, GetAndResetSentEventCount());
 
   // Send a touch-press event.
   PressTouchPoint(1, 1);
   EXPECT_EQ(1U, GetAndResetSentEventCount());
   EXPECT_EQ(1U, queued_event_count());
 
   // Signal that all touch handlers have been removed.
@@ skipping 12 matching lines @@
   PressTouchPoint(2, 2);
   EXPECT_EQ(1U, GetAndResetSentEventCount());
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS);
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
   EXPECT_EQ(0U, queued_event_count());
 
   // Further events for any pointer should be forwarded, even for pointers that
   // reported no consumer.
   MoveTouchPoint(1, 3, 3);
   ReleaseTouchPoint(1);
-  EXPECT_EQ(1U, GetAndResetSentEventCount());
+  EXPECT_EQ(2U, GetAndResetSentEventCount());
   EXPECT_EQ(0U, GetAndResetAckedEventCount());
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS);
-  EXPECT_EQ(1U, GetAndResetSentEventCount());
+  EXPECT_EQ(0U, GetAndResetSentEventCount());
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS);
   EXPECT_EQ(0U, GetAndResetSentEventCount());
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 
   // Events for the first pointer, that had a handler, should be forwarded.
   MoveTouchPoint(0, 4, 4);
   ReleaseTouchPoint(0);
-  EXPECT_EQ(1U, GetAndResetSentEventCount());
+  EXPECT_EQ(2U, GetAndResetSentEventCount());
   EXPECT_EQ(2U, queued_event_count());
 
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
-  EXPECT_EQ(1U, GetAndResetSentEventCount());
+  EXPECT_EQ(0U, GetAndResetSentEventCount());
   EXPECT_EQ(1U, queued_event_count());
   EXPECT_EQ(INPUT_EVENT_ACK_STATE_CONSUMED, acked_event_state());
 
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
   EXPECT_EQ(0U, GetAndResetSentEventCount());
   EXPECT_EQ(0U, queued_event_count());
   EXPECT_EQ(INPUT_EVENT_ACK_STATE_CONSUMED, acked_event_state());
 }
 
 // Tests that addition of a touch handler during a touch sequence will not cause
 // the remaining sequence to be forwarded.
-TEST_F(TouchEventQueueTest, ActiveSequenceNotForwardedWhenHandlersAdded) {
+TEST_F(PassthroughTouchEventQueueTest,
+       ActiveSequenceNotForwardedWhenHandlersAdded) {
   OnHasTouchEventHandlers(false);
 
   // Send a touch-press event while there is no handler.
   PressTouchPoint(1, 1);
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
   EXPECT_EQ(0U, GetAndResetSentEventCount());
   EXPECT_EQ(0U, queued_event_count());
 
   OnHasTouchEventHandlers(true);
 
   // The remaining touch sequence should not be forwarded.
   MoveTouchPoint(0, 5, 5);
   ReleaseTouchPoint(0);
   EXPECT_EQ(2U, GetAndResetAckedEventCount());
   EXPECT_EQ(0U, GetAndResetSentEventCount());
   EXPECT_EQ(0U, queued_event_count());
 
   // A new touch sequence should resume forwarding.
   PressTouchPoint(1, 1);
   EXPECT_EQ(1U, queued_event_count());
   EXPECT_EQ(1U, GetAndResetSentEventCount());
 }
 
 // Tests that removal of a touch handler during a touch sequence will prevent
 // the remaining sequence from being forwarded, even if another touch handler is
 // registered during the same touch sequence.
-TEST_F(TouchEventQueueTest, ActiveSequenceDroppedWhenHandlersRemoved) {
+TEST_F(PassthroughTouchEventQueueTest,
+       ActiveSequenceDroppedWhenHandlersRemoved) {
   // Send a touch-press event.
   PressTouchPoint(1, 1);
   EXPECT_EQ(1U, GetAndResetSentEventCount());
   EXPECT_EQ(1U, queued_event_count());
 
   // Queue a touch-move event.
   MoveTouchPoint(0, 5, 5);
   EXPECT_EQ(2U, queued_event_count());
   EXPECT_EQ(0U, GetAndResetAckedEventCount());
-  EXPECT_EQ(0U, GetAndResetSentEventCount());
+  EXPECT_EQ(1U, GetAndResetSentEventCount());
 
   // Unregister all touch handlers.
   OnHasTouchEventHandlers(false);
   EXPECT_EQ(0U, GetAndResetAckedEventCount());
   EXPECT_EQ(2U, queued_event_count());
 
   // Repeated registration/unregstration of handlers should have no effect as
   // we're still awaiting the ack arrival.
   OnHasTouchEventHandlers(true);
   EXPECT_EQ(0U, GetAndResetAckedEventCount());
   EXPECT_EQ(2U, queued_event_count());
   OnHasTouchEventHandlers(false);
   EXPECT_EQ(0U, GetAndResetAckedEventCount());
   EXPECT_EQ(2U, queued_event_count());
 
-  // The ack should be flush the queue.
+  // clear the queue .
+  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS);
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS);
   EXPECT_EQ(2U, GetAndResetAckedEventCount());
   EXPECT_EQ(0U, queued_event_count());
 
   // Events should be dropped while there is no touch handler.
   MoveTouchPoint(0, 10, 10);
   EXPECT_EQ(0U, queued_event_count());
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
   EXPECT_EQ(0U, GetAndResetSentEventCount());
 
   // Simulate touch handler registration in the middle of a touch sequence.
   OnHasTouchEventHandlers(true);
 
   // The touch end for the interrupted sequence should be dropped.
   ReleaseTouchPoint(0);
   EXPECT_EQ(0U, queued_event_count());
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
   EXPECT_EQ(0U, GetAndResetSentEventCount());
 
   // A new touch sequence should be forwarded properly.
   PressTouchPoint(1, 1);
   EXPECT_EQ(1U, queued_event_count());
   EXPECT_EQ(1U, GetAndResetSentEventCount());
 }
 
 // Tests that removal/addition of a touch handler without any intervening
 // touch activity has no affect on touch forwarding.
-TEST_F(TouchEventQueueTest,
+TEST_F(PassthroughTouchEventQueueTest,
        ActiveSequenceUnaffectedByRepeatedHandlerRemovalAndAddition) {
   // Send a touch-press event.
   PressTouchPoint(1, 1);
   EXPECT_EQ(1U, GetAndResetSentEventCount());
   EXPECT_EQ(1U, queued_event_count());
 
   // Simulate the case where the touchstart handler removes itself, and adds a
   // touchmove handler.
   OnHasTouchEventHandlers(false);
   OnHasTouchEventHandlers(true);
 
-  // Queue a touch-move event.
+  // Queue a touch-move event, should be sent right away.
   MoveTouchPoint(0, 5, 5);
   EXPECT_EQ(2U, queued_event_count());
   EXPECT_EQ(0U, GetAndResetAckedEventCount());
-  EXPECT_EQ(0U, GetAndResetSentEventCount());
+  EXPECT_EQ(1U, GetAndResetSentEventCount());
 
   // The ack should trigger forwarding of the touchmove, as if no touch
   // handler registration changes have occurred.
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
-  EXPECT_EQ(1U, GetAndResetSentEventCount());
+  EXPECT_EQ(0U, GetAndResetSentEventCount());
   EXPECT_EQ(1U, queued_event_count());
 }
 
-// Tests that touch-events are coalesced properly in the queue.
-TEST_F(TouchEventQueueTest, Coalesce) {
-  // Send a touch-press event.
-  PressTouchPoint(1, 1);
-  EXPECT_EQ(1U, GetAndResetSentEventCount());
-
-  // Send a few touch-move events, followed by a touch-release event. All the
-  // touch-move events should be coalesced into a single event.
-  for (float i = 5; i < 15; ++i)
-    MoveTouchPoint(0, i, i);
-
-  EXPECT_EQ(0U, GetAndResetSentEventCount());
-  ReleaseTouchPoint(0);
-  EXPECT_EQ(0U, GetAndResetSentEventCount());
-  EXPECT_EQ(3U, queued_event_count());
-
-  // ACK the press.  Coalesced touch-move events should be sent.
-  SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
-  EXPECT_EQ(2U, queued_event_count());
-  EXPECT_EQ(1U, GetAndResetSentEventCount());
-  EXPECT_EQ(1U, GetAndResetAckedEventCount());
-  EXPECT_EQ(WebInputEvent::TouchStart, acked_event().type());
-  EXPECT_EQ(INPUT_EVENT_ACK_STATE_CONSUMED, acked_event_state());
-
-  // ACK the moves.
-  SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
-  EXPECT_EQ(1U, queued_event_count());
-  EXPECT_EQ(1U, GetAndResetSentEventCount());
-  EXPECT_EQ(10U, GetAndResetAckedEventCount());
-  EXPECT_EQ(WebInputEvent::TouchMove, acked_event().type());
-
-  // ACK the release.
-  SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
-  EXPECT_EQ(0U, queued_event_count());
-  EXPECT_EQ(0U, GetAndResetSentEventCount());
-  EXPECT_EQ(1U, GetAndResetAckedEventCount());
-  EXPECT_EQ(WebInputEvent::TouchEnd, acked_event().type());
-}
-
-// Tests that an event that has already been sent but hasn't been ack'ed yet
-// doesn't get coalesced with newer events.
-TEST_F(TouchEventQueueTest, SentTouchEventDoesNotCoalesce) {
-  // Send a touch-press event.
-  PressTouchPoint(1, 1);
-  EXPECT_EQ(1U, GetAndResetSentEventCount());
-
-  // Send a few touch-move events, followed by a touch-release event. All the
-  // touch-move events should be coalesced into a single event.
-  for (float i = 5; i < 15; ++i)
-    MoveTouchPoint(0, i, i);
-
-  EXPECT_EQ(0U, GetAndResetSentEventCount());
-  EXPECT_EQ(2U, queued_event_count());
-
-  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-  EXPECT_EQ(1U, GetAndResetSentEventCount());
-  EXPECT_EQ(1U, queued_event_count());
-
-  // The coalesced touch-move event has been sent to the renderer. Any new
-  // touch-move event should not be coalesced with the sent event.
-  MoveTouchPoint(0, 5, 5);
-  EXPECT_EQ(2U, queued_event_count());
-
-  MoveTouchPoint(0, 7, 7);
-  EXPECT_EQ(2U, queued_event_count());
-}
-
-// Tests that coalescing works correctly for multi-touch events.
-TEST_F(TouchEventQueueTest, MultiTouch) {
-  // Press the first finger.
-  PressTouchPoint(1, 1);
-  EXPECT_EQ(1U, GetAndResetSentEventCount());
-
-  // Move the finger.
-  MoveTouchPoint(0, 5, 5);
-  EXPECT_EQ(2U, queued_event_count());
-
-  // Now press a second finger.
-  PressTouchPoint(2, 2);
-  EXPECT_EQ(3U, queued_event_count());
-
-  // Move both fingers.
-  MoveTouchPoints(0, 10, 10, 1, 20, 20);
-  MoveTouchPoint(1, 20, 20);
-  EXPECT_EQ(4U, queued_event_count());
-
-  // Move only one finger now.
-  MoveTouchPoint(0, 15, 15);
-  EXPECT_EQ(4U, queued_event_count());
-
-  // Move the other finger.
-  MoveTouchPoint(1, 25, 25);
-  EXPECT_EQ(4U, queued_event_count());
-
-  // Make sure both fingers are marked as having been moved in the coalesced
-  // event.
-  const WebTouchEvent& event = latest_event();
-  EXPECT_EQ(WebTouchPoint::StateMoved, event.touches[0].state);
-  EXPECT_EQ(WebTouchPoint::StateMoved, event.touches[1].state);
-}
-
 // Tests that the touch-event queue is robust to redundant acks.
-TEST_F(TouchEventQueueTest, SpuriousAcksIgnored) {
+TEST_F(PassthroughTouchEventQueueTest, SpuriousAcksIgnored) {
   // Trigger a spurious ack.
   SendTouchEventAckWithID(INPUT_EVENT_ACK_STATE_CONSUMED, 0);
   EXPECT_EQ(0U, GetAndResetAckedEventCount());
 
   // Send and ack a touch press.
   PressTouchPoint(1, 1);
   EXPECT_EQ(1U, GetAndResetSentEventCount());
   EXPECT_EQ(1U, queued_event_count());
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
   EXPECT_EQ(0U, queued_event_count());
 
   // Trigger a spurious ack.
   SendTouchEventAckWithID(INPUT_EVENT_ACK_STATE_CONSUMED, 3);
   EXPECT_EQ(0U, GetAndResetAckedEventCount());
 }
 
 // Tests that touch-move events are not sent to the renderer if the preceding
 // touch-press event did not have a consumer (and consequently, did not hit the
-// main thread in the renderer). Also tests that all queued/coalesced touch
-// events are flushed immediately when the ACK for the touch-press comes back
-// with NO_CONSUMER status.
-TEST_F(TouchEventQueueTest, NoConsumer) {
+// main thread in the renderer).
+TEST_F(PassthroughTouchEventQueueTest, NoConsumer) {
   // The first touch-press should reach the renderer.
   PressTouchPoint(1, 1);
   EXPECT_EQ(1U, GetAndResetSentEventCount());
 
-  // The second touch should not be sent since one is already in queue.
+  // The second touch should be sent since we don't know if there is
+  // a consumer or not.
   MoveTouchPoint(0, 5, 5);
-  EXPECT_EQ(0U, GetAndResetSentEventCount());
+  EXPECT_EQ(1U, GetAndResetSentEventCount());
   EXPECT_EQ(2U, queued_event_count());
 
-  // Receive an ACK for the first touch-event. This should release the queued
-  // touch-event, but it should not be sent to the renderer.
+  // Receive an ACK for the first touch-event and the first touch-move
+  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS);
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS);
   EXPECT_EQ(0U, queued_event_count());
-  EXPECT_EQ(WebInputEvent::TouchMove, acked_event().type());
   EXPECT_EQ(2U, GetAndResetAckedEventCount());
   EXPECT_EQ(0U, GetAndResetSentEventCount());
 
   // Send a release event. This should not reach the renderer.
   ReleaseTouchPoint(0);
   EXPECT_EQ(0U, GetAndResetSentEventCount());
   EXPECT_EQ(WebInputEvent::TouchEnd, acked_event().type());
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 
-  // Send a press-event, followed by move and release events, and another press
-  // event, before the ACK for the first press event comes back. All of the
-  // events should be queued first. After the NO_CONSUMER ack for the first
-  // touch-press, all events upto the second touch-press should be flushed.
+  // Send a press-event, followed by move a following move should not
+  // be sent but held in the queue.
   PressTouchPoint(10, 10);
-  EXPECT_EQ(1U, GetAndResetSentEventCount());
+  MoveTouchPoint(0, 5, 5);
 
+  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS);
+  EXPECT_EQ(2U, GetAndResetSentEventCount());
+  EXPECT_EQ(1U, GetAndResetAckedEventCount());
+
+  MoveTouchPoint(0, 6, 5);
+  EXPECT_EQ(0U, GetAndResetSentEventCount());
+  EXPECT_EQ(0U, GetAndResetAckedEventCount());
+  EXPECT_EQ(2U, queued_event_count());
+  SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
+  EXPECT_EQ(2U, GetAndResetAckedEventCount());
+}
+
+TEST_F(PassthroughTouchEventQueueTest, AckTouchEventInReverse) {
+  PressTouchPoint(1, 1);
   MoveTouchPoint(0, 5, 5);
-  MoveTouchPoint(0, 6, 5);
+  MoveTouchPoint(0, 15, 15);
   ReleaseTouchPoint(0);
 
-  PressTouchPoint(6, 5);
-  EXPECT_EQ(0U, GetAndResetSentEventCount());
-  // The queue should hold the first sent touch-press event, the coalesced
-  // touch-move event, the touch-end event and the second touch-press event.
+  EXPECT_EQ(4U, GetAndResetSentEventCount());
   EXPECT_EQ(4U, queued_event_count());
 
-  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS);
-  EXPECT_EQ(1U, GetAndResetSentEventCount());
-  EXPECT_EQ(WebInputEvent::TouchEnd, acked_event().type());
-  EXPECT_EQ(4U, GetAndResetAckedEventCount());
-  EXPECT_EQ(1U, queued_event_count());
+  SendTouchEventAckLast(INPUT_EVENT_ACK_STATE_CONSUMED);
+  EXPECT_EQ(0U, GetAndResetAckedEventCount());
+  EXPECT_EQ(4U, queued_event_count());
 
-  // ACK the second press event as NO_CONSUMER too.
-  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS);
-  EXPECT_EQ(0U, GetAndResetSentEventCount());
-  EXPECT_EQ(WebInputEvent::TouchStart, acked_event().type());
-  EXPECT_EQ(1U, GetAndResetAckedEventCount());
-  EXPECT_EQ(0U, queued_event_count());
-
-  // Send a second press event. Even though the first touch press had
-  // NO_CONSUMER, this press event should reach the renderer.
-  PressTouchPoint(1, 1);
-  EXPECT_EQ(1U, GetAndResetSentEventCount());
-  EXPECT_EQ(1U, queued_event_count());
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
   EXPECT_EQ(WebInputEvent::TouchStart, acked_event().type());
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
-}
+  EXPECT_EQ(3U, queued_event_count());
 
-TEST_F(TouchEventQueueTest, ConsumerIgnoreMultiFinger) {
-  // Interleave three pointer press, move and release events.
-  PressTouchPoint(1, 1);
-  MoveTouchPoint(0, 5, 5);
-  PressTouchPoint(10, 10);
-  MoveTouchPoint(1, 15, 15);
-  PressTouchPoint(20, 20);
-  MoveTouchPoint(2, 25, 25);
-  ReleaseTouchPoint(2);
-  MoveTouchPoint(1, 20, 20);
-  ReleaseTouchPoint(1);
-  MoveTouchPoint(0, 10, 10);
-  ReleaseTouchPoint(0);
+  SendTouchEventAckLast(INPUT_EVENT_ACK_STATE_CONSUMED);
+  EXPECT_EQ(0U, GetAndResetAckedEventCount());
+  EXPECT_EQ(3U, queued_event_count());
 
-  // Since the first touch-press is still pending ACK, no other event should
-  // have been sent to the renderer.
-  EXPECT_EQ(1U, GetAndResetSentEventCount());
-  EXPECT_EQ(0U, GetAndResetSentEventCount());
-  EXPECT_EQ(11U, queued_event_count());
-
-  // ACK the first press as CONSUMED. This should cause the first touch-move of
-  // the first touch-point to be dispatched.
-  SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
-  EXPECT_EQ(1U, GetAndResetSentEventCount());
-  EXPECT_EQ(10U, queued_event_count());
-
-  // ACK the first move as CONSUMED.
-  SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
-  EXPECT_EQ(1U, GetAndResetSentEventCount());
-  EXPECT_EQ(9U, queued_event_count());
-
-  // ACK the second press as NO_CONSUMER_EXISTS. The second pointer's touchmove
-  // should still be forwarded, despite lacking a direct consumer.
-  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS);
-  EXPECT_EQ(1U, GetAndResetSentEventCount());
-  EXPECT_EQ(8U, queued_event_count());
-
-  // ACK the coalesced move as NOT_CONSUMED.
-  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-  EXPECT_EQ(1U, GetAndResetSentEventCount());
-  EXPECT_EQ(7U, queued_event_count());
-
-  // All remaining touch events should be forwarded, even if the third pointer
-  // press also reports no consumer.
-  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS);
-  EXPECT_EQ(6U, queued_event_count());
-
-  while (queued_event_count())
-    SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-
-  EXPECT_EQ(6U, GetAndResetSentEventCount());
+  SendTouchEventAckLast(INPUT_EVENT_ACK_STATE_CONSUMED);
+  EXPECT_EQ(WebInputEvent::TouchEnd, acked_event().type());
+  EXPECT_EQ(3U, GetAndResetAckedEventCount());
+  EXPECT_EQ(0U, queued_event_count());
 }
 
 // Tests that touch-event's enqueued via a touch ack are properly handled.
-TEST_F(TouchEventQueueTest, AckWithFollowupEvents) {
+TEST_F(PassthroughTouchEventQueueTest, AckWithFollowupEvents) {
   // Queue a touch down.
   PressTouchPoint(1, 1);
   EXPECT_EQ(1U, queued_event_count());
   EXPECT_EQ(1U, GetAndResetSentEventCount());
   EXPECT_EQ(0U, GetAndResetAckedEventCount());
 
   // Create a touch event that will be queued synchronously by a touch ack.
   // Note, this will be triggered by all subsequent touch acks.
   WebTouchEvent followup_event(
       WebInputEvent::TouchMove, WebInputEvent::NoModifiers,
@@ skipping 18 matching lines @@
 
   // Receive an ACK for the touch-move followup event. This should cause the
   // subsequent touch move event be sent to the renderer.
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
   EXPECT_EQ(1U, queued_event_count());
   EXPECT_EQ(1U, GetAndResetSentEventCount());
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 }
 
 // Tests that touch-events can be synchronously ack'ed.
-TEST_F(TouchEventQueueTest, SynchronousAcks) {
+TEST_F(PassthroughTouchEventQueueTest, SynchronousAcks) {
   // TouchStart
   SetSyncAckResult(INPUT_EVENT_ACK_STATE_CONSUMED);
   PressTouchPoint(1, 1);
   EXPECT_EQ(0U, queued_event_count());
   EXPECT_EQ(1U, GetAndResetSentEventCount());
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 
   // TouchMove
   SetSyncAckResult(INPUT_EVENT_ACK_STATE_CONSUMED);
   MoveTouchPoint(0, 2, 2);
@@ skipping 17 matching lines @@
 
   SetSyncAckResult(INPUT_EVENT_ACK_STATE_CONSUMED);
   CancelTouchPoint(0);
   EXPECT_EQ(0U, queued_event_count());
   EXPECT_EQ(1U, GetAndResetSentEventCount());
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 }
 
 // Tests that followup events triggered by an immediate ack from
 // TouchEventQueue::QueueEvent() are properly handled.
-TEST_F(TouchEventQueueTest, ImmediateAckWithFollowupEvents) {
+TEST_F(PassthroughTouchEventQueueTest, ImmediateAckWithFollowupEvents) {
   // Create a touch event that will be queued synchronously by a touch ack.
   WebTouchEvent followup_event(
       WebInputEvent::TouchStart, WebInputEvent::NoModifiers,
       ui::EventTimeStampToSeconds(ui::EventTimeForNow()));
   followup_event.touchesLength = 1;
   followup_event.touches[0].id = 1;
   followup_event.touches[0].state = WebTouchPoint::StatePressed;
   SetFollowupEvent(followup_event);
 
   // Now, enqueue a stationary touch that will not be forwarded.  This should be
   // immediately ack'ed with "NO_CONSUMER_EXISTS".  The followup event should
   // then be enqueued and immediately sent to the renderer.
   WebTouchEvent stationary_event(
       WebInputEvent::TouchMove, WebInputEvent::NoModifiers,
       ui::EventTimeStampToSeconds(ui::EventTimeForNow()));
   ;
   stationary_event.touchesLength = 1;
   stationary_event.touches[0].id = 1;
   stationary_event.touches[0].state = WebTouchPoint::StateStationary;
   SendTouchEvent(stationary_event);
 
   EXPECT_EQ(1U, queued_event_count());
   EXPECT_EQ(1U, GetAndResetSentEventCount());
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
   EXPECT_EQ(INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS, acked_event_state());
   EXPECT_EQ(WebInputEvent::TouchMove, acked_event().type());
 }
 
 // Tests basic TouchEvent forwarding suppression.
-TEST_F(TouchEventQueueTest, NoTouchBasic) {
+TEST_F(PassthroughTouchEventQueueTest, NoTouchBasic) {
   // Disable TouchEvent forwarding.
   OnHasTouchEventHandlers(false);
   PressTouchPoint(30, 5);
   EXPECT_EQ(0U, GetAndResetSentEventCount());
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 
   // TouchMove should not be sent to renderer.
   MoveTouchPoint(0, 65, 10);
   EXPECT_EQ(0U, GetAndResetSentEventCount());
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
@@ skipping 16 matching lines @@
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 
   ReleaseTouchPoint(0);
   EXPECT_EQ(1U, GetAndResetSentEventCount());
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 }
 
 // Tests that IsTouchStartPendingAck works correctly.
-TEST_F(TouchEventQueueTest, PendingStart) {
-
+TEST_F(PassthroughTouchEventQueueTest, PendingStart) {
   EXPECT_FALSE(IsPendingAckTouchStart());
 
   // Send the touchstart for one point (#1).
   PressTouchPoint(1, 1);
   EXPECT_EQ(1U, queued_event_count());
   EXPECT_TRUE(IsPendingAckTouchStart());
 
   // Send a touchmove for that point (#2).
   MoveTouchPoint(0, 5, 5);
   EXPECT_EQ(2U, queued_event_count());
   EXPECT_TRUE(IsPendingAckTouchStart());
 
   // Ack the touchstart (#1).
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   EXPECT_EQ(1U, queued_event_count());
   EXPECT_FALSE(IsPendingAckTouchStart());
 
   // Send a touchstart for another point (#3).
   PressTouchPoint(10, 10);
   EXPECT_EQ(2U, queued_event_count());
-  EXPECT_FALSE(IsPendingAckTouchStart());
+  EXPECT_TRUE(IsPendingAckTouchStart());
 
   // Ack the touchmove (#2).
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   EXPECT_EQ(1U, queued_event_count());
   EXPECT_TRUE(IsPendingAckTouchStart());
 
   // Send a touchstart for a third point (#4).
   PressTouchPoint(15, 15);
   EXPECT_EQ(2U, queued_event_count());
   EXPECT_TRUE(IsPendingAckTouchStart());
 
   // Ack the touchstart for the second point (#3).
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   EXPECT_EQ(1U, queued_event_count());
   EXPECT_TRUE(IsPendingAckTouchStart());
 
   // Ack the touchstart for the third point (#4).
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   EXPECT_EQ(0U, queued_event_count());
   EXPECT_FALSE(IsPendingAckTouchStart());
 }
 
 // Tests that the touch timeout is started when sending certain touch types.
-TEST_F(TouchEventQueueTest, TouchTimeoutTypes) {
+TEST_F(PassthroughTouchEventQueueTest, TouchTimeoutTypes) {
   SetUpForTimeoutTesting();
 
   // Sending a TouchStart will start the timeout.
   PressTouchPoint(0, 1);
   EXPECT_TRUE(IsTimeoutRunning());
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   EXPECT_FALSE(IsTimeoutRunning());
 
   // A TouchMove should start the timeout.
   MoveTouchPoint(0, 5, 5);
@@ skipping 13 matching lines @@
   ASSERT_FALSE(IsTimeoutRunning());
   CancelTouchPoint(0);
   EXPECT_FALSE(IsTimeoutRunning());
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   EXPECT_FALSE(IsTimeoutRunning());
 }
 
 // Tests that a delayed TouchEvent ack will trigger a TouchCancel timeout,
 // disabling touch forwarding until the next TouchStart is received after
 // the timeout events are ack'ed.
-TEST_F(TouchEventQueueTest, TouchTimeoutBasic) {
+TEST_F(PassthroughTouchEventQueueTest, TouchTimeoutBasic) {
   SetUpForTimeoutTesting();
 
   // Queue a TouchStart.
   GetAndResetSentEventCount();
   GetAndResetAckedEventCount();
   PressTouchPoint(0, 1);
   ASSERT_EQ(1U, GetAndResetSentEventCount());
   ASSERT_EQ(0U, GetAndResetAckedEventCount());
   EXPECT_TRUE(IsTimeoutRunning());
 
@@ skipping 33 matching lines @@
   // Subsequent events should be handled normally.
   PressTouchPoint(0, 1);
   EXPECT_EQ(WebInputEvent::TouchStart, sent_event().type());
   EXPECT_EQ(WebInputEvent::Blocking, sent_event().dispatchType);
   EXPECT_EQ(1U, GetAndResetSentEventCount());
   EXPECT_EQ(0U, GetAndResetAckedEventCount());
 }
 
 // Tests that the timeout is never started if the renderer consumes
 // a TouchEvent from the current touch sequence.
-TEST_F(TouchEventQueueTest, NoTouchTimeoutIfRendererIsConsumingGesture) {
+TEST_F(PassthroughTouchEventQueueTest,
+       NoTouchTimeoutIfRendererIsConsumingGesture) {
   SetUpForTimeoutTesting();
 
   // Queue a TouchStart.
   PressTouchPoint(0, 1);
   ASSERT_TRUE(IsTimeoutRunning());
 
   // Mark the event as consumed. This should prevent the timeout from
   // being activated on subsequent TouchEvents in this gesture.
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
   EXPECT_FALSE(IsTimeoutRunning());
@@ skipping 13 matching lines @@
   EXPECT_FALSE(IsTimeoutRunning());
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
 
   // A TouchCancel should not start the timeout.
   CancelTouchPoint(0);
   EXPECT_FALSE(IsTimeoutRunning());
 }
 
 // Tests that the timeout is never started if the renderer consumes
 // a TouchEvent from the current touch sequence.
-TEST_F(TouchEventQueueTest, NoTouchTimeoutIfDisabledAfterTouchStart) {
+TEST_F(PassthroughTouchEventQueueTest,
+       NoTouchTimeoutIfDisabledAfterTouchStart) {
   SetUpForTimeoutTesting();
 
   // Queue a TouchStart.
   PressTouchPoint(0, 1);
   ASSERT_TRUE(IsTimeoutRunning());
 
   // Send the ack immediately. The timeout should not have fired.
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   EXPECT_FALSE(IsTimeoutRunning());
   EXPECT_EQ(1U, GetAndResetSentEventCount());
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 
   // Now explicitly disable the timeout.
   SetAckTimeoutDisabled();
   EXPECT_FALSE(IsTimeoutRunning());
 
   // A TouchMove should not start or trigger the timeout.
   MoveTouchPoint(0, 5, 5);
   EXPECT_FALSE(IsTimeoutRunning());
   EXPECT_EQ(1U, GetAndResetSentEventCount());
   RunTasksAndWait(DefaultTouchTimeoutDelay() * 2);
   EXPECT_EQ(0U, GetAndResetAckedEventCount());
 }
 
 // Tests that the timeout is never started if the ack is synchronous.
-TEST_F(TouchEventQueueTest, NoTouchTimeoutIfAckIsSynchronous) {
+TEST_F(PassthroughTouchEventQueueTest, NoTouchTimeoutIfAckIsSynchronous) {
   SetUpForTimeoutTesting();
 
   // Queue a TouchStart.
   SetSyncAckResult(INPUT_EVENT_ACK_STATE_CONSUMED);
   ASSERT_FALSE(IsTimeoutRunning());
   PressTouchPoint(0, 1);
   EXPECT_FALSE(IsTimeoutRunning());
 }
 
 // Tests that the timeout does not fire if explicitly disabled while an event
 // is in-flight.
-TEST_F(TouchEventQueueTest, NoTouchTimeoutIfDisabledWhileTimerIsActive) {
+TEST_F(PassthroughTouchEventQueueTest,
+       NoTouchTimeoutIfDisabledWhileTimerIsActive) {
   SetUpForTimeoutTesting();
 
   // Queue a TouchStart.
   PressTouchPoint(0, 1);
   ASSERT_TRUE(IsTimeoutRunning());
 
   // Verify that disabling the timeout also turns off the timer.
   SetAckTimeoutDisabled();
   EXPECT_FALSE(IsTimeoutRunning());
   RunTasksAndWait(DefaultTouchTimeoutDelay() * 2);
   EXPECT_EQ(0U, GetAndResetAckedEventCount());
 }
 
 // Tests that the timeout does not fire if the delay is zero.
-TEST_F(TouchEventQueueTest, NoTouchTimeoutIfTimeoutDelayIsZero) {
+TEST_F(PassthroughTouchEventQueueTest, NoTouchTimeoutIfTimeoutDelayIsZero) {
   SetUpForTimeoutTesting(base::TimeDelta(), base::TimeDelta());
 
   // As the delay is zero, timeout behavior should be disabled.
   PressTouchPoint(0, 1);
   EXPECT_FALSE(IsTimeoutRunning());
   RunTasksAndWait(DefaultTouchTimeoutDelay() * 2);
   EXPECT_EQ(0U, GetAndResetAckedEventCount());
 }
 
 // Tests that timeout delays for mobile sites take effect when appropriate.
-TEST_F(TouchEventQueueTest, TouchTimeoutConfiguredForMobile) {
+TEST_F(PassthroughTouchEventQueueTest, TouchTimeoutConfiguredForMobile) {
   base::TimeDelta desktop_delay = DefaultTouchTimeoutDelay();
   base::TimeDelta mobile_delay = base::TimeDelta();
   SetUpForTimeoutTesting(desktop_delay, mobile_delay);
 
   // The desktop delay is non-zero, allowing timeout behavior.
   SetIsMobileOptimizedSite(false);
 
   PressTouchPoint(0, 1);
   ASSERT_TRUE(IsTimeoutRunning());
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
   ReleaseTouchPoint(0);
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
   EXPECT_EQ(2U, GetAndResetAckedEventCount());
   ASSERT_FALSE(IsTimeoutRunning());
 
   // The mobile delay is zero, preventing timeout behavior.
   SetIsMobileOptimizedSite(true);
 
   PressTouchPoint(0, 1);
   EXPECT_FALSE(IsTimeoutRunning());
   RunTasksAndWait(DefaultTouchTimeoutDelay() * 2);
   EXPECT_EQ(0U, GetAndResetAckedEventCount());
 }
 
 // Tests that a TouchCancel timeout plays nice when the timed out touch stream
 // turns into a scroll gesture sequence.
-TEST_F(TouchEventQueueTest, TouchTimeoutWithFollowupGesture) {
+TEST_F(PassthroughTouchEventQueueTest, TouchTimeoutWithFollowupGesture) {
   SetUpForTimeoutTesting();
 
   // Queue a TouchStart.
   PressTouchPoint(0, 1);
   EXPECT_TRUE(IsTimeoutRunning());
   EXPECT_EQ(1U, GetAndResetSentEventCount());
 
   // The cancelled sequence may turn into a scroll gesture.
   WebGestureEvent followup_scroll(
       WebInputEvent::GestureScrollBegin, WebInputEvent::NoModifiers,
@@ skipping 35 matching lines @@
   SendGestureEvent(blink::WebInputEvent::GestureScrollEnd);
   PressTouchPoint(0, 1);
   EXPECT_TRUE(IsTimeoutRunning());
   EXPECT_EQ(1U, GetAndResetSentEventCount());
   EXPECT_EQ(0U, GetAndResetAckedEventCount());
 }
 
 // Tests that a TouchCancel timeout plays nice when the timed out touch stream
 // turns into a scroll gesture sequence, but the original event acks are
 // significantly delayed.
-TEST_F(TouchEventQueueTest, TouchTimeoutWithFollowupGestureAndDelayedAck) {
+TEST_F(PassthroughTouchEventQueueTest,
+       TouchTimeoutWithFollowupGestureAndDelayedAck) {
   SetUpForTimeoutTesting();
 
   // Queue a TouchStart.
   PressTouchPoint(0, 1);
   EXPECT_TRUE(IsTimeoutRunning());
   EXPECT_EQ(1U, GetAndResetSentEventCount());
 
   // The cancelled sequence may turn into a scroll gesture.
   WebGestureEvent followup_scroll(
       WebInputEvent::GestureScrollBegin, WebInputEvent::NoModifiers,
@@ skipping 36 matching lines @@
   EXPECT_EQ(0U, GetAndResetSentEventCount());
   EXPECT_EQ(0U, GetAndResetAckedEventCount());
 
   PressTouchPoint(0, 1);
   EXPECT_TRUE(IsTimeoutRunning());
   EXPECT_EQ(1U, GetAndResetSentEventCount());
 }
 
 // Tests that a delayed TouchEvent ack will not trigger a TouchCancel timeout if
 // the timed-out event had no consumer.
-TEST_F(TouchEventQueueTest, NoCancelOnTouchTimeoutWithoutConsumer) {
+TEST_F(PassthroughTouchEventQueueTest, NoCancelOnTouchTimeoutWithoutConsumer) {
   SetUpForTimeoutTesting();
 
   // Queue a TouchStart.
   PressTouchPoint(0, 1);
   ASSERT_EQ(1U, GetAndResetSentEventCount());
   ASSERT_EQ(0U, GetAndResetAckedEventCount());
   EXPECT_TRUE(IsTimeoutRunning());
 
   // Delay the ack.
   RunTasksAndWait(DefaultTouchTimeoutDelay() * 2);
@@ skipping 18 matching lines @@
   EXPECT_EQ(0U, GetAndResetSentEventCount());
 
   // Subsequent events should be handled normally.
   PressTouchPoint(0, 1);
   EXPECT_EQ(1U, GetAndResetSentEventCount());
   EXPECT_EQ(0U, GetAndResetAckedEventCount());
 }
 
 // Tests that TouchMove's movedBeyondSlopRegion is set to false if within the
 // boundary-inclusive slop region for an unconsumed TouchStart.
-TEST_F(TouchEventQueueTest, TouchMovedBeyondSlopRegionCheck) {
+TEST_F(PassthroughTouchEventQueueTest, TouchMovedBeyondSlopRegionCheck) {
   SetUpForTouchMoveSlopTesting(kSlopLengthDips);
 
   // Queue a TouchStart.
   PressTouchPoint(0, 0);
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   ASSERT_EQ(1U, GetAndResetSentEventCount());
   ASSERT_EQ(1U, GetAndResetAckedEventCount());
 
   // TouchMove's movedBeyondSlopRegion within the slop region is set to false.
   MoveTouchPoint(0, 0, kHalfSlopLengthDips);
@@ skipping 29 matching lines @@
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   EXPECT_EQ(1U, GetAndResetSentEventCount());
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
   EXPECT_FALSE(acked_event().movedBeyondSlopRegion);
 
   // When a TouchMove exceeds the (Euclidean) distance, the TouchMove's
   // movedBeyondSlopRegion is set to true.
   const float kFortyFiveDegreeSlopLengthXY =
       kSlopLengthDips * std::sqrt(2.f) / 2;
   MoveTouchPoint(0, kFortyFiveDegreeSlopLengthXY + .2f,
-                    kFortyFiveDegreeSlopLengthXY + .2f);
+                 kFortyFiveDegreeSlopLengthXY + .2f);
   EXPECT_EQ(1U, queued_event_count());
   EXPECT_EQ(1U, GetAndResetSentEventCount());
   EXPECT_EQ(0U, GetAndResetAckedEventCount());
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
   EXPECT_TRUE(acked_event().movedBeyondSlopRegion);
 }
 
 // Tests that even very small TouchMove's movedBeyondSlopRegion is set to true
 // when the slop region's dimension is 0.
-TEST_F(TouchEventQueueTest, MovedBeyondSlopRegionAlwaysTrueIfDimensionZero) {
+TEST_F(PassthroughTouchEventQueueTest,
+       MovedBeyondSlopRegionAlwaysTrueIfDimensionZero) {
   // Queue a TouchStart.
   PressTouchPoint(0, 0);
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   ASSERT_EQ(1U, GetAndResetSentEventCount());
   ASSERT_EQ(1U, GetAndResetAckedEventCount());
 
   // Small TouchMove's movedBeyondSlopRegion is set to true.
   MoveTouchPoint(0, 0.001f, 0.001f);
   EXPECT_EQ(1U, queued_event_count());
   EXPECT_EQ(1U, GetAndResetSentEventCount());
   EXPECT_EQ(0U, GetAndResetAckedEventCount());
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
   EXPECT_TRUE(acked_event().movedBeyondSlopRegion);
 }
 
 // Tests that secondary touch points can be forwarded even if the primary touch
 // point had no consumer.
-TEST_F(TouchEventQueueTest, SecondaryTouchForwardedAfterPrimaryHadNoConsumer) {
+TEST_F(PassthroughTouchEventQueueTest,
+       SecondaryTouchForwardedAfterPrimaryHadNoConsumer) {
   // Queue a TouchStart.
   PressTouchPoint(0, 0);
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS);
   ASSERT_EQ(1U, GetAndResetSentEventCount());
   ASSERT_EQ(1U, GetAndResetAckedEventCount());
 
   // Events should not be forwarded, as the point had no consumer.
   MoveTouchPoint(0, 0, 15);
   EXPECT_EQ(0U, queued_event_count());
   EXPECT_EQ(0U, GetAndResetSentEventCount());
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 
   // Simulate a secondary pointer press.
   PressTouchPoint(20, 0);
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   EXPECT_EQ(1U, GetAndResetSentEventCount());
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 
   // TouchMove with a secondary pointer should not be suppressed.
   MoveTouchPoint(1, 25, 0);
   EXPECT_EQ(1U, queued_event_count());
   EXPECT_EQ(1U, GetAndResetSentEventCount());
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 }
 
 // Tests that secondary touch points can be forwarded after scrolling begins
 // while first touch point has no consumer.
-TEST_F(TouchEventQueueTest, NoForwardingAfterScrollWithNoTouchConsumers) {
+TEST_F(PassthroughTouchEventQueueTest,
+       NoForwardingAfterScrollWithNoTouchConsumers) {
   // Queue a TouchStart.
   PressTouchPoint(0, 0);
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS);
   ASSERT_EQ(1U, GetAndResetSentEventCount());
   ASSERT_EQ(1U, GetAndResetAckedEventCount());
 
   WebGestureEvent followup_scroll(WebInputEvent::GestureScrollBegin,
                                   WebInputEvent::NoModifiers,
                                   WebInputEvent::TimeStampForTesting);
   SetFollowupEvent(followup_scroll);
   MoveTouchPoint(0, 20, 5);
   EXPECT_EQ(0U, GetAndResetSentEventCount());
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
   EXPECT_EQ(INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS, acked_event_state());
 
   // The secondary pointer press should be forwarded.
   PressTouchPoint(20, 0);
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
   EXPECT_EQ(1U, GetAndResetSentEventCount());
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 
   // TouchMove with a secondary pointer should also be forwarded.
   MoveTouchPoint(1, 25, 0);
   EXPECT_EQ(1U, queued_event_count());
   EXPECT_EQ(1U, GetAndResetSentEventCount());
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 }
 
-TEST_F(TouchEventQueueTest, AsyncTouch) {
-  // Queue a TouchStart.
-  PressTouchPoint(0, 1);
-  EXPECT_EQ(1U, GetAndResetSentEventCount());
-  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-  EXPECT_EQ(1U, GetAndResetAckedEventCount());
-
-  for (int i = 0; i < 3; ++i) {
-   SendGestureEventAck(WebInputEvent::GestureScrollUpdate,
-                       INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-
-   MoveTouchPoint(0, 10, 5+i);
-   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-   EXPECT_FALSE(HasPendingAsyncTouchMove());
-   EXPECT_EQ(WebInputEvent::Blocking, sent_event().dispatchType);
-   EXPECT_EQ(0U, queued_event_count());
-   EXPECT_EQ(1U, GetAndResetSentEventCount());
-
-   // Consuming a scroll event will throttle subsequent touchmoves.
-   SendGestureEventAck(WebInputEvent::GestureScrollUpdate,
-                       INPUT_EVENT_ACK_STATE_CONSUMED);
-   MoveTouchPoint(0, 10, 7+i);
-   EXPECT_TRUE(HasPendingAsyncTouchMove());
-   EXPECT_EQ(0U, queued_event_count());
-   EXPECT_EQ(0U, GetAndResetSentEventCount());
-  }
-}
-
-// Ensure that touchmove's are appropriately throttled during a typical
-// scroll sequences that transitions between scrolls consumed and unconsumed.
-TEST_F(TouchEventQueueTest, AsyncTouchThrottledAfterScroll) {
-  // Process a TouchStart
-  PressTouchPoint(0, 1);
-  EXPECT_EQ(1U, GetAndResetSentEventCount());
-  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-  EXPECT_EQ(1U, GetAndResetAckedEventCount());
-
-  // Now send the first touch move and associated GestureScrollBegin.
-  MoveTouchPoint(0, 0, 5);
-  WebGestureEvent followup_scroll(WebInputEvent::GestureScrollBegin,
-                                  WebInputEvent::NoModifiers,
-                                  WebInputEvent::TimeStampForTesting);
-  SetFollowupEvent(followup_scroll);
-  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-  EXPECT_EQ(1U, GetAndResetSentEventCount());
-  EXPECT_EQ(1U, GetAndResetAckedEventCount());
-  SendGestureEventAck(WebInputEvent::GestureScrollBegin,
-                      INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-
-  // Send the second touch move and associated GestureScrollUpdate, but don't
-  // ACK the gesture event yet.
-  MoveTouchPoint(0, 0, 50);
-  followup_scroll.setType(WebInputEvent::GestureScrollUpdate);
-  SetFollowupEvent(followup_scroll);
-  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-  EXPECT_EQ(1U, GetAndResetSentEventCount());
-  EXPECT_EQ(1U, GetAndResetAckedEventCount());
-
-  // Now queue a second touchmove and verify it's not (yet) dispatched.
-  MoveTouchPoint(0, 0, 100);
-  SetFollowupEvent(followup_scroll);
-  EXPECT_TRUE(HasPendingAsyncTouchMove());
-  EXPECT_EQ(0U, queued_event_count());
-  EXPECT_EQ(0U, GetAndResetSentEventCount());
-  EXPECT_EQ(1U, GetAndResetAckedEventCount());
-
-  // Queuing the final touchend should flush the pending async touchmove. In
-  // this case, we will first dispatch an async touchmove and then a touchend.
-  // For the async touchmove, we will not send ack again.
-  ReleaseTouchPoint(0);
-  followup_scroll.setType(WebInputEvent::GestureScrollEnd);
-  SetFollowupEvent(followup_scroll);
-  EXPECT_FALSE(HasPendingAsyncTouchMove());
-  EXPECT_EQ(2U, all_sent_events().size());
-  EXPECT_EQ(WebInputEvent::TouchMove, all_sent_events()[0].type());
-  EXPECT_NE(WebInputEvent::Blocking, all_sent_events()[0].dispatchType);
-  EXPECT_EQ(WebInputEvent::TouchEnd, all_sent_events()[1].type());
-  EXPECT_NE(WebInputEvent::Blocking, all_sent_events()[1].dispatchType);
-  EXPECT_EQ(2U, GetAndResetSentEventCount());
-  EXPECT_EQ(0U, GetAndResetAckedEventCount());
-  EXPECT_EQ(1U, queued_event_count());
-
-  // Ack the touchend.
-  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-  EXPECT_EQ(0U, queued_event_count());
-  EXPECT_EQ(0U, GetAndResetSentEventCount());
-  EXPECT_EQ(1U, GetAndResetAckedEventCount());
-
-  // Now mark the scrolls as not consumed (which would cause future touchmoves
-  // in the active sequence to be sent if there was one).
-  SendGestureEventAck(WebInputEvent::GestureScrollUpdate,
-                      INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-  SendGestureEventAck(WebInputEvent::GestureScrollUpdate,
-                      INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-
-  // Start a new touch sequence and verify that throttling has been reset.
-  // Touch moves after the start of scrolling will again be throttled.
-  PressTouchPoint(0, 0);
-  EXPECT_EQ(1U, GetAndResetSentEventCount());
-  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-  EXPECT_EQ(1U, GetAndResetAckedEventCount());
-  MoveTouchPoint(0, 0, 5);
-  followup_scroll.setType(WebInputEvent::GestureScrollBegin);
-  SetFollowupEvent(followup_scroll);
-  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-  EXPECT_EQ(1U, GetAndResetSentEventCount());
-  EXPECT_EQ(1U, GetAndResetAckedEventCount());
-
-  MoveTouchPoint(0, 0, 6);
-  followup_scroll.setType(WebInputEvent::GestureScrollUpdate);
-  SetFollowupEvent(followup_scroll);
-  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-  EXPECT_FALSE(HasPendingAsyncTouchMove());
-  EXPECT_EQ(1U, GetAndResetSentEventCount());
-  EXPECT_EQ(1U, GetAndResetAckedEventCount());
-
-  MoveTouchPoint(0, 0, 10);
-  EXPECT_TRUE(HasPendingAsyncTouchMove());
-  EXPECT_EQ(0U, queued_event_count());
-  EXPECT_EQ(0U, GetAndResetSentEventCount());
-  EXPECT_EQ(1U, GetAndResetAckedEventCount());
-
-  // Subsequent touchmove's should be deferred.
-  MoveTouchPoint(0, 0, 25);
-  EXPECT_TRUE(HasPendingAsyncTouchMove());
-  EXPECT_EQ(0U, queued_event_count());
-  EXPECT_EQ(0U, GetAndResetSentEventCount());
-  EXPECT_EQ(1U, GetAndResetAckedEventCount());
-  EXPECT_EQ(0U, uncancelable_touch_moves_pending_ack_count());
-
-  // The pending touchmove should be flushed with the the new touchmove if
-  // sufficient time has passed and ack to the client.
-  AdvanceTouchTime(kMinSecondsBetweenThrottledTouchmoves + 0.1);
-  MoveTouchPoint(0, 0, 15);
-  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-  EXPECT_FALSE(HasPendingAsyncTouchMove());
-  EXPECT_NE(WebInputEvent::Blocking, sent_event().dispatchType);
-  EXPECT_EQ(0U, queued_event_count());
-  EXPECT_EQ(1U, GetAndResetSentEventCount());
-  EXPECT_EQ(1U, GetAndResetAckedEventCount());
-
-  // Non-touchmove events should always flush any pending touchmove events. In
-  // this case, we will first dispatch an async touchmove and then a
-  // touchstart. For the async touchmove, we will not send ack again.
-  MoveTouchPoint(0, 0, 25);
-  EXPECT_TRUE(HasPendingAsyncTouchMove());
-  EXPECT_EQ(0U, queued_event_count());
-  EXPECT_EQ(0U, GetAndResetSentEventCount());
-  EXPECT_EQ(1U, GetAndResetAckedEventCount());
-  PressTouchPoint(30, 30);
-  EXPECT_FALSE(HasPendingAsyncTouchMove());
-  EXPECT_EQ(2U, all_sent_events().size());
-  EXPECT_EQ(WebInputEvent::TouchMove, all_sent_events()[0].type());
-  EXPECT_NE(WebInputEvent::Blocking, all_sent_events()[0].dispatchType);
-  EXPECT_EQ(WebInputEvent::TouchStart, all_sent_events()[1].type());
-  EXPECT_EQ(WebInputEvent::Blocking, all_sent_events()[1].dispatchType);
-  EXPECT_EQ(2U, GetAndResetSentEventCount());
-  EXPECT_EQ(0U, GetAndResetAckedEventCount());
-  EXPECT_EQ(1U, queued_event_count());
-
-  // Ack the touchstart.
-  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-  EXPECT_EQ(0U, queued_event_count());
-  EXPECT_EQ(0U, GetAndResetSentEventCount());
-  EXPECT_EQ(1U, GetAndResetAckedEventCount());
-
-  // Send a secondary touchmove.
-  MoveTouchPoint(1, 0, 25);
-  EXPECT_TRUE(HasPendingAsyncTouchMove());
-  EXPECT_EQ(0U, queued_event_count());
-  EXPECT_EQ(0U, GetAndResetSentEventCount());
-  EXPECT_EQ(1U, GetAndResetAckedEventCount());
-
-  // An unconsumed scroll should resume synchronous touch handling.
-  SendGestureEventAck(WebInputEvent::GestureScrollUpdate,
-                      INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-
-  // The pending touchmove should be coalesced with the next (now synchronous)
-  // touchmove.
-  MoveTouchPoint(0, 0, 26);
-  EXPECT_EQ(WebInputEvent::Blocking, sent_event().dispatchType);
-  EXPECT_FALSE(HasPendingAsyncTouchMove());
-  EXPECT_EQ(WebInputEvent::TouchMove, sent_event().type());
-  EXPECT_EQ(WebTouchPoint::StateMoved, sent_event().touches[0].state);
-  EXPECT_EQ(WebTouchPoint::StateMoved, sent_event().touches[1].state);
-  EXPECT_EQ(1U, queued_event_count());
-  EXPECT_EQ(1U, GetAndResetSentEventCount());
-  EXPECT_EQ(0U, GetAndResetAckedEventCount());
-
-  // Subsequent touches will queue until the preceding, synchronous touches are
-  // ack'ed.
-  ReleaseTouchPoint(1);
-  EXPECT_EQ(2U, queued_event_count());
-  ReleaseTouchPoint(0);
-  EXPECT_EQ(3U, queued_event_count());
-  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-  EXPECT_EQ(WebInputEvent::Blocking, sent_event().dispatchType);
-  EXPECT_EQ(WebInputEvent::TouchEnd, sent_event().type());
-  EXPECT_EQ(2U, queued_event_count());
-  EXPECT_EQ(1U, GetAndResetSentEventCount());
-  EXPECT_EQ(1U, GetAndResetAckedEventCount());
-
-  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-  EXPECT_EQ(WebInputEvent::Blocking, sent_event().dispatchType);
-  EXPECT_EQ(WebInputEvent::TouchEnd, sent_event().type());
-  EXPECT_EQ(1U, queued_event_count());
-  EXPECT_EQ(1U, GetAndResetSentEventCount());
-  EXPECT_EQ(1U, GetAndResetAckedEventCount());
-
-  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-  EXPECT_EQ(0U, queued_event_count());
-  EXPECT_EQ(0U, GetAndResetSentEventCount());
-  EXPECT_EQ(1U, GetAndResetAckedEventCount());
-}
-
-TEST_F(TouchEventQueueTest, AsyncTouchFlushedByTouchEnd) {
-  PressTouchPoint(0, 0);
-  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-  EXPECT_EQ(1U, GetAndResetSentEventCount());
-  EXPECT_EQ(1U, GetAndResetAckedEventCount());
-
-  // Initiate async touchmove dispatch after the start of a scroll sequence.
-  MoveTouchPoint(0, 0, 5);
-  WebGestureEvent followup_scroll(WebInputEvent::GestureScrollBegin,
-                                  WebInputEvent::NoModifiers,
-                                  WebInputEvent::TimeStampForTesting);
-  SetFollowupEvent(followup_scroll);
-  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-  EXPECT_EQ(1U, GetAndResetSentEventCount());
-  EXPECT_EQ(1U, GetAndResetAckedEventCount());
-
-  MoveTouchPoint(0, 0, 10);
-  followup_scroll.setType(WebInputEvent::GestureScrollUpdate);
-  SetFollowupEvent(followup_scroll);
-  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-  EXPECT_EQ(1U, GetAndResetSentEventCount());
-  EXPECT_EQ(1U, GetAndResetAckedEventCount());
-
-  // Now queue a second touchmove and verify it's not (yet) dispatched.
-  MoveTouchPoint(0, 0, 100);
-  EXPECT_TRUE(HasPendingAsyncTouchMove());
-  EXPECT_EQ(0U, queued_event_count());
-  EXPECT_EQ(0U, GetAndResetSentEventCount());
-  EXPECT_EQ(1U, GetAndResetAckedEventCount());
-
-  // Return the touch sequence to the original touchstart position. Note that
-  // this (0, 0) touchmove will coalesce with the previous (0, 100) touchmove.
-  MoveTouchPoint(0, 0, 0);
-  EXPECT_TRUE(HasPendingAsyncTouchMove());
-  EXPECT_EQ(0U, queued_event_count());
-  EXPECT_EQ(0U, GetAndResetSentEventCount());
-  EXPECT_EQ(1U, GetAndResetAckedEventCount());
-
-  // Queuing the final touchend should flush the pending, async touchmove. In
-  // this case, we will first dispatch an async touchmove and then a touchend.
-  // For the async touchmove, we will not send ack again.
-  ReleaseTouchPoint(0);
-  EXPECT_FALSE(HasPendingAsyncTouchMove());
-  EXPECT_EQ(2U, all_sent_events().size());
-  EXPECT_EQ(WebInputEvent::TouchMove, all_sent_events()[0].type());
-  EXPECT_NE(WebInputEvent::Blocking, all_sent_events()[0].dispatchType);
-  EXPECT_EQ(0, all_sent_events()[0].touches[0].position.x);
-  EXPECT_EQ(0, all_sent_events()[0].touches[0].position.y);
-  EXPECT_EQ(WebInputEvent::TouchEnd, all_sent_events()[1].type());
-  EXPECT_NE(WebInputEvent::Blocking, all_sent_events()[1].dispatchType);
-  EXPECT_EQ(2U, GetAndResetSentEventCount());
-  EXPECT_EQ(0U, GetAndResetAckedEventCount());
-}
-
-// Ensure that async touch dispatch and touch ack timeout interactions work
-// appropriately.
-TEST_F(TouchEventQueueTest, AsyncTouchWithAckTimeout) {
-  SetUpForTimeoutTesting();
-
-  // The touchstart should start the timeout.
-  PressTouchPoint(0, 0);
-  EXPECT_EQ(1U, GetAndResetSentEventCount());
-  EXPECT_TRUE(IsTimeoutRunning());
-  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-  EXPECT_EQ(1U, GetAndResetAckedEventCount());
-  EXPECT_FALSE(IsTimeoutRunning());
-
-  // The start of a scroll gesture should trigger async touch event dispatch.
-  MoveTouchPoint(0, 1, 1);
-  EXPECT_EQ(1U, GetAndResetSentEventCount());
-  EXPECT_TRUE(IsTimeoutRunning());
-  WebGestureEvent followup_scroll(WebInputEvent::GestureScrollBegin,
-                                  WebInputEvent::NoModifiers,
-                                  WebInputEvent::TimeStampForTesting);
-  SetFollowupEvent(followup_scroll);
-  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-  EXPECT_FALSE(IsTimeoutRunning());
-  EXPECT_EQ(1U, GetAndResetAckedEventCount());
-
-  SendGestureEventAck(WebInputEvent::GestureScrollUpdate,
-                      INPUT_EVENT_ACK_STATE_CONSUMED);
-
-  // An async touch should fire after the throttling interval has expired, but
-  // it should not start the touch ack timeout.
-  MoveTouchPoint(0, 5, 5);
-  EXPECT_TRUE(HasPendingAsyncTouchMove());
-  EXPECT_EQ(1U, GetAndResetAckedEventCount());
-
-  AdvanceTouchTime(kMinSecondsBetweenThrottledTouchmoves + 0.1);
-  MoveTouchPoint(0, 5, 5);
-  EXPECT_FALSE(IsTimeoutRunning());
-  EXPECT_FALSE(HasPendingAsyncTouchMove());
-  EXPECT_NE(WebInputEvent::Blocking, sent_event().dispatchType);
-  EXPECT_EQ(1U, GetAndResetAckedEventCount());
-  EXPECT_EQ(1U, GetAndResetSentEventCount());
-
-  // An unconsumed scroll event will resume synchronous touchmoves, which are
-  // subject to the ack timeout.
-  SendGestureEventAck(WebInputEvent::GestureScrollUpdate,
-                      INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-  MoveTouchPoint(0, 20, 5);
-  EXPECT_TRUE(IsTimeoutRunning());
-  EXPECT_EQ(WebInputEvent::Blocking, sent_event().dispatchType);
-  EXPECT_EQ(1U, GetAndResetSentEventCount());
-
-  // The timeout should fire, disabling touch forwarding until both acks are
-  // received and acking the timed out event.
-  RunTasksAndWait(DefaultTouchTimeoutDelay() * 2);
-  EXPECT_FALSE(IsTimeoutRunning());
-  EXPECT_EQ(1U, GetAndResetAckedEventCount());
-  EXPECT_EQ(0U, GetAndResetSentEventCount());
-
-  // Ack'ing the original event should trigger a cancel event.
-  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-  EXPECT_NE(WebInputEvent::Blocking, sent_event().dispatchType);
-  EXPECT_EQ(0U, GetAndResetAckedEventCount());
-  EXPECT_EQ(1U, GetAndResetSentEventCount());
-
-  // Subsequent touchmove's should not be forwarded, even as the scroll gesture
-  // goes from unconsumed to consumed.
-  SendGestureEventAck(WebInputEvent::GestureScrollUpdate,
-                      INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-  MoveTouchPoint(0, 20, 5);
-  EXPECT_FALSE(HasPendingAsyncTouchMove());
-  EXPECT_EQ(1U, GetAndResetAckedEventCount());
-  EXPECT_EQ(0U, GetAndResetSentEventCount());
-
-  SendGestureEventAck(WebInputEvent::GestureScrollUpdate,
-                      INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-  MoveTouchPoint(0, 25, 5);
-  EXPECT_FALSE(HasPendingAsyncTouchMove());
-  EXPECT_EQ(1U, GetAndResetAckedEventCount());
-  EXPECT_EQ(0U, GetAndResetSentEventCount());
-}
-
-// Ensure that if the touch ack for an async touchmove triggers a follow-up
-// touch event, that follow-up touch will be forwarded appropriately.
-TEST_F(TouchEventQueueTest, AsyncTouchWithTouchCancelAfterAck) {
-  PressTouchPoint(0, 0);
-  EXPECT_EQ(1U, GetAndResetSentEventCount());
-  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-  EXPECT_EQ(1U, GetAndResetAckedEventCount());
-
-  // The start of a scroll gesture should trigger async touch event dispatch.
-  MoveTouchPoint(0, 1, 1);
-  EXPECT_EQ(1U, GetAndResetSentEventCount());
-  WebGestureEvent followup_scroll(WebInputEvent::GestureScrollBegin,
-                                  WebInputEvent::NoModifiers,
-                                  WebInputEvent::TimeStampForTesting);
-  SetFollowupEvent(followup_scroll);
-  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-  EXPECT_EQ(1U, GetAndResetAckedEventCount());
-  EXPECT_EQ(0U, queued_event_count());
-
-  SendGestureEvent(WebInputEvent::GestureScrollUpdate);
-
-  // The async touchmove should be ack'ed immediately, but not forwarded.
-  // However, because the ack triggers a touchcancel, both the pending touch and
-  // the queued touchcancel should be flushed.
-  WebTouchEvent followup_cancel(WebInputEvent::TouchCancel,
-                                WebInputEvent::NoModifiers,
-                                WebInputEvent::TimeStampForTesting);
-  followup_cancel.touchesLength = 1;
-  followup_cancel.touches[0].state = WebTouchPoint::StateCancelled;
-  SetFollowupEvent(followup_cancel);
-  MoveTouchPoint(0, 5, 5);
-  EXPECT_EQ(1U, queued_event_count());
-  EXPECT_EQ(2U, all_sent_events().size());
-  EXPECT_EQ(WebInputEvent::TouchMove, all_sent_events()[0].type());
-  EXPECT_NE(WebInputEvent::Blocking, all_sent_events()[0].dispatchType);
-  EXPECT_EQ(WebInputEvent::TouchCancel, all_sent_events()[1].type());
-  EXPECT_NE(WebInputEvent::Blocking, all_sent_events()[1].dispatchType);
-  EXPECT_EQ(2U, GetAndResetSentEventCount());
-  // Sending the ack is because the async touchmove is not ready for
-  // dispatching send the ack immediately.
-  EXPECT_EQ(1U, GetAndResetAckedEventCount());
-  EXPECT_EQ(WebInputEvent::TouchMove, acked_event().type());
-
-  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-  EXPECT_EQ(0U, queued_event_count());
-  EXPECT_EQ(WebInputEvent::TouchCancel, acked_event().type());
-  EXPECT_EQ(1U, GetAndResetAckedEventCount());
-  EXPECT_EQ(0U, GetAndResetSentEventCount());
-}
-
-// Ensure that the async touch is fully reset if the touch sequence restarts
-// without properly terminating.
-TEST_F(TouchEventQueueTest, AsyncTouchWithHardTouchStartReset) {
-  PressTouchPoint(0, 0);
-  EXPECT_EQ(1U, GetAndResetSentEventCount());
-  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-  EXPECT_EQ(1U, GetAndResetAckedEventCount());
-
-  // Trigger async touchmove dispatch.
-  MoveTouchPoint(0, 1, 1);
-  EXPECT_EQ(1U, GetAndResetSentEventCount());
-  WebGestureEvent followup_scroll(WebInputEvent::GestureScrollBegin,
-                                  WebInputEvent::NoModifiers,
-                                  WebInputEvent::TimeStampForTesting);
-  SetFollowupEvent(followup_scroll);
-  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-  EXPECT_EQ(1U, GetAndResetAckedEventCount());
-  EXPECT_EQ(0U, queued_event_count());
-  SendGestureEvent(WebInputEvent::GestureScrollUpdate);
-
-  // The async touchmove should be immediately ack'ed but delivery is deferred.
-  MoveTouchPoint(0, 2, 2);
-  EXPECT_EQ(0U, GetAndResetSentEventCount());
-  EXPECT_EQ(1U, GetAndResetAckedEventCount());
-  EXPECT_EQ(0U, queued_event_count());
-  EXPECT_EQ(WebInputEvent::TouchMove, acked_event().type());
-
-  // The queue should be robust to hard touch restarts with a new touch
-  // sequence. In this case, the deferred async touch should not be flushed
-  // by the new touch sequence.
-  SendGestureEvent(WebInputEvent::GestureScrollEnd);
-  ResetTouchEvent();
-
-  PressTouchPoint(0, 0);
-  EXPECT_EQ(WebInputEvent::TouchStart, sent_event().type());
-  EXPECT_EQ(1U, GetAndResetSentEventCount());
-  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-  EXPECT_EQ(1U, GetAndResetAckedEventCount());
-}
-
-// Ensure that even when the interval expires, we still need to wait for the
-// ack sent back from render to send the next async touchmove once the scroll
-// starts.
-TEST_F(TouchEventQueueTest, SendNextThrottledAsyncTouchMoveAfterAck) {
-  // Process a TouchStart
-  PressTouchPoint(0, 1);
-  EXPECT_EQ(1U, GetAndResetSentEventCount());
-  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-  EXPECT_EQ(1U, GetAndResetAckedEventCount());
-
-  // Initiate async touchmove dispatch after the start of a scroll sequence.
-  MoveTouchPoint(0, 0, 5);
-  WebGestureEvent followup_scroll(WebInputEvent::GestureScrollBegin,
-                                  WebInputEvent::NoModifiers,
-                                  WebInputEvent::TimeStampForTesting);
-  SetFollowupEvent(followup_scroll);
-  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-  EXPECT_EQ(1U, GetAndResetSentEventCount());
-  EXPECT_EQ(1U, GetAndResetAckedEventCount());
-
-  MoveTouchPoint(0, 0, 10);
-  followup_scroll.setType(WebInputEvent::GestureScrollUpdate);
-  SetFollowupEvent(followup_scroll);
-  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-  EXPECT_FALSE(HasPendingAsyncTouchMove());
-  EXPECT_EQ(1U, GetAndResetSentEventCount());
-  EXPECT_EQ(1U, GetAndResetAckedEventCount());
-
-  // We set the next touch event time to be after the throttled interval.
-  AdvanceTouchTime(kMinSecondsBetweenThrottledTouchmoves + 0.1);
-  // Dispatch the touch move event when sufficient time has passed.
-  MoveTouchPoint(0, 0, 40);
-  EXPECT_FALSE(HasPendingAsyncTouchMove());
-  EXPECT_NE(WebInputEvent::Blocking, sent_event().dispatchType);
-  // When we dispatch an async touchmove, we do not put it back to the queue
-  // any more and we will ack to client right away.
-  EXPECT_EQ(0U, queued_event_count());
-  EXPECT_EQ(1U, GetAndResetSentEventCount());
-  EXPECT_EQ(1U, GetAndResetAckedEventCount());
-  EXPECT_EQ(1U, uncancelable_touch_moves_pending_ack_count());
-
-  // Do not dispatch the event until throttledTouchmoves intervals expires and
-  // receive an ack from render.
-  AdvanceTouchTime(kMinSecondsBetweenThrottledTouchmoves + 0.1);
-  MoveTouchPoint(0, 0, 50);
-  EXPECT_TRUE(HasPendingAsyncTouchMove());
-  EXPECT_EQ(0U, queued_event_count());
-  EXPECT_EQ(0U, GetAndResetSentEventCount());
-  EXPECT_EQ(1U, GetAndResetAckedEventCount());
-  EXPECT_EQ(1U, uncancelable_touch_moves_pending_ack_count());
-
-  // Send pending_async_touch_move_ when we receive an ack back from render,
-  // but we will not send an ack for pending_async_touch_move_ becasue it is
-  // been acked before.
-  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-  EXPECT_FALSE(HasPendingAsyncTouchMove());
-  EXPECT_EQ(0U, queued_event_count());
-  EXPECT_EQ(1U, GetAndResetSentEventCount());
-  EXPECT_EQ(0U, GetAndResetAckedEventCount());
-  EXPECT_EQ(1U, uncancelable_touch_moves_pending_ack_count());
-}
-
-// Ensure that even when we receive the ack from render, we still need to wait
-// for the interval expires to send the next async touchmove once the scroll
-// starts.
-TEST_F(TouchEventQueueTest, SendNextAsyncTouchMoveAfterAckAndTimeExpire) {
-  // Process a TouchStart
-  PressTouchPoint(0, 1);
-  EXPECT_EQ(1U, GetAndResetSentEventCount());
-  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-  EXPECT_EQ(1U, GetAndResetAckedEventCount());
-
-  // Initiate async touchmove dispatch after the start of a scroll sequence.
-  MoveTouchPoint(0, 0, 5);
-  WebGestureEvent followup_scroll(WebInputEvent::GestureScrollBegin,
-                                  WebInputEvent::NoModifiers,
-                                  WebInputEvent::TimeStampForTesting);
-  SetFollowupEvent(followup_scroll);
-  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-  EXPECT_EQ(1U, GetAndResetSentEventCount());
-  EXPECT_EQ(1U, GetAndResetAckedEventCount());
-
-  MoveTouchPoint(0, 0, 10);
-  followup_scroll.setType(WebInputEvent::GestureScrollUpdate);
-  SetFollowupEvent(followup_scroll);
-  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-  EXPECT_FALSE(HasPendingAsyncTouchMove());
-  EXPECT_EQ(1U, GetAndResetSentEventCount());
-  EXPECT_EQ(1U, GetAndResetAckedEventCount());
-
-  // Dispatch the touch move event when sufficient time has passed.
-  AdvanceTouchTime(kMinSecondsBetweenThrottledTouchmoves + 0.1);
-  MoveTouchPoint(0, 0, 40);
-  EXPECT_FALSE(HasPendingAsyncTouchMove());
-  EXPECT_NE(WebInputEvent::Blocking, sent_event().dispatchType);
-  // When we dispatch an async touchmove, we do not put it back to the queue
-  // any more and we will ack to client right away.
-  EXPECT_EQ(0U, queued_event_count());
-  EXPECT_EQ(1U, GetAndResetSentEventCount());
-  EXPECT_EQ(1U, GetAndResetAckedEventCount());
-  EXPECT_EQ(1U, uncancelable_touch_moves_pending_ack_count());
-
-  // We receive an ack back from render but the time interval is not expired,
-  // so we do not dispatch the touch move event.
-  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-  EXPECT_EQ(0U, uncancelable_touch_moves_pending_ack_count());
-  MoveTouchPoint(0, 0, 50);
-  EXPECT_TRUE(HasPendingAsyncTouchMove());
-  EXPECT_EQ(0U, queued_event_count());
-  EXPECT_EQ(0U, GetAndResetSentEventCount());
-  EXPECT_EQ(1U, GetAndResetAckedEventCount());
-
-  // Dispatch the touch move when sufficient time has passed.
-  AdvanceTouchTime(kMinSecondsBetweenThrottledTouchmoves + 0.1);
-  MoveTouchPoint(0, 0, 50);
-  EXPECT_FALSE(HasPendingAsyncTouchMove());
-  EXPECT_EQ(WebInputEvent::TouchMove, sent_event().type());
-  EXPECT_NE(WebInputEvent::Blocking, sent_event().dispatchType);
-  EXPECT_EQ(0U, queued_event_count());
-  EXPECT_EQ(1U, GetAndResetSentEventCount());
-  EXPECT_EQ(1U, GetAndResetAckedEventCount());
-  EXPECT_EQ(1U, uncancelable_touch_moves_pending_ack_count());
-}
-
-TEST_F(TouchEventQueueTest, AsyncTouchFlushedByNonTouchMove) {
-  // Process a TouchStart
-  PressTouchPoint(0, 1);
-  EXPECT_EQ(1U, GetAndResetSentEventCount());
-  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-  EXPECT_EQ(1U, GetAndResetAckedEventCount());
-
-  // Initiate async touchmove dispatch after the start of a scroll sequence.
-  MoveTouchPoint(0, 0, 5);
-  WebGestureEvent followup_scroll(WebInputEvent::GestureScrollBegin,
-                                  WebInputEvent::NoModifiers,
-                                  WebInputEvent::TimeStampForTesting);
-  SetFollowupEvent(followup_scroll);
-  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-  EXPECT_EQ(1U, GetAndResetSentEventCount());
-  EXPECT_EQ(1U, GetAndResetAckedEventCount());
-
-  MoveTouchPoint(0, 0, 10);
-  followup_scroll.setType(WebInputEvent::GestureScrollUpdate);
-  SetFollowupEvent(followup_scroll);
-  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-  EXPECT_FALSE(HasPendingAsyncTouchMove());
-  EXPECT_EQ(1U, GetAndResetSentEventCount());
-  EXPECT_EQ(1U, GetAndResetAckedEventCount());
-
-  // Dispatch the touch move when sufficient time has passed.
-  AdvanceTouchTime(kMinSecondsBetweenThrottledTouchmoves + 0.1);
-  MoveTouchPoint(0, 0, 40);
-  EXPECT_FALSE(HasPendingAsyncTouchMove());
-  EXPECT_NE(WebInputEvent::Blocking, sent_event().dispatchType);
-  // When we dispatch an async touchmove, we do not put it back to the queue
-  // any more and we will ack to client right away.
-  EXPECT_EQ(0U, queued_event_count());
-  EXPECT_EQ(1U, GetAndResetSentEventCount());
-  EXPECT_EQ(1U, GetAndResetAckedEventCount());
-  EXPECT_EQ(1U, uncancelable_touch_moves_pending_ack_count());
-
-  for (int i = 0; i < 3; ++i) {
-    // We throttle the touchmoves, put it in the pending_async_touch_move_,
-    // do not dispatch it.
-    MoveTouchPoint(0, 10 + 10 * i, 10 + 10 * i);
-    EXPECT_TRUE(HasPendingAsyncTouchMove());
-    EXPECT_EQ(0U, queued_event_count());
-    EXPECT_EQ(0U, GetAndResetSentEventCount());
-    EXPECT_EQ(1U, GetAndResetAckedEventCount());
-    EXPECT_EQ(static_cast<size_t>(i + 1),
-              uncancelable_touch_moves_pending_ack_count());
-
-    // Send touchstart will flush pending_async_touch_move_, and increase the
-    // count. In this case, we will first dispatch an async touchmove and
-    // then a touchstart. For the async touchmove, we will not send ack again.
-    PressTouchPoint(30, 30);
-    EXPECT_FALSE(HasPendingAsyncTouchMove());
-    EXPECT_EQ(2U, all_sent_events().size());
-    EXPECT_EQ(WebInputEvent::TouchMove, all_sent_events()[0].type());
-    EXPECT_NE(WebInputEvent::Blocking, all_sent_events()[0].dispatchType);
-    EXPECT_EQ(10 + 10 * i, all_sent_events()[0].touches[0].position.x);
-    EXPECT_EQ(10 + 10 * i, all_sent_events()[0].touches[0].position.y);
-    EXPECT_EQ(static_cast<size_t>(i + 2),
-              uncancelable_touch_moves_pending_ack_count());
-    EXPECT_EQ(WebInputEvent::TouchStart, all_sent_events()[1].type());
-    EXPECT_EQ(WebInputEvent::Blocking, all_sent_events()[1].dispatchType);
-    EXPECT_EQ(2U, GetAndResetSentEventCount());
-    EXPECT_EQ(0U, GetAndResetAckedEventCount());
-
-    SendTouchEventAckWithID(INPUT_EVENT_ACK_STATE_NOT_CONSUMED,
-                            GetUniqueTouchEventID());
-    EXPECT_EQ(0U, queued_event_count());
-    EXPECT_FALSE(HasPendingAsyncTouchMove());
-    EXPECT_EQ(0U, GetAndResetSentEventCount());
-    EXPECT_EQ(1U, GetAndResetAckedEventCount());
-  }
-
-  EXPECT_EQ(4U, uncancelable_touch_moves_pending_ack_count());
-
-  // When we receive an ack from render we decrease the count.
-  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-  EXPECT_EQ(3U, uncancelable_touch_moves_pending_ack_count());
-  EXPECT_EQ(0U, queued_event_count());
-  EXPECT_FALSE(HasPendingAsyncTouchMove());
-
-  // Do not dispatch the next uncancelable touchmove when we have not received
-  // all the acks back from render.
-  AdvanceTouchTime(kMinSecondsBetweenThrottledTouchmoves + 0.1);
-  MoveTouchPoint(0, 20, 30);
-  EXPECT_TRUE(HasPendingAsyncTouchMove());
-  EXPECT_EQ(0U, queued_event_count());
-  EXPECT_EQ(0U, GetAndResetSentEventCount());
-  EXPECT_EQ(1U, GetAndResetAckedEventCount());
-  EXPECT_EQ(3U, uncancelable_touch_moves_pending_ack_count());
-
-  // Once we receive the ack from render, we do not dispatch the
-  // pending_async_touchmove_ until the count is 0.
-  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-  EXPECT_EQ(2U, uncancelable_touch_moves_pending_ack_count());
-  EXPECT_EQ(0U, queued_event_count());
-  EXPECT_TRUE(HasPendingAsyncTouchMove());
-
-  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-
-  // When we receive this ack from render, and the count is 0, so we can
-  // dispatch the pending_async_touchmove_.
-  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-  EXPECT_EQ(1U, uncancelable_touch_moves_pending_ack_count());
-  EXPECT_FALSE(HasPendingAsyncTouchMove());
-  EXPECT_EQ(0U, queued_event_count());
-  EXPECT_EQ(WebInputEvent::TouchMove, sent_event().type());
-  EXPECT_NE(WebInputEvent::Blocking, sent_event().dispatchType);
-  EXPECT_EQ(1U, GetAndResetSentEventCount());
-  EXPECT_EQ(0U, GetAndResetAckedEventCount());
-}
-
-// Ensure that even when we receive the ack from render, we still need to wait
-// for the interval expires to send the next async touchmove once the scroll
-// starts.
-TEST_F(TouchEventQueueTest, DoNotIncreaseIfClientConsumeAsyncTouchMove) {
-  // Process a TouchStart
-  PressTouchPoint(0, 1);
-  EXPECT_EQ(1U, GetAndResetSentEventCount());
-  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-  EXPECT_EQ(1U, GetAndResetAckedEventCount());
-
-  // Initiate async touchmove dispatch after the start of a scroll sequence.
-  MoveTouchPoint(0, 0, 5);
-  WebGestureEvent followup_scroll(WebInputEvent::GestureScrollBegin,
-                                  WebInputEvent::NoModifiers,
-                                  WebInputEvent::TimeStampForTesting);
-  SetFollowupEvent(followup_scroll);
-  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-  EXPECT_EQ(1U, GetAndResetSentEventCount());
-  EXPECT_EQ(1U, GetAndResetAckedEventCount());
-
-  MoveTouchPoint(0, 0, 10);
-  followup_scroll.setType(WebInputEvent::GestureScrollUpdate);
-  SetFollowupEvent(followup_scroll);
-  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-  EXPECT_FALSE(HasPendingAsyncTouchMove());
-  EXPECT_EQ(1U, GetAndResetSentEventCount());
-  EXPECT_EQ(1U, GetAndResetAckedEventCount());
-
-  // Dispatch the touch move event when sufficient time has passed.
-  AdvanceTouchTime(kMinSecondsBetweenThrottledTouchmoves + 0.1);
-  MoveTouchPoint(0, 0, 40);
-  EXPECT_FALSE(HasPendingAsyncTouchMove());
-  EXPECT_NE(WebInputEvent::Blocking, sent_event().dispatchType);
-  // When we dispatch an async touchmove, we do not put it back to the queue
-  // any more and we will ack to client right away.
-  EXPECT_EQ(0U, queued_event_count());
-  EXPECT_EQ(1U, GetAndResetSentEventCount());
-  EXPECT_EQ(1U, GetAndResetAckedEventCount());
-  EXPECT_EQ(1U, uncancelable_touch_moves_pending_ack_count());
-
-  // We receive an ack back from render but the time interval is not expired,
-  // so we do not dispatch the touch move event.
-  SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-  EXPECT_EQ(0U, uncancelable_touch_moves_pending_ack_count());
-  MoveTouchPoint(0, 0, 50);
-  EXPECT_TRUE(HasPendingAsyncTouchMove());
-  EXPECT_EQ(0U, queued_event_count());
-  EXPECT_EQ(0U, GetAndResetSentEventCount());
-  EXPECT_EQ(1U, GetAndResetAckedEventCount());
-
-  // Dispatch the touch move when sufficient time has passed. Becasue the event
-  // is consumed by client already, we would not increase the count and ack to
-  // client again.
-  AdvanceTouchTime(kMinSecondsBetweenThrottledTouchmoves + 0.1);
-  SetSyncAckResult(INPUT_EVENT_ACK_STATE_CONSUMED);
-  MoveTouchPoint(0, 0, 50);
-  EXPECT_FALSE(HasPendingAsyncTouchMove());
-  EXPECT_EQ(WebInputEvent::TouchMove, sent_event().type());
-  EXPECT_NE(WebInputEvent::Blocking, sent_event().dispatchType);
-  EXPECT_EQ(0U, queued_event_count());
-  EXPECT_EQ(1U, GetAndResetSentEventCount());
-  EXPECT_EQ(1U, GetAndResetAckedEventCount());
-  EXPECT_EQ(0U, uncancelable_touch_moves_pending_ack_count());
-}
-
-TEST_F(TouchEventQueueTest, TouchAbsorptionWithConsumedFirstMove) {
+TEST_F(PassthroughTouchEventQueueTest, TouchAbsorptionWithConsumedFirstMove) {
   // Queue a TouchStart.
   PressTouchPoint(0, 1);
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   EXPECT_EQ(0U, queued_event_count());
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 
   MoveTouchPoint(0, 20, 5);
   SendGestureEvent(blink::WebInputEvent::GestureScrollBegin);
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
   EXPECT_EQ(0U, queued_event_count());
@@ skipping 12 matching lines @@
                                   WebInputEvent::NoModifiers,
                                   WebInputEvent::TimeStampForTesting);
   SetFollowupEvent(followup_scroll);
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   SendGestureEventAck(WebInputEvent::GestureScrollUpdate,
                       INPUT_EVENT_ACK_STATE_CONSUMED);
   EXPECT_EQ(0U, queued_event_count());
   EXPECT_EQ(WebInputEvent::Blocking, sent_event().dispatchType);
   EXPECT_EQ(1U, GetAndResetSentEventCount());
 
-  // Touch move event is throttled.
+  // Touch moves are sent right away.
   MoveTouchPoint(0, 60, 5);
-  EXPECT_EQ(0U, queued_event_count());
-  EXPECT_EQ(0U, GetAndResetSentEventCount());
+  EXPECT_EQ(1U, queued_event_count());
+  EXPECT_EQ(1U, GetAndResetSentEventCount());
 }
 
-TEST_F(TouchEventQueueTest, TouchStartCancelableDuringScroll) {
+TEST_F(PassthroughTouchEventQueueTest, TouchStartCancelableDuringScroll) {
   // Queue a touchstart and touchmove that go unconsumed, transitioning to an
   // active scroll sequence.
   PressTouchPoint(0, 1);
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   EXPECT_EQ(WebInputEvent::Blocking, sent_event().dispatchType);
   ASSERT_EQ(1U, GetAndResetSentEventCount());
 
   MoveTouchPoint(0, 20, 5);
   EXPECT_EQ(WebInputEvent::Blocking, sent_event().dispatchType);
   SendGestureEvent(blink::WebInputEvent::GestureScrollBegin);
@@ skipping 38 matching lines @@
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   EXPECT_NE(WebInputEvent::Blocking, sent_event().dispatchType);
   ASSERT_EQ(1U, GetAndResetSentEventCount());
 
   // The touchend will be uncancelable during an active scroll sequence.
   ReleaseTouchPoint(0);
   EXPECT_NE(WebInputEvent::Blocking, sent_event().dispatchType);
   ASSERT_EQ(1U, GetAndResetSentEventCount());
 }
 
-TEST_F(TouchEventQueueTest, UnseenTouchPointerIdsNotForwarded) {
+TEST_F(PassthroughTouchEventQueueTest, UnseenTouchPointerIdsNotForwarded) {
   SyntheticWebTouchEvent event;
   event.PressPoint(0, 0);
   SendTouchEvent(event);
   EXPECT_EQ(1U, GetAndResetSentEventCount());
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 
   // Give the touchmove a previously unseen pointer id; it should not be sent.
   int press_id = event.touches[0].id;
   event.MovePoint(0, 1, 1);
   event.touches[0].id = 7;
   SendTouchEvent(event);
   EXPECT_EQ(0U, GetAndResetSentEventCount());
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 
   // Give the touchmove a valid id; it should be sent.
   event.touches[0].id = press_id;
   SendTouchEvent(event);
   EXPECT_EQ(1U, GetAndResetSentEventCount());
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 
   // Do the same for release.
   event.ReleasePoint(0);
   event.touches[0].id = 11;
   SendTouchEvent(event);
   EXPECT_EQ(0U, GetAndResetSentEventCount());
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 
-  // Give the touchmove a valid id; it should be sent.
+  // Give the touchmove a valid id after release it shouldn't be sent.
   event.touches[0].id = press_id;
   SendTouchEvent(event);
-  EXPECT_EQ(1U, GetAndResetSentEventCount());
-  SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
+  EXPECT_EQ(0U, GetAndResetSentEventCount());
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 }
 
 // Tests that touch points states are correct in TouchMove events.
-TEST_F(TouchEventQueueTest, PointerStatesInTouchMove) {
+TEST_F(PassthroughTouchEventQueueTest, PointerStatesInTouchMove) {
   PressTouchPoint(1, 1);
   PressTouchPoint(2, 2);
   PressTouchPoint(3, 3);
+  EXPECT_EQ(3U, queued_event_count());
+  EXPECT_EQ(3U, GetAndResetSentEventCount());
   PressTouchPoint(4, 4);
-  EXPECT_EQ(4U, queued_event_count());
-  EXPECT_EQ(1U, GetAndResetSentEventCount());
 
   // Receive ACK for the first three touch-events.
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
   EXPECT_EQ(1U, queued_event_count());
 
   // Test current touches state before sending TouchMoves.
   const WebTouchEvent& event1 = sent_event();
   EXPECT_EQ(WebInputEvent::TouchStart, event1.type());
   EXPECT_EQ(WebTouchPoint::StateStationary, event1.touches[0].state);
   EXPECT_EQ(WebTouchPoint::StateStationary, event1.touches[1].state);
   EXPECT_EQ(WebTouchPoint::StateStationary, event1.touches[2].state);
   EXPECT_EQ(WebTouchPoint::StatePressed, event1.touches[3].state);
 
   // Move x-position for 1st touch, y-position for 2nd touch
   // and do not move other touches.
   MoveTouchPoints(0, 1.1f, 1.f, 1, 2.f, 20.001f);
   MoveTouchPoints(2, 3.f, 3.f, 3, 4.f, 4.f);
-  EXPECT_EQ(2U, queued_event_count());
+  EXPECT_EQ(3U, queued_event_count());
 
   // Receive an ACK for the last TouchPress event.
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
 
   // 1st TouchMove is sent. Test for touches state.
   const WebTouchEvent& event2 = sent_event();
   EXPECT_EQ(WebInputEvent::TouchMove, event2.type());
   EXPECT_EQ(WebTouchPoint::StateMoved, event2.touches[0].state);
   EXPECT_EQ(WebTouchPoint::StateMoved, event2.touches[1].state);
   EXPECT_EQ(WebTouchPoint::StateStationary, event2.touches[2].state);
@@ skipping 10 matching lines @@
   const WebTouchEvent& event3 = sent_event();
   EXPECT_EQ(WebInputEvent::TouchMove, event3.type());
   EXPECT_EQ(WebTouchPoint::StateStationary, event3.touches[0].state);
   EXPECT_EQ(WebTouchPoint::StateStationary, event3.touches[1].state);
   EXPECT_EQ(WebTouchPoint::StateStationary, event3.touches[2].state);
   EXPECT_EQ(WebTouchPoint::StateMoved, event3.touches[3].state);
 }
 
 // Tests that touch point state is correct in TouchMove events
 // when point properties other than position changed.
-TEST_F(TouchEventQueueTest, PointerStatesWhenOtherThanPositionChanged) {
+TEST_F(PassthroughTouchEventQueueTest,
+       PointerStatesWhenOtherThanPositionChanged) {
   PressTouchPoint(1, 1);
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
 
   // Default initial radiusX/Y is (1.f, 1.f).
   // Default initial rotationAngle is 1.f.
   // Default initial force is 1.f.
 
   // Change touch point radius only.
   ChangeTouchPointRadius(0, 1.5f, 1.f);
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
@@ skipping 20 matching lines @@
   const WebTouchEvent& event3 = sent_event();
   EXPECT_EQ(WebInputEvent::TouchMove, event3.type());
   EXPECT_EQ(WebTouchPoint::StateMoved, event3.touches[0].state);
 
   EXPECT_EQ(0U, queued_event_count());
   EXPECT_EQ(4U, GetAndResetSentEventCount());
   EXPECT_EQ(4U, GetAndResetAckedEventCount());
 }
 
 // Tests that TouchMoves are filtered when none of the points are changed.
-TEST_F(TouchEventQueueTest, FilterTouchMovesWhenNoPointerChanged) {
+TEST_F(PassthroughTouchEventQueueTest, FilterTouchMovesWhenNoPointerChanged) {
   PressTouchPoint(1, 1);
   PressTouchPoint(2, 2);
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
   EXPECT_EQ(0U, queued_event_count());
   EXPECT_EQ(2U, GetAndResetSentEventCount());
   EXPECT_EQ(2U, GetAndResetAckedEventCount());
 
   // Move 1st touch point.
   MoveTouchPoint(0, 10, 10);
   EXPECT_EQ(1U, queued_event_count());
 
   // TouchMove should be allowed and test for touches state.
   const WebTouchEvent& event1 = sent_event();
   EXPECT_EQ(WebInputEvent::TouchMove, event1.type());
   EXPECT_EQ(WebTouchPoint::StateMoved, event1.touches[0].state);
   EXPECT_EQ(WebTouchPoint::StateStationary, event1.touches[1].state);
   EXPECT_EQ(1U, GetAndResetSentEventCount());
   EXPECT_EQ(0U, GetAndResetAckedEventCount());
 
   // Do not really move any touch points, but use previous values.
   MoveTouchPoint(0, 10, 10);
   ChangeTouchPointRadius(1, 1, 1);
   MoveTouchPoint(1, 2, 2);
-  EXPECT_EQ(2U, queued_event_count());
+  EXPECT_EQ(4U, queued_event_count());
   EXPECT_EQ(0U, GetAndResetSentEventCount());
+  // The TouchMove but should be filtered when none of the touch points have
+  // changed but don't get acked right away.
+  EXPECT_EQ(0U, GetAndResetAckedEventCount());
 
   // Receive an ACK for 1st TouchMove.
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
 
-  // Tries to forward TouchMove but should be filtered
-  // when none of the touch points have changed.
   EXPECT_EQ(0U, queued_event_count());
   EXPECT_EQ(0U, GetAndResetSentEventCount());
   EXPECT_EQ(4U, GetAndResetAckedEventCount());
   EXPECT_EQ(INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS, acked_event_state());
 
   // Move 2nd touch point.
   MoveTouchPoint(1, 3, 3);
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
   EXPECT_EQ(0U, queued_event_count());
 
   // TouchMove should be allowed and test for touches state.
   const WebTouchEvent& event2 = sent_event();
   EXPECT_EQ(WebInputEvent::TouchMove, event2.type());
   EXPECT_EQ(WebTouchPoint::StateStationary, event2.touches[0].state);
   EXPECT_EQ(WebTouchPoint::StateMoved, event2.touches[1].state);
   EXPECT_EQ(1U, GetAndResetSentEventCount());
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 }
 
-// Tests that touch-scroll-notification is not pushed into an empty queue.
-TEST_F(TouchEventQueueTest, TouchScrollNotificationOrder_EmptyQueue) {
+// Tests that touch-scroll-notification is queued normally.
+TEST_F(PassthroughTouchEventQueueTest,
+       TouchScrollNotificationOrder_EmptyQueue) {
   PrependTouchScrollNotification();
 
   EXPECT_EQ(0U, GetAndResetAckedEventCount());
-  EXPECT_EQ(0U, queued_event_count());
-  EXPECT_EQ(0U, GetAndResetSentEventCount());
+  EXPECT_EQ(1U, queued_event_count());
+  EXPECT_EQ(1U, GetAndResetSentEventCount());
 }
 
-// Tests touch-scroll-notification firing order when the event is placed at the
-// end of touch queue because of a pending ack for the head of the queue.
-TEST_F(TouchEventQueueTest, TouchScrollNotificationOrder_EndOfQueue) {
+// Tests touch-scroll-notification firing is appended to the tail of sent
+// events since all events are sent right away.
+TEST_F(PassthroughTouchEventQueueTest,
+       TouchScrollNotificationOrder_EndOfQueue) {
   PressTouchPoint(1, 1);
 
   EXPECT_EQ(0U, GetAndResetAckedEventCount());
   EXPECT_EQ(1U, queued_event_count());
 
   // Send the touch-scroll-notification when 3 events are in the queue.
   PrependTouchScrollNotification();
 
   EXPECT_EQ(0U, GetAndResetAckedEventCount());
   EXPECT_EQ(2U, queued_event_count());
 
-  // Receive an ACK for the touchstart.
+  // Send ACKs.
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
-
-  EXPECT_EQ(1U, GetAndResetAckedEventCount());
-  EXPECT_EQ(WebInputEvent::TouchStart, acked_event().type());
-  EXPECT_EQ(1U, queued_event_count());
-
-  // Receive an ACK for the touch-scroll-notification.
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_IGNORED);
 
-  EXPECT_EQ(0U, GetAndResetAckedEventCount());
+  // Touch-scroll-start Ack is not reported to client.
+  EXPECT_EQ(1U, GetAndResetAckedEventCount());
   EXPECT_EQ(0U, queued_event_count());
 
   EXPECT_EQ(WebInputEvent::TouchStart, all_sent_events()[0].type());
   EXPECT_EQ(WebInputEvent::TouchScrollStarted, all_sent_events()[1].type());
   EXPECT_EQ(2U, GetAndResetSentEventCount());
 }
 
-// Tests touch-scroll-notification firing order when the event is placed in the
-// 2nd position in the touch queue between two events.
-TEST_F(TouchEventQueueTest, TouchScrollNotificationOrder_SecondPosition) {
-  PressTouchPoint(1, 1);
-  MoveTouchPoint(0, 5, 5);
-  ReleaseTouchPoint(0);
-
-  EXPECT_EQ(0U, GetAndResetAckedEventCount());
-  EXPECT_EQ(3U, queued_event_count());
-
-  // Send the touch-scroll-notification when 3 events are in the queue.
-  PrependTouchScrollNotification();
-
-  EXPECT_EQ(0U, GetAndResetAckedEventCount());
-  EXPECT_EQ(4U, queued_event_count());
-
-  // Receive an ACK for the touchstart.
-  SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
-
-  EXPECT_EQ(1U, GetAndResetAckedEventCount());
-  EXPECT_EQ(WebInputEvent::TouchStart, acked_event().type());
-  EXPECT_EQ(3U, queued_event_count());
-
-  // Receive an ACK for the touch-scroll-notification.
-  SendTouchEventAck(INPUT_EVENT_ACK_STATE_IGNORED);
-
-  EXPECT_EQ(0U, GetAndResetAckedEventCount());
-  EXPECT_EQ(2U, queued_event_count());
-
-  // Receive an ACK for the touchmove.
-  SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
-
-  EXPECT_EQ(1U, GetAndResetAckedEventCount());
-  EXPECT_EQ(WebInputEvent::TouchMove, acked_event().type());
-  EXPECT_EQ(1U, queued_event_count());
-
-  // Receive an ACK for the touchend.
-  SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
-
-  EXPECT_EQ(1U, GetAndResetAckedEventCount());
-  EXPECT_EQ(WebInputEvent::TouchEnd, acked_event().type());
-  EXPECT_EQ(0U, queued_event_count());
-
-  EXPECT_EQ(WebInputEvent::TouchStart, all_sent_events()[0].type());
-  EXPECT_EQ(WebInputEvent::TouchScrollStarted, all_sent_events()[1].type());
-  EXPECT_EQ(WebInputEvent::TouchMove, all_sent_events()[2].type());
-  EXPECT_EQ(WebInputEvent::TouchEnd, all_sent_events()[3].type());
-  EXPECT_EQ(4U, GetAndResetSentEventCount());
-}
-
 // Tests that if touchStartOrFirstTouchMove is correctly set up for touch
 // events.
-TEST_F(TouchEventQueueTest, TouchStartOrFirstTouchMove) {
+TEST_F(PassthroughTouchEventQueueTest, TouchStartOrFirstTouchMove) {
   PressTouchPoint(1, 1);
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
   EXPECT_EQ(WebInputEvent::TouchStart, sent_event().type());
   EXPECT_TRUE(sent_event().touchStartOrFirstTouchMove);
 
   MoveTouchPoint(0, 5, 5);
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
   EXPECT_EQ(WebInputEvent::TouchMove, sent_event().type());
   EXPECT_TRUE(sent_event().touchStartOrFirstTouchMove);
 
   MoveTouchPoint(0, 15, 15);
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
   EXPECT_EQ(WebInputEvent::TouchMove, sent_event().type());
   EXPECT_FALSE(sent_event().touchStartOrFirstTouchMove);
 
   ReleaseTouchPoint(0);
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
   EXPECT_EQ(WebInputEvent::TouchEnd, sent_event().type());
   EXPECT_FALSE(sent_event().touchStartOrFirstTouchMove);
 }
 
 }  // namespace content