Move the TouchEventQueue to be completely virtual.

content/browser/renderer_host/input/legacy_touch_event_queue.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 <utility>
 
 #include "base/auto_reset.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/trace_event/trace_event.h"
 #include "content/browser/renderer_host/input/timeout_monitor.h"
 #include "content/common/input/web_touch_event_traits.h"
@@ skipping 27 matching lines @@
 }
 
 bool ShouldTouchTriggerTimeout(const WebTouchEvent& event) {
   return (event.type() == WebInputEvent::TouchStart ||
           event.type() == WebInputEvent::TouchMove) &&
          event.dispatchType == WebInputEvent::Blocking;
 }
 
 // Compare all properties of touch points to determine the state.
 bool HasPointChanged(const WebTouchPoint& point_1,
-    const WebTouchPoint& point_2) {
+                     const WebTouchPoint& point_2) {
   DCHECK_EQ(point_1.id, point_2.id);
   if (point_1.screenPosition != point_2.screenPosition ||
       point_1.position != point_2.position ||
       point_1.radiusX != point_2.radiusX ||
       point_1.radiusY != point_2.radiusY ||
       point_1.rotationAngle != point_2.rotationAngle ||
-      point_1.force != point_2.force ||
-      point_1.tiltX != point_2.tiltX ||
+      point_1.force != point_2.force || point_1.tiltX != point_2.tiltX ||
       point_1.tiltY != point_2.tiltY) {
     return true;
   }
   return false;
 }
 
 }  // namespace
 
-
 // Cancels a touch sequence if a touchstart or touchmove ack response is
 // sufficiently delayed.
-class TouchEventQueue::TouchTimeoutHandler {
+class LegacyTouchEventQueue::TouchTimeoutHandler {
  public:
-  TouchTimeoutHandler(TouchEventQueue* touch_queue,
+  TouchTimeoutHandler(LegacyTouchEventQueue* touch_queue,
                       base::TimeDelta desktop_timeout_delay,
                       base::TimeDelta mobile_timeout_delay)
       : touch_queue_(touch_queue),
         desktop_timeout_delay_(desktop_timeout_delay),
         mobile_timeout_delay_(mobile_timeout_delay),
         use_mobile_timeout_(false),
         pending_ack_state_(PENDING_ACK_NONE),
         timeout_monitor_(base::Bind(&TouchTimeoutHandler::OnTimeOut,
                                     base::Unretained(this))),
         enabled_(true),
         enabled_for_current_sequence_(false),
         sequence_awaiting_uma_update_(false),
         sequence_using_mobile_timeout_(false) {
     SetUseMobileTimeout(false);
   }
 
-  ~TouchTimeoutHandler() {
-    LogSequenceEndForUMAIfNecessary(false);
-  }
+  ~TouchTimeoutHandler() { LogSequenceEndForUMAIfNecessary(false); }
 
   void StartIfNecessary(const TouchEventWithLatencyInfo& event) {
     if (pending_ack_state_ != PENDING_ACK_NONE)
       return;
 
     if (!enabled_)
       return;
 
     const base::TimeDelta timeout_delay = GetTimeoutDelay();
     if (timeout_delay.is_zero())
@@ skipping 72 matching lines @@
       timeout_monitor_.Stop();
     }
   }
 
   void SetUseMobileTimeout(bool use_mobile_timeout) {
     use_mobile_timeout_ = use_mobile_timeout;
   }
 
   bool IsTimeoutTimerRunning() const { return timeout_monitor_.IsRunning(); }
 
-  bool IsEnabled() const {
-    return enabled_ && !GetTimeoutDelay().is_zero();
-  }
+  bool IsEnabled() const { return enabled_ && !GetTimeoutDelay().is_zero(); }
 
  private:
   enum PendingAckState {
     PENDING_ACK_NONE,
     PENDING_ACK_ORIGINAL_EVENT,
     PENDING_ACK_CANCEL_EVENT,
   };
 
   void OnTimeOut() {
     LogSequenceEndForUMAIfNecessary(true);
@@ skipping 14 matching lines @@
     DCHECK_NE(pending_ack_state_, new_pending_ack_state);
     switch (new_pending_ack_state) {
       case PENDING_ACK_ORIGINAL_EVENT:
         DCHECK_EQ(pending_ack_state_, PENDING_ACK_NONE);
         TRACE_EVENT_ASYNC_BEGIN0("input", "TouchEventTimeout", this);
         break;
       case PENDING_ACK_CANCEL_EVENT:
         DCHECK_EQ(pending_ack_state_, PENDING_ACK_ORIGINAL_EVENT);
         DCHECK(!timeout_monitor_.IsRunning());
         DCHECK(touch_queue_->empty());
-        TRACE_EVENT_ASYNC_STEP_INTO0(
-            "input", "TouchEventTimeout", this, "CancelEvent");
+        TRACE_EVENT_ASYNC_STEP_INTO0("input", "TouchEventTimeout", this,
+                                     "CancelEvent");
         break;
       case PENDING_ACK_NONE:
         DCHECK(!timeout_monitor_.IsRunning());
         DCHECK(touch_queue_->empty());
         TRACE_EVENT_ASYNC_END0("input", "TouchEventTimeout", this);
         break;
     }
     pending_ack_state_ = new_pending_ack_state;
   }
 
@@ skipping 18 matching lines @@
   }
 
   base::TimeDelta GetTimeoutDelay() const {
     return use_mobile_timeout_ ? mobile_timeout_delay_ : desktop_timeout_delay_;
   }
 
   bool HasTimeoutEvent() const {
     return pending_ack_state_ != PENDING_ACK_NONE;
   }
 
-  TouchEventQueue* touch_queue_;
+  LegacyTouchEventQueue* touch_queue_;
 
   // How long to wait on a touch ack before cancelling the touch sequence.
   const base::TimeDelta desktop_timeout_delay_;
   const base::TimeDelta mobile_timeout_delay_;
   bool use_mobile_timeout_;
 
   // The touch event source for which we expect the next ack.
   PendingAckState pending_ack_state_;
 
   // The event for which the ack timeout is triggered.
   TouchEventWithLatencyInfo timeout_event_;
 
   // Provides timeout-based callback behavior.
   TimeoutMonitor timeout_monitor_;
 
   bool enabled_;
   bool enabled_for_current_sequence_;
 
   // Bookkeeping to classify and log whether a touch sequence times out.
   bool sequence_awaiting_uma_update_;
   bool sequence_using_mobile_timeout_;
 };
 
 // Provides touchmove slop suppression for a touch sequence until a
 // (unprevented) touch will trigger immediate scrolling.
-class TouchEventQueue::TouchMoveSlopSuppressor {
+class LegacyTouchEventQueue::TouchMoveSlopSuppressor {

[tdresser, 2017/01/27 15:11:56]

We'll need to pull this out to enable code sharing with the
PassThroughTouchEvent queue, right?

It might make sense to do that now (but if you'd prefer to wait, fine by me).

[dtapuska, 2017/01/27 15:57:38]

Nope I think implementing this on main thread first is easiest.

  public:
   TouchMoveSlopSuppressor() : suppressing_touchmoves_(false) {}
 
   bool FilterEvent(const WebTouchEvent& event) {
     if (WebTouchEventTraits::IsTouchSequenceStart(event)) {
       suppressing_touchmoves_ = true;
       touch_start_location_ = gfx::PointF(event.touches[0].position);
     }
 
     if (event.type() == WebInputEvent::TouchEnd ||
         event.type() == WebInputEvent::TouchCancel)
       suppressing_touchmoves_ = false;
 
     if (event.type() != WebInputEvent::TouchMove)
       return false;
 
     if (suppressing_touchmoves_) {
       if (event.touchesLength > 1) {
         suppressing_touchmoves_ = false;
       } else if (event.movedBeyondSlopRegion) {
         suppressing_touchmoves_ = false;
       } else {
         // No sane slop region should be larger than 60 DIPs.
-        DCHECK_LT((gfx::PointF(event.touches[0].position) -
-                   touch_start_location_).LengthSquared(),
-                  kMaxConceivablePlatformSlopRegionLengthDipsSquared);
+        DCHECK_LT(
+            (gfx::PointF(event.touches[0].position) - touch_start_location_)
+                .LengthSquared(),
+            kMaxConceivablePlatformSlopRegionLengthDipsSquared);
       }
     }
 
     return suppressing_touchmoves_;
   }
 
   void ConfirmTouchEvent(InputEventAckState ack_result) {
     if (ack_result == INPUT_EVENT_ACK_STATE_CONSUMED)
       suppressing_touchmoves_ = false;
   }
@@ skipping 13 matching lines @@
 // This class represents a single coalesced touch event. However, it also keeps
 // track of all the original touch-events that were coalesced into a single
 // event. The coalesced event is forwarded to the renderer, while the original
 // touch-events are sent to the Client (on ACK for the coalesced event) so that
 // the Client receives the event with their original timestamp.
 class CoalescedWebTouchEvent {
  public:
   CoalescedWebTouchEvent(const TouchEventWithLatencyInfo& event,
                          bool suppress_client_ack)
       : coalesced_event_(event), suppress_client_ack_(suppress_client_ack) {
-    TRACE_EVENT_ASYNC_BEGIN0("input", "TouchEventQueue::QueueEvent", this);
+    TRACE_EVENT_ASYNC_BEGIN0("input", "LegacyTouchEventQueue::QueueEvent",
+                             this);
   }
 
   ~CoalescedWebTouchEvent() {
-    TRACE_EVENT_ASYNC_END0("input", "TouchEventQueue::QueueEvent", this);
+    TRACE_EVENT_ASYNC_END0("input", "LegacyTouchEventQueue::QueueEvent", this);
   }
 
   // Coalesces the event with the existing event if possible. Returns whether
   // the event was coalesced.
   bool CoalesceEventIfPossible(
       const TouchEventWithLatencyInfo& event_with_latency) {
     if (suppress_client_ack_)
       return false;
 
     if (!coalesced_event_.CanCoalesceWith(event_with_latency))
       return false;
 
     // Addition of the first event to |uncoaleseced_events_to_ack_| is deferred
     // until the first coalesced event, optimizing the (common) case where the
     // event is not coalesced at all.
     if (uncoaleseced_events_to_ack_.empty())
       uncoaleseced_events_to_ack_.push_back(coalesced_event_);
 
-    TRACE_EVENT_INSTANT0(
-        "input", "TouchEventQueue::MoveCoalesced", TRACE_EVENT_SCOPE_THREAD);
+    TRACE_EVENT_INSTANT0("input", "LegacyTouchEventQueue::MoveCoalesced",
+                         TRACE_EVENT_SCOPE_THREAD);
     coalesced_event_.CoalesceWith(event_with_latency);
     uncoaleseced_events_to_ack_.push_back(event_with_latency);
     DCHECK_GE(uncoaleseced_events_to_ack_.size(), 2U);
     return true;
   }
 
   void DispatchAckToClient(InputEventAckState ack_result,
                            const ui::LatencyInfo* optional_latency_info,
                            TouchEventQueueClient* client) {
     DCHECK(client);
     if (suppress_client_ack_)
       return;
 
     if (uncoaleseced_events_to_ack_.empty()) {
       if (optional_latency_info)
         coalesced_event_.latency.AddNewLatencyFrom(*optional_latency_info);
       client->OnTouchEventAck(coalesced_event_, ack_result);
       return;
     }
 
     DCHECK_GE(uncoaleseced_events_to_ack_.size(), 2U);
     for (WebTouchEventWithLatencyList::iterator
              iter = uncoaleseced_events_to_ack_.begin(),
              end = uncoaleseced_events_to_ack_.end();
-         iter != end;
-         ++iter) {
+         iter != end; ++iter) {
       if (optional_latency_info)
         iter->latency.AddNewLatencyFrom(*optional_latency_info);
       client->OnTouchEventAck(*iter, ack_result);
     }
   }
 
   const TouchEventWithLatencyInfo& coalesced_event() const {
     return coalesced_event_;
   }
 
  private:
   // This is the event that is forwarded to the renderer.
   TouchEventWithLatencyInfo coalesced_event_;
 
   // This is the list of the original events that were coalesced, each requiring
   // future ack dispatch to the client.
   // Note that this will be empty if no coalescing has occurred.
   typedef std::vector<TouchEventWithLatencyInfo> WebTouchEventWithLatencyList;
   WebTouchEventWithLatencyList uncoaleseced_events_to_ack_;
 
   bool suppress_client_ack_;
 
   DISALLOW_COPY_AND_ASSIGN(CoalescedWebTouchEvent);
 };
 
-TouchEventQueue::Config::Config()
-    : desktop_touch_ack_timeout_delay(base::TimeDelta::FromMilliseconds(200)),
-      mobile_touch_ack_timeout_delay(base::TimeDelta::FromMilliseconds(1000)),
-      touch_ack_timeout_supported(false) {
-}
-
-TouchEventQueue::TouchEventQueue(TouchEventQueueClient* client,
-                                 const Config& config)
-    : client_(client),
+LegacyTouchEventQueue::LegacyTouchEventQueue(TouchEventQueueClient* client,
+                                             const Config& config)
+    : TouchEventQueue(client, config),
       dispatching_touch_ack_(false),
       dispatching_touch_(false),
       has_handlers_(true),
       has_handler_for_current_sequence_(false),
       drop_remaining_touches_in_sequence_(false),
       touchmove_slop_suppressor_(new TouchMoveSlopSuppressor),
       send_touch_events_async_(false),
       last_sent_touch_timestamp_sec_(0) {
-  DCHECK(client);
   if (config.touch_ack_timeout_supported) {
     timeout_handler_.reset(
-        new TouchTimeoutHandler(this,
-                                config.desktop_touch_ack_timeout_delay,
+        new TouchTimeoutHandler(this, config.desktop_touch_ack_timeout_delay,
                                 config.mobile_touch_ack_timeout_delay));
   }
 }
 
-TouchEventQueue::~TouchEventQueue() {
-}
+LegacyTouchEventQueue::~LegacyTouchEventQueue() {}
 
-void TouchEventQueue::QueueEvent(const TouchEventWithLatencyInfo& event) {
-  TRACE_EVENT0("input", "TouchEventQueue::QueueEvent");
+void LegacyTouchEventQueue::QueueEvent(const TouchEventWithLatencyInfo& event) {
+  TRACE_EVENT0("input", "LegacyTouchEventQueue::QueueEvent");
 
   // If the queueing of |event| was triggered by an ack dispatch, defer
   // processing the event until the dispatch has finished.
   if (touch_queue_.empty() && !dispatching_touch_ack_) {
     // Optimization of the case without touch handlers.  Removing this path
     // yields identical results, but this avoids unnecessary allocations.
     PreFilterResult filter_result = FilterBeforeForwarding(event.event);
     if (filter_result != FORWARD_TO_RENDERER) {
       client_->OnFilteringTouchEvent(event.event);
       client_->OnTouchEventAck(event,
@@ skipping 15 matching lines @@
   // also a touch-move, then the events can be coalesced into a single event.
   if (touch_queue_.size() > 1) {
     CoalescedWebTouchEvent* last_event = touch_queue_.back().get();
     if (last_event->CoalesceEventIfPossible(event))
       return;
   }
   touch_queue_.push_back(
       base::MakeUnique<CoalescedWebTouchEvent>(event, false));
 }
 
-void TouchEventQueue::PrependTouchScrollNotification() {
-  TRACE_EVENT0("input", "TouchEventQueue::PrependTouchScrollNotification");
+void LegacyTouchEventQueue::PrependTouchScrollNotification() {
+  TRACE_EVENT0("input",
+               "LegacyTouchEventQueue::PrependTouchScrollNotification");
 
   // The queue should have an in-flight event when this method is called because
   // this method is triggered by InputRouterImpl::SendGestureEvent, which is
-  // triggered by TouchEventQueue::AckTouchEventToClient, which has just
+  // triggered by LegacyTouchEventQueue::AckTouchEventToClient, which has just
   // received an ack for the in-flight event. We leave the head of the queue
   // untouched since it is the in-flight event.
   //
   // However, for the (integration) tests in RenderWidgetHostTest that trigger
   // this method indirectly, they push the TouchScrollStarted event into
   // TouchEventQueue without any way to dispatch it. Below we added a check for
   // non-empty queue to keep those tests as-is w/o exposing internals of this
   // class all the way up.
   if (!touch_queue_.empty()) {
     TouchEventWithLatencyInfo touch(
         WebInputEvent::TouchScrollStarted, WebInputEvent::NoModifiers,
         ui::EventTimeStampToSeconds(ui::EventTimeForNow()), LatencyInfo());
     touch.event.dispatchType = WebInputEvent::EventNonBlocking;
 
     auto it = touch_queue_.begin();
     DCHECK(it != touch_queue_.end());
     touch_queue_.insert(++it,
                         base::MakeUnique<CoalescedWebTouchEvent>(touch, false));
   }
 }
 
-void TouchEventQueue::ProcessTouchAck(InputEventAckState ack_result,
-                                      const LatencyInfo& latency_info,
-                                      const uint32_t unique_touch_event_id) {
-  TRACE_EVENT0("input", "TouchEventQueue::ProcessTouchAck");
+void LegacyTouchEventQueue::ProcessTouchAck(
+    InputEventAckState ack_result,
+    const LatencyInfo& latency_info,
+    const uint32_t unique_touch_event_id) {
+  TRACE_EVENT0("input", "LegacyTouchEventQueue::ProcessTouchAck");
 
   // We receive an ack for async touchmove from render.
   if (!ack_pending_async_touchmove_ids_.empty() &&
       ack_pending_async_touchmove_ids_.front() == unique_touch_event_id) {
     // Remove the first touchmove from the ack_pending_async_touchmove queue.
     ack_pending_async_touchmove_ids_.pop_front();
     // Send the next pending async touch move once we receive all acks back.
     if (pending_async_touchmove_ && ack_pending_async_touchmove_ids_.empty()) {
       DCHECK(touch_queue_.empty());
 
@@ skipping 23 matching lines @@
   // when, for example, A is acked from renderer but B isn't, so the ack for B
   // is synthesized "locally" in InputRouter.
   //
   // TODO(crbug.com/600773): Bring the id checks back when dispatch triggering
   // is sane.
 
   PopTouchEventToClient(ack_result, latency_info);
   TryForwardNextEventToRenderer();
 }
 
-void TouchEventQueue::TryForwardNextEventToRenderer() {
+void LegacyTouchEventQueue::TryForwardNextEventToRenderer() {
   DCHECK(!dispatching_touch_ack_);
   // If there are queued touch events, then try to forward them to the renderer
   // immediately, or ACK the events back to the client if appropriate.
   while (!touch_queue_.empty()) {
     const WebTouchEvent& event = touch_queue_.front()->coalesced_event().event;
     PreFilterResult filter_result = FilterBeforeForwarding(event);
     if (filter_result != FORWARD_TO_RENDERER)
       client_->OnFilteringTouchEvent(event);
     switch (filter_result) {
       case ACK_WITH_NO_CONSUMER_EXISTS:
         PopTouchEventToClient(INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS);
         break;
       case ACK_WITH_NOT_CONSUMED:
         PopTouchEventToClient(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
         break;
       case FORWARD_TO_RENDERER:
         ForwardNextEventToRenderer();
         return;
     }
   }
 }
 
-void TouchEventQueue::ForwardNextEventToRenderer() {
-  TRACE_EVENT0("input", "TouchEventQueue::ForwardNextEventToRenderer");
+void LegacyTouchEventQueue::ForwardNextEventToRenderer() {
+  TRACE_EVENT0("input", "LegacyTouchEventQueue::ForwardNextEventToRenderer");
 
   DCHECK(!empty());
   DCHECK(!dispatching_touch_);
   TouchEventWithLatencyInfo touch = touch_queue_.front()->coalesced_event();
 
   if (send_touch_events_async_ &&
       touch.event.type() == WebInputEvent::TouchMove) {
     // Throttling touchmove's in a continuous touchmove stream while scrolling
     // reduces the risk of jank. However, it's still important that the web
     // application be sent touches at key points in the gesture stream,
@@ skipping 47 matching lines @@
   // Note: Touchstart events are marked cancelable to allow transitions between
   // platform scrolling and JS pinching. Touchend events, however, remain
   // uncancelable, mitigating the risk of jank when transitioning to a fling.
   if (send_touch_events_async_ &&
       touch.event.type() != WebInputEvent::TouchStart)
     touch.event.dispatchType = WebInputEvent::EventNonBlocking;
 
   SendTouchEventImmediately(&touch);
 }
 
-void TouchEventQueue::FlushPendingAsyncTouchmove() {
+void LegacyTouchEventQueue::FlushPendingAsyncTouchmove() {
   DCHECK(!dispatching_touch_);
   std::unique_ptr<TouchEventWithLatencyInfo> touch =
       std::move(pending_async_touchmove_);
   touch->event.dispatchType = WebInputEvent::EventNonBlocking;
   touch_queue_.push_front(
       base::MakeUnique<CoalescedWebTouchEvent>(*touch, true));
   SendTouchEventImmediately(touch.get());
 }
 
-void TouchEventQueue::OnGestureScrollEvent(
+void LegacyTouchEventQueue::OnGestureScrollEvent(
     const GestureEventWithLatencyInfo& gesture_event) {
   if (gesture_event.event.type() == blink::WebInputEvent::GestureScrollBegin) {
     if (has_handler_for_current_sequence_ &&
         !drop_remaining_touches_in_sequence_) {
       DCHECK(!touchmove_slop_suppressor_->suppressing_touchmoves())
-          <<  "A touch handler should be offered a touchmove before scrolling.";
+          << "A touch handler should be offered a touchmove before scrolling.";
     }
 
     pending_async_touchmove_.reset();
 
     return;
   }
 
   if (gesture_event.event.type() == blink::WebInputEvent::GestureScrollUpdate &&
       gesture_event.event.resendingPluginId == -1) {
     send_touch_events_async_ = true;
   }
 }
 
-void TouchEventQueue::OnGestureEventAck(
+void LegacyTouchEventQueue::OnGestureEventAck(
     const GestureEventWithLatencyInfo& event,
     InputEventAckState ack_result) {
   // Throttle sending touchmove events as long as the scroll events are handled.
   // Note that there's no guarantee that this ACK is for the most recent
   // gesture event (or even part of the current sequence).  Worst case, the
   // delay in updating the absorption state will result in minor UI glitches.
   // A valid |pending_async_touchmove_| will be flushed when the next event is
   // forwarded. Scroll updates that are being resent from a GuestView are
   // ignored.
   if (event.event.type() == blink::WebInputEvent::GestureScrollUpdate &&
       event.event.resendingPluginId == -1) {
     send_touch_events_async_ = (ack_result == INPUT_EVENT_ACK_STATE_CONSUMED);
   }
 }
 
-void TouchEventQueue::OnHasTouchEventHandlers(bool has_handlers) {
+void LegacyTouchEventQueue::OnHasTouchEventHandlers(bool has_handlers) {
   DCHECK(!dispatching_touch_ack_);
   DCHECK(!dispatching_touch_);
   has_handlers_ = has_handlers;
 }
 
-bool TouchEventQueue::IsPendingAckTouchStart() const {
+bool LegacyTouchEventQueue::IsPendingAckTouchStart() const {
   DCHECK(!dispatching_touch_ack_);
   if (touch_queue_.empty())
     return false;
 
   const blink::WebTouchEvent& event =
       touch_queue_.front()->coalesced_event().event;
   return (event.type() == WebInputEvent::TouchStart);
 }
 
-void TouchEventQueue::SetAckTimeoutEnabled(bool enabled) {
+void LegacyTouchEventQueue::SetAckTimeoutEnabled(bool enabled) {
   if (timeout_handler_)
     timeout_handler_->SetEnabled(enabled);
 }
 
-void TouchEventQueue::SetIsMobileOptimizedSite(bool mobile_optimized_site) {
+void LegacyTouchEventQueue::SetIsMobileOptimizedSite(
+    bool mobile_optimized_site) {
   if (timeout_handler_)
     timeout_handler_->SetUseMobileTimeout(mobile_optimized_site);
 }
 
-bool TouchEventQueue::IsAckTimeoutEnabled() const {
+bool LegacyTouchEventQueue::IsAckTimeoutEnabled() const {
   return timeout_handler_ && timeout_handler_->IsEnabled();
 }
 
-bool TouchEventQueue::HasPendingAsyncTouchMoveForTesting() const {
+bool LegacyTouchEventQueue::Empty() const {
+  return touch_queue_.empty();
+}
+
+bool LegacyTouchEventQueue::HasPendingAsyncTouchMoveForTesting() const {
   return !!pending_async_touchmove_;
 }
 
-bool TouchEventQueue::IsTimeoutRunningForTesting() const {
+bool LegacyTouchEventQueue::IsTimeoutRunningForTesting() const {
   return timeout_handler_ && timeout_handler_->IsTimeoutTimerRunning();
 }
 
 const TouchEventWithLatencyInfo&
-TouchEventQueue::GetLatestEventForTesting() const {
+LegacyTouchEventQueue::GetLatestEventForTesting() const {
   return touch_queue_.back()->coalesced_event();
 }
 
-void TouchEventQueue::FlushQueue() {
+void LegacyTouchEventQueue::FlushQueue() {
   DCHECK(!dispatching_touch_ack_);
   DCHECK(!dispatching_touch_);
   pending_async_touchmove_.reset();
   drop_remaining_touches_in_sequence_ = true;
   while (!touch_queue_.empty())
     PopTouchEventToClient(INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS);
 }
 
-void TouchEventQueue::PopTouchEventToClient(InputEventAckState ack_result) {
+void LegacyTouchEventQueue::PopTouchEventToClient(
+    InputEventAckState ack_result) {
   AckTouchEventToClient(ack_result, nullptr);
 }
 
-void TouchEventQueue::PopTouchEventToClient(
+void LegacyTouchEventQueue::PopTouchEventToClient(
     InputEventAckState ack_result,
     const LatencyInfo& renderer_latency_info) {
   AckTouchEventToClient(ack_result, &renderer_latency_info);
 }
 
-void TouchEventQueue::AckTouchEventToClient(
+void LegacyTouchEventQueue::AckTouchEventToClient(
     InputEventAckState ack_result,
     const ui::LatencyInfo* optional_latency_info) {
   DCHECK(!dispatching_touch_ack_);
   if (touch_queue_.empty()) {
     NOTREACHED() << "Too many acks";
     return;
   }
   std::unique_ptr<CoalescedWebTouchEvent> acked_event =
       std::move(touch_queue_.front());
   DCHECK(acked_event);
 
   UpdateTouchConsumerStates(acked_event->coalesced_event().event, ack_result);
 
   // Note that acking the touch-event may result in multiple gestures being sent
   // to the renderer, or touch-events being queued.
   base::AutoReset<bool> dispatching_touch_ack(&dispatching_touch_ack_, true);
 
   // Skip ack for TouchScrollStarted since it was synthesized within the queue.
   if (acked_event->coalesced_event().event.type() !=
       WebInputEvent::TouchScrollStarted) {
     acked_event->DispatchAckToClient(ack_result, optional_latency_info,
                                      client_);
   }
 
   touch_queue_.pop_front();
 }
 
-void TouchEventQueue::SendTouchEventImmediately(
+void LegacyTouchEventQueue::SendTouchEventImmediately(
     TouchEventWithLatencyInfo* touch) {
   // TODO(crbug.com/600773): Hack to avoid cyclic reentry to this method.
   if (dispatching_touch_)
     return;
 
   if (touch->event.type() == WebInputEvent::TouchStart)
     touch->event.touchStartOrFirstTouchMove = true;
 
   // For touchmove events, compare touch points position from current event
   // to last sent event and update touch points state.
   if (touch->event.type() == WebInputEvent::TouchMove) {
     CHECK(last_sent_touchevent_);
     if (last_sent_touchevent_->type() == WebInputEvent::TouchStart)
       touch->event.touchStartOrFirstTouchMove = true;
     for (unsigned int i = 0; i < last_sent_touchevent_->touchesLength; ++i) {
-      const WebTouchPoint& last_touch_point =
-          last_sent_touchevent_->touches[i];
+      const WebTouchPoint& last_touch_point = last_sent_touchevent_->touches[i];
       // Touches with same id may not have same index in Touches array.
       for (unsigned int j = 0; j < touch->event.touchesLength; ++j) {
         const WebTouchPoint& current_touchmove_point = touch->event.touches[j];
         if (current_touchmove_point.id != last_touch_point.id)
           continue;
 
         if (!HasPointChanged(last_touch_point, current_touchmove_point))
           touch->event.touches[j].state = WebTouchPoint::StateStationary;
 
         break;
@@ skipping 27 matching lines @@
       PopTouchEventToClient(INPUT_EVENT_ACK_STATE_IGNORED);
       TryForwardNextEventToRenderer();
       return;
     }
 
     if (timeout_handler_)
       timeout_handler_->StartIfNecessary(*touch);
   }
 }
 
-TouchEventQueue::PreFilterResult
-TouchEventQueue::FilterBeforeForwarding(const WebTouchEvent& event) {
+LegacyTouchEventQueue::PreFilterResult
+LegacyTouchEventQueue::FilterBeforeForwarding(const WebTouchEvent& event) {
   if (event.type() == WebInputEvent::TouchScrollStarted)
     return FORWARD_TO_RENDERER;
 
   if (WebTouchEventTraits::IsTouchSequenceStart(event)) {
     has_handler_for_current_sequence_ = false;
     send_touch_events_async_ = false;
     pending_async_touchmove_.reset();
     last_sent_touchevent_.reset();
 
     touch_sequence_start_position_ = gfx::PointF(event.touches[0].position);
@@ skipping 45 matching lines @@
         // even though none of the pointers have not changed in real.
         // Forward these events when at least one pointer has changed.
         if (HasPointChanged(last_sent_touchevent_->touches[j], point))
           return FORWARD_TO_RENDERER;
 
         // This is a TouchMove event for which we have yet to find a
         // non-stationary pointer. Continue checking the next pointers
         // in the |event|.
         break;
       }
-
     }
   }
 
   return ACK_WITH_NO_CONSUMER_EXISTS;
 }
 
-void TouchEventQueue::UpdateTouchConsumerStates(const WebTouchEvent& event,
-                                                InputEventAckState ack_result) {
+void LegacyTouchEventQueue::UpdateTouchConsumerStates(
+    const WebTouchEvent& event,
+    InputEventAckState ack_result) {
   if (event.type() == WebInputEvent::TouchStart) {
     if (ack_result == INPUT_EVENT_ACK_STATE_CONSUMED)
       send_touch_events_async_ = false;
     has_handler_for_current_sequence_ |=
         ack_result != INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS;
   } else if (WebTouchEventTraits::IsTouchSequenceEnd(event)) {
     has_handler_for_current_sequence_ = false;
   }
 }
 
 }  // namespace content