Implement async touchmove dispatch during scroll

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 <deque>
 #include <map>
 
@@ skipping 30 matching lines @@
   // TODO(rbyers): Remove this once we're confident that touch move absorption
   // is OK. http://crbug.com/350430
   enum TouchScrollingMode {
     // Send a touchcancel on scroll start and no further touch events for the
     // duration of the scroll.  Chrome Android's traditional behavior.
     TOUCH_SCROLLING_MODE_TOUCHCANCEL,
     // Send touchmove events throughout a scroll, blocking on each ACK and
     // using the disposition to determine whether a scroll update should be
     // sent.  Mobile Safari's default overflow scroll behavior.
     TOUCH_SCROLLING_MODE_SYNC_TOUCHMOVE,
+    // Send touchmove events throughout a scroll, but throttle sending and
+    // ignore the ACK as long as scrolling remains possible.  Unconsumed scroll
+    // events return touchmove events to being dispatched synchronously.
+    TOUCH_SCROLLING_MODE_ASYNC_TOUCHMOVE,
     // Like sync, except that consumed scroll events cause subsequent touchmove
     // events to be suppressed.  Unconsumed scroll events return touchmove
     // events to being dispatched synchronously (so scrolling may be hijacked
     // when a scroll limit is reached, and later resumed). http://goo.gl/RShsdN
     TOUCH_SCROLLING_MODE_ABSORB_TOUCHMOVE,

[aelias_OOO_until_Jul13, 2014/04/22 01:56:39]

Can we delete this mode as part of this patch?  There's no reason to ever turn
it on again even for debugging.

[Rick Byers, 2014/04/22 14:52:59]

Replacing ABSORB with ASYNC is OK with me (async just adds some things on top of
absorb).

[jdduke (slow), 2014/04/23 19:57:41]

Done.

-    TOUCH_SCROLLING_MODE_DEFAULT = TOUCH_SCROLLING_MODE_TOUCHCANCEL
+    TOUCH_SCROLLING_MODE_DEFAULT = TOUCH_SCROLLING_MODE_ASYNC_TOUCHMOVE
   };
 
   // The |client| must outlive the TouchEventQueue. If
   // |touchmove_suppression_length_dips| <= 0, touch move suppression is
   // disabled.
   TouchEventQueue(TouchEventQueueClient* client,
                   TouchScrollingMode mode,
                   double touchmove_suppression_length_dips);
   ~TouchEventQueue();
 
@@ skipping 54 matching lines @@
   friend class TouchEventQueueTest;
 
   bool HasTimeoutEvent() 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();
 
-  // Walks the queue, checking each event for |ShouldForwardToRenderer()|.
-  // If true, forwards the touch event and stops processing further events.
-  // If false, acks the event with |INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS|.
+  // Walks the queue, checking each event with |FilterBeforeFowarding()|.
+  // 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();
 
-  // Pops the touch-event from the top of the queue and sends it to the
-  // TouchEventQueueClient. This reduces the size of the queue by one.
+  // 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 head 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|.
+  void AckTouchEventToClient(InputEventAckState ack_result,
+                             const CoalescedWebTouchEvent& acked_event);
+
+  // Safely pop the head of the queue.
+  scoped_ptr<CoalescedWebTouchEvent> PopTouchEvent();
+
   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 UpdateTouchAckStates(const blink::WebTouchEvent& event,
                             InputEventAckState ack_result);
 
 
   // Handles touch event forwarding and ack'ed event dispatch.
   TouchEventQueueClient* client_;
 
   typedef std::deque<CoalescedWebTouchEvent*> TouchQueue;
   TouchQueue touch_queue_;
 
   // Maintain the ACK status for each touch point.
   typedef std::map<int, InputEventAckState> TouchPointAckStates;
   TouchPointAckStates touch_ack_states_;
 
   // Used to defer touch forwarding when ack dispatch triggers |QueueEvent()|.
   // If not NULL, |dispatching_touch_ack_| is the touch event of which the ack
   // is being dispatched.
-  CoalescedWebTouchEvent* dispatching_touch_ack_;
+  const CoalescedWebTouchEvent* dispatching_touch_ack_;
 
   // Used to prevent touch timeout scheduling if we receive a synchronous
   // ack after forwarding a touch event to the client.
   bool dispatching_touch_;
 
   enum TouchFilteringState {
     FORWARD_ALL_TOUCHES,           // Don't filter at all - the default.
     FORWARD_TOUCHES_UNTIL_TIMEOUT, // Don't filter unless we get an ACK timeout.
     DROP_TOUCHES_IN_SEQUENCE,      // Filter all events until a new touch
                                    // sequence is received.
@@ skipping 10 matching lines @@
   // been preventDefaulted.
   scoped_ptr<TouchMoveSlopSuppressor> touchmove_slop_suppressor_;
 
   // Whether touchmove events should be dropped due to the
   // TOUCH_SCROLLING_MODE_ABSORB_TOUCHMOVE mode.  Note that we can't use
   // touch_filtering_state_ for this (without adding a few new states and
   // complicating the code significantly) because it can occur with and without
   // timeout, and shouldn't cause touchend to be dropped.
   bool absorbing_touch_moves_;
 
+  // Whether touchmove's should remain buffered and dispatched asynchronously
+  // while a scroll sequence is active.  In this mode, touchmove's are
+  // ack'ed immediately but remain buffered in |pending_async_touch_move_| until
+  // a sufficient time period has elapsed since the last sent touch event.
+  bool async_touch_moves_;

[aelias_OOO_until_Jul13, 2014/04/22 01:56:39]

Instead of these bools, can we keep the enum value?

[Rick Byers, 2014/04/22 14:52:59]

We can remove this bool completely when we collapse the two modes into one.  The
above bool needs to stay because it's what toggles back and forth depending on
GSU consumption.

[jdduke (slow), 2014/04/23 19:57:41]

Done.

+  scoped_ptr<TouchEventWithLatencyInfo> pending_async_touch_move_;
+  double last_sent_touch_timestamp_;

[aelias_OOO_until_Jul13, 2014/04/22 01:56:39]

Please specify "ms" or "sec" in the variable name.

[jdduke (slow), 2014/04/23 19:57:41]

Done.

+
   // How touch events are handled during scrolling.  For now this is a global
   // setting for experimentation, but we may evolve it into an app-controlled
   // mode.
   const TouchScrollingMode touch_scrolling_mode_;
 
   DISALLOW_COPY_AND_ASSIGN(TouchEventQueue);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_RENDERER_HOST_INPUT_TOUCH_EVENT_QUEUE_H_