Notify Blink about start of gesture scroll through a queued event.

content/browser/renderer_host/input/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_TOUCH_EVENT_QUEUE_H_
 #define CONTENT_BROWSER_RENDERER_HOST_INPUT_TOUCH_EVENT_QUEUE_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <deque>
-#include <map>
+#include <list>
 
 #include "base/macros.h"
 #include "base/time/time.h"
 #include "content/browser/renderer_host/event_with_latency_info.h"
 #include "content/common/content_export.h"
 #include "content/common/input/input_event_ack_state.h"
 #include "third_party/WebKit/public/web/WebInputEvent.h"
 #include "ui/gfx/geometry/point_f.h"
 
 namespace content {
@@ skipping 40 matching lines @@
   TouchEventQueue(TouchEventQueueClient* client, const Config& config);
 
   ~TouchEventQueue();
 
   // Adds an event to the queue. The event may be coalesced with previously
   // queued events (e.g. consecutive touch-move events can be coalesced into a
   // single touch-move event). The event may also be immediately forwarded to
   // the renderer (e.g. when there are no other queued touch event).
   void QueueEvent(const TouchEventWithLatencyInfo& event);
 
+  // Insert a TouchScrollStarted event in the queue ahead of all not-in-flight
+  // events.
+  void PrependTouchScrollNotification();
+
   // Notifies the queue that a touch-event has been processed by the renderer.
   // At this point, if the ack is for async touchmove, remove the uncancelable
   // touchmove from the front of the queue and decide if it should dispatch the
   // next pending async touch move event, otherwise the queue may send one or
   // more gesture events and/or additional queued touch-events to the renderer.
   void ProcessTouchAck(InputEventAckState ack_result,
                        const ui::LatencyInfo& latency_info,
                        const uint32_t unique_touch_event_id);
 
   // When GestureScrollBegin is received, we send a touch cancel to renderer,
@@ skipping 19 matching lines @@
   void SetAckTimeoutEnabled(bool enabled);
 
   // Sets whether the current site has a mobile friendly viewport. This
   // determines which ack timeout delay will be used for *future* touch events.
   // The default assumption is that the site is *not* mobile-optimized.
   void SetIsMobileOptimizedSite(bool mobile_optimized_site);
 
   // Whether ack timeout behavior is supported and enabled for the current site.
   bool IsAckTimeoutEnabled() const;
 
-  bool IsForwardingTouches();
-
   bool empty() const WARN_UNUSED_RESULT {
     return touch_queue_.empty();
   }
 
   size_t size() const {
     return touch_queue_.size();
   }
 
   bool has_handlers() const { return has_handlers_; }
 
@@ skipping 24 matching lines @@
   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 in |acked_event| to the client with |ack_result|,
-  // updating the acked events with |optional_latency_info| if it exists.
-  void AckTouchEventToClient(
-      InputEventAckState ack_result,
-      std::unique_ptr<CoalescedWebTouchEvent> acked_event,
-      const ui::LatencyInfo* optional_latency_info);
-
-  // Safely pop the head of the queue.
-  std::unique_ptr<CoalescedWebTouchEvent> PopTouchEvent();
+  // 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 |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);
   void FlushPendingAsyncTouchmove();
 
   // Handles touch event forwarding and ack'ed event dispatch.
   TouchEventQueueClient* client_;
 
-  typedef std::deque<CoalescedWebTouchEvent*> TouchQueue;
+  typedef std::list<CoalescedWebTouchEvent*> TouchQueue;
   TouchQueue 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_;
 
@@ skipping 44 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(TouchEventQueue);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_RENDERER_HOST_INPUT_TOUCH_EVENT_QUEUE_H_