Add a passthrough touch event queue.

content/browser/renderer_host/input/legacy_touch_event_queue_unittest.cc

 // Copyright 2013 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/legacy_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 LegacyTouchEventQueueTest : public testing::Test,
+                                  public TouchEventQueueClient {
  public:
-  TouchEventQueueTest()
+  LegacyTouchEventQueueTest()
       : acked_event_count_(0),
         last_acked_event_state_(INPUT_EVENT_ACK_STATE_UNKNOWN),
         slop_length_dips_(0) {}
 
-  ~TouchEventQueueTest() override {}
+  ~LegacyTouchEventQueueTest() 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 142 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();
@@ skipping 13 matching lines @@
   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_->size(); }
 
   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_;
   }
 
@@ skipping 32 matching lines @@
   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(LegacyTouchEventQueueTest, 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.
   MoveTouchPoint(0, 5, 5);
   EXPECT_EQ(2U, queued_event_count());
   EXPECT_EQ(0U, 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(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(LegacyTouchEventQueueTest, BasicMultiTouch) {
   const size_t kPointerCount = 10;
   for (float i = 0; i < kPointerCount; ++i)
     PressTouchPoint(i, i);
 
   EXPECT_EQ(1U, 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);
@@ skipping 25 matching lines @@
   // 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());
 }
 
 // Tests that the touch-queue continues delivering events for an active touch
 // sequence after all handlers are removed.
-TEST_F(TouchEventQueueTest, TouchesForwardedIfHandlerRemovedDuringSequence) {
+TEST_F(LegacyTouchEventQueueTest,
+       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 42 matching lines @@
 
   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(LegacyTouchEventQueueTest, 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(LegacyTouchEventQueueTest, 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());
@@ skipping 33 matching lines @@
   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(LegacyTouchEventQueueTest,
        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.
   MoveTouchPoint(0, 5, 5);
   EXPECT_EQ(2U, queued_event_count());
   EXPECT_EQ(0U, GetAndResetAckedEventCount());
   EXPECT_EQ(0U, 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(1U, queued_event_count());
 }
 
 // Tests that touch-events are coalesced properly in the queue.
-TEST_F(TouchEventQueueTest, Coalesce) {
+TEST_F(LegacyTouchEventQueueTest, 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());
@@ skipping 19 matching lines @@
   // 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) {
+TEST_F(LegacyTouchEventQueueTest, 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) {
+TEST_F(LegacyTouchEventQueueTest, 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);
@@ skipping 13 matching lines @@
   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(LegacyTouchEventQueueTest, 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) {
+TEST_F(LegacyTouchEventQueueTest, 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.
   MoveTouchPoint(0, 5, 5);
   EXPECT_EQ(0U, GetAndResetSentEventCount());
   EXPECT_EQ(2U, queued_event_count());
 
   // Receive an ACK for the first touch-event. This should release the queued
@@ skipping 43 matching lines @@
   // 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());
 }
 
-TEST_F(TouchEventQueueTest, ConsumerIgnoreMultiFinger) {
+TEST_F(LegacyTouchEventQueueTest, 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);
@@ skipping 33 matching lines @@
   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());
 }
 
 // Tests that touch-event's enqueued via a touch ack are properly handled.
-TEST_F(TouchEventQueueTest, AckWithFollowupEvents) {
+TEST_F(LegacyTouchEventQueueTest, 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(LegacyTouchEventQueueTest, 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(LegacyTouchEventQueueTest, 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(LegacyTouchEventQueueTest, 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(LegacyTouchEventQueueTest, 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());
@@ skipping 24 matching lines @@
   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(LegacyTouchEventQueueTest, 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(LegacyTouchEventQueueTest, 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(LegacyTouchEventQueueTest, 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(LegacyTouchEventQueueTest, 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(LegacyTouchEventQueueTest, 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(LegacyTouchEventQueueTest, 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(LegacyTouchEventQueueTest, 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(LegacyTouchEventQueueTest, 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(LegacyTouchEventQueueTest, 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(LegacyTouchEventQueueTest,
+       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(LegacyTouchEventQueueTest, 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(LegacyTouchEventQueueTest, 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(LegacyTouchEventQueueTest,
+       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(LegacyTouchEventQueueTest,
+       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(LegacyTouchEventQueueTest, 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) {
+TEST_F(LegacyTouchEventQueueTest, 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);
+    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());
+    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());
+    // 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) {
+TEST_F(LegacyTouchEventQueueTest, 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,
@@ skipping 166 matching lines @@
   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) {
+TEST_F(LegacyTouchEventQueueTest, 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);
@@ skipping 35 matching lines @@
   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) {
+TEST_F(LegacyTouchEventQueueTest, 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());
 
@@ skipping 61 matching lines @@
   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) {
+TEST_F(LegacyTouchEventQueueTest, 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,
@@ skipping 30 matching lines @@
   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) {
+TEST_F(LegacyTouchEventQueueTest, 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,
@@ skipping 20 matching lines @@
   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) {
+TEST_F(LegacyTouchEventQueueTest, 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,
@@ skipping 41 matching lines @@
   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) {
+TEST_F(LegacyTouchEventQueueTest, 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,
@@ skipping 38 matching lines @@
   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) {
+TEST_F(LegacyTouchEventQueueTest, 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,
@@ skipping 94 matching lines @@
   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) {
+TEST_F(LegacyTouchEventQueueTest, 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,
@@ skipping 41 matching lines @@
   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(LegacyTouchEventQueueTest, 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 18 matching lines @@
   EXPECT_EQ(0U, queued_event_count());
   EXPECT_EQ(WebInputEvent::Blocking, sent_event().dispatchType);
   EXPECT_EQ(1U, GetAndResetSentEventCount());
 
   // Touch move event is throttled.
   MoveTouchPoint(0, 60, 5);
   EXPECT_EQ(0U, queued_event_count());
   EXPECT_EQ(0U, GetAndResetSentEventCount());
 }
 
-TEST_F(TouchEventQueueTest, TouchStartCancelableDuringScroll) {
+TEST_F(LegacyTouchEventQueueTest, 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(LegacyTouchEventQueueTest, 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);
@@ skipping 18 matching lines @@
 
   // 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());
 }
 
 // Tests that touch points states are correct in TouchMove events.
-TEST_F(TouchEventQueueTest, PointerStatesInTouchMove) {
+TEST_F(LegacyTouchEventQueueTest, PointerStatesInTouchMove) {
   PressTouchPoint(1, 1);
   PressTouchPoint(2, 2);
   PressTouchPoint(3, 3);
   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);
@@ skipping 36 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(LegacyTouchEventQueueTest, 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(LegacyTouchEventQueueTest, 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);
@@ skipping 32 matching lines @@
   // 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) {
+TEST_F(LegacyTouchEventQueueTest, TouchScrollNotificationOrder_EmptyQueue) {
   PrependTouchScrollNotification();
 
   EXPECT_EQ(0U, GetAndResetAckedEventCount());
   EXPECT_EQ(0U, queued_event_count());
   EXPECT_EQ(0U, 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) {
+TEST_F(LegacyTouchEventQueueTest, 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());
@@ skipping 11 matching lines @@
   EXPECT_EQ(0U, 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) {
+TEST_F(LegacyTouchEventQueueTest, 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();
 
@@ skipping 29 matching lines @@
 
   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(LegacyTouchEventQueueTest, 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