Add touch scrolling modes experimental flags (DEPRECATED)

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 40 matching lines @@
   // additional queued touch-events to the renderer.
   void ProcessTouchAck(InputEventAckState ack_result,
                        const ui::LatencyInfo& latency_info);
 
   // When GestureScrollBegin is received, we send a touch cancel to renderer,
   // route all the following touch events directly to client, and ignore the
   // ack for the touch cancel. When Gesture{ScrollEnd,FlingStart} is received,
   // resume the normal flow of sending touch events to the renderer.
   void OnGestureScrollEvent(const GestureEventWithLatencyInfo& gesture_event);
 
+  void OnGestureEventAck(
+      const GestureEventWithLatencyInfo& event,
+      InputEventAckState ack_result);
+
   // Notifies the queue whether the renderer has at least one touch handler.
   void OnHasTouchEventHandlers(bool has_handlers);
 
   // Returns whether the currently pending touch event (waiting ACK) is for
   // a touch start event.
   bool IsPendingAckTouchStart() const;
 
   // Sets whether a delayed touch ack will cancel and flush the current
   // touch sequence.
   void SetAckTimeoutEnabled(bool enabled, size_t ack_timeout_delay_ms);
@@ skipping 35 matching lines @@
   // 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.
   void PopTouchEventToClient(InputEventAckState ack_result,
                              const ui::LatencyInfo& renderer_latency_info);
 
   bool ShouldForwardToRenderer(const blink::WebTouchEvent& event) const;
   void ForwardToRenderer(const TouchEventWithLatencyInfo& event);
   void UpdateTouchAckStates(const blink::WebTouchEvent& event,
                             InputEventAckState ack_result);
 
+  // Different ways of dealing with touch events during scrolling.
+  // TODO(rbyers): Remove (or otherwise update) this once results of
+  // experiments are complete.  http://crbug.com/328503
+  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,
+    // 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).
+    TOUCH_SCROLLING_MODE_ABSORB_TOUCHMOVE
+  };
+  static TouchScrollingMode GetTouchScrollingMode();
 
   // 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_;
@@ skipping 14 matching lines @@
                                    // sequence is received.
     DROP_ALL_TOUCHES,              // Filter all events, e.g., no touch handler.
     TOUCH_FILTERING_STATE_DEFAULT = FORWARD_ALL_TOUCHES,
   };
   TouchFilteringState touch_filtering_state_;
 
   // Optional handler for timed-out touch event acks, disabled by default.
   bool ack_timeout_enabled_;
   scoped_ptr<TouchTimeoutHandler> timeout_handler_;
 
+  // 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_;
+
+  // Wether 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_;
+
   DISALLOW_COPY_AND_ASSIGN(TouchEventQueue);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_RENDERER_HOST_INPUT_TOUCH_EVENT_QUEUE_H_