Remove the touch ack timeout handler out of the legacy touch event queue.

content/browser/renderer_host/input/legacy_touch_event_queue.h

 // 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.
 
 #ifndef CONTENT_BROWSER_RENDERER_HOST_INPUT_LEGACY_TOUCH_EVENT_QUEUE_H_
 #define CONTENT_BROWSER_RENDERER_HOST_INPUT_LEGACY_TOUCH_EVENT_QUEUE_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <deque>
 #include <list>
 #include <memory>
 
 #include "base/macros.h"
 #include "base/time/time.h"
 #include "content/browser/renderer_host/event_with_latency_info.h"
 #include "content/browser/renderer_host/input/touch_event_queue.h"
 #include "content/common/content_export.h"
 #include "content/common/input/input_event_ack_state.h"
 #include "third_party/WebKit/public/platform/WebInputEvent.h"
 #include "ui/gfx/geometry/point_f.h"
 
 namespace content {
 
 class CoalescedWebTouchEvent;
+class TouchTimeoutHandler;
 
 // A queue for throttling and coalescing touch-events.
 class CONTENT_EXPORT LegacyTouchEventQueue : public TouchEventQueue {
  public:
   // The |client| must outlive the LegacyTouchEventQueue.
   LegacyTouchEventQueue(TouchEventQueueClient* client, const Config& config);
 
   ~LegacyTouchEventQueue() override;
 
   // Adds an event to the queue. The event may be coalesced with previously
@@ skipping 51 matching lines @@
 
   size_t size() const { return touch_queue_.size(); }
 
   bool has_handlers() const { return has_handlers_; }
 
   size_t uncancelable_touch_moves_pending_ack_count() const {
     return ack_pending_async_touchmove_ids_.size();
   }
 
  private:
-  class TouchTimeoutHandler;
-  friend class TouchTimeoutHandler;
   friend class TouchEventQueueTest;
 
   bool HasPendingAsyncTouchMoveForTesting() const;
   bool IsTimeoutRunningForTesting() const;
   const TouchEventWithLatencyInfo& GetLatestEventForTesting() const;
 
   // Empties the queue of touch events. This may result in any number of gesture
   // events being sent to the renderer.
-  void FlushQueue();
+  void FlushQueue() override;
 
   // Walks the queue, checking each event with |FilterBeforeForwarding()|.
   // If allowed, forwards the touch event and stops processing further events.
   // Otherwise, acks the event with |INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS|.
   void TryForwardNextEventToRenderer();
 
   // Forwards the event at the head of the queue to the renderer.
   void ForwardNextEventToRenderer();
 
   // Pops the touch-event from the head of the queue and acks it to the client.
   void PopTouchEventToClient(InputEventAckState ack_result);
 
   // Pops the touch-event from the top of the queue and acks it to the client,
   // updating the event with |renderer_latency_info|.
   void PopTouchEventToClient(InputEventAckState ack_result,
                              const ui::LatencyInfo& renderer_latency_info);
 
   // Ack all coalesced events at the head of the queue to the client with
   // |ack_result|, updating the acked events with |optional_latency_info| if it
   // exists, and popping the head of the queue.
   void AckTouchEventToClient(InputEventAckState ack_result,
                              const ui::LatencyInfo* optional_latency_info);
 
+  // Dispatch a touch cancel event for the |event_to_cancel|.
+  void SendTouchCancelEventForTouchEvent(
+      const TouchEventWithLatencyInfo& event_to_cancel) override;
+
   // Dispatch |touch| to the client. Before dispatching, updates pointer
   // states in touchmove events for pointers that have not changed position.
   void SendTouchEventImmediately(TouchEventWithLatencyInfo* touch);
 
   enum PreFilterResult {
     ACK_WITH_NO_CONSUMER_EXISTS,
     ACK_WITH_NOT_CONSUMED,
     FORWARD_TO_RENDERER,
   };
   // Filter touches prior to forwarding to the renderer, e.g., if the renderer
   // has no touch handler.
   PreFilterResult FilterBeforeForwarding(const blink::WebTouchEvent& event);
   void ForwardToRenderer(const TouchEventWithLatencyInfo& event);
   void UpdateTouchConsumerStates(const blink::WebTouchEvent& event,
-                                 InputEventAckState ack_result);
+                                 InputEventAckState ack_result) override;
   void FlushPendingAsyncTouchmove();
 
   // Handles touch event forwarding and ack'ed event dispatch.
   TouchEventQueueClient* client_;
 
   std::list<std::unique_ptr<CoalescedWebTouchEvent>> touch_queue_;
 
-  // Position of the first touch in the most recent sequence forwarded to the
-  // client.
-  gfx::PointF touch_sequence_start_position_;
-
   // Used to defer touch forwarding when ack dispatch triggers |QueueEvent()|.
   // True within the scope of |AckTouchEventToClient()|.
   bool dispatching_touch_ack_;
 
   // Used to prevent touch timeout scheduling and increase the count for async
   // touchmove if we receive a synchronous ack after forwarding a touch event
   // to the client.
   bool dispatching_touch_;
 
   // Whether the renderer has at least one touch handler.
@@ skipping 34 matching lines @@
 
   // Event is saved to compare pointer positions for new touchmove events.
   std::unique_ptr<blink::WebTouchEvent> last_sent_touchevent_;
 
   DISALLOW_COPY_AND_ASSIGN(LegacyTouchEventQueue);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_RENDERER_HOST_INPUT_LEGACY_TOUCH_EVENT_QUEUE_H_