Add touch scrolling modes experimental flags (DEPRECATED)

content/browser/renderer_host/input/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 "base/auto_reset.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/stl_util.h"
@@ skipping 222 matching lines @@
   bool ignore_ack_;
 
   DISALLOW_COPY_AND_ASSIGN(CoalescedWebTouchEvent);
 };
 
 TouchEventQueue::TouchEventQueue(TouchEventQueueClient* client)
     : client_(client),
       dispatching_touch_ack_(NULL),
       dispatching_touch_(false),
       touch_filtering_state_(TOUCH_FILTERING_STATE_DEFAULT),
-      ack_timeout_enabled_(false) {
+      ack_timeout_enabled_(false),
+      touch_scrolling_mode_(GetTouchScrollingMode()),
+      absorbing_touch_moves_(false) {
   DCHECK(client);
 }
 
 TouchEventQueue::~TouchEventQueue() {
   if (!touch_queue_.empty())
     STLDeleteElements(&touch_queue_);
 }
 
 void TouchEventQueue::QueueEvent(const TouchEventWithLatencyInfo& event) {
   // If the queueing of |event| was triggered by an ack dispatch, defer
@@ skipping 65 matching lines @@
 void TouchEventQueue::ForwardToRenderer(
     const TouchEventWithLatencyInfo& touch) {
   DCHECK(!dispatching_touch_);
   DCHECK_NE(touch_filtering_state_, DROP_ALL_TOUCHES);
 
   if (IsNewTouchSequence(touch.event)) {
     touch_filtering_state_ =
         ack_timeout_enabled_ ? FORWARD_TOUCHES_UNTIL_TIMEOUT
                              : FORWARD_ALL_TOUCHES;
     touch_ack_states_.clear();
+    absorbing_touch_moves_ = false;
   }
 
   // A synchronous ack will reset |dispatching_touch_|, in which case
   // the touch timeout should not be started.
   base::AutoReset<bool> dispatching_touch(&dispatching_touch_, true);
   client_->SendTouchEventImmediately(touch);
   if (dispatching_touch_ &&
       touch_filtering_state_ == FORWARD_TOUCHES_UNTIL_TIMEOUT &&
       ShouldTouchTypeTriggerTimeout(touch.event.type)) {
     DCHECK(timeout_handler_);
     timeout_handler_->Start(touch);
   }
 }
 
 void TouchEventQueue::OnGestureScrollEvent(
     const GestureEventWithLatencyInfo& gesture_event) {
   if (gesture_event.event.type != blink::WebInputEvent::GestureScrollBegin)
     return;
 
+    if (touch_scrolling_mode_ != TOUCH_SCROLLING_MODE_TOUCHCANCEL)
+      return;
+
   // We assume that scroll events are generated synchronously from
   // dispatching a touch event ack. This allows us to generate a synthetic
   // cancel event that has the same touch ids as the touch event that
   // is being acked. Otherwise, we don't perform the touch-cancel optimization.
   if (!dispatching_touch_ack_)
     return;
 
   if (touch_filtering_state_ == DROP_TOUCHES_IN_SEQUENCE)
     return;
 
   touch_filtering_state_ = DROP_TOUCHES_IN_SEQUENCE;
 
   // Fake a TouchCancel to cancel the touch points of the touch event
   // that is currently being acked.
   // Note: |dispatching_touch_ack_| is non-null when we reach here, meaning we
   // are in the scope of PopTouchEventToClient() and that no touch event
   // in the queue is waiting for ack from renderer. So we can just insert
   // the touch cancel at the beginning of the queue.
   touch_queue_.push_front(new CoalescedWebTouchEvent(
       ObtainCancelEventForTouchEvent(
           dispatching_touch_ack_->coalesced_event()), true));
 }
 
+void TouchEventQueue::OnGestureEventAck(
+    const GestureEventWithLatencyInfo& event,
+    InputEventAckState ack_result) {
+  if (touch_scrolling_mode_ != TOUCH_SCROLLING_MODE_ABSORB_TOUCHMOVE)

[jdduke (slow), 2014/01/31 20:01:16]

Could this be racy? If the GSU ack is delayed?  Or is the only consequence that
there might be some lag time when transitioning between absorption states?

[Rick Byers, 2014/02/01 23:09:34]

Yes, this could be racy.  I was thinking it was OK, but upon further reflection
I'm a little worried about the impact of unavoidably triggering overscroll. 
I've add some thoughts on this to the design doc here:
https://docs.google.com/a/chromium.org/document/d/1MGuCb0Lb7UfaDmH44bp9YKVG-C...
and will leave a TODO in the code for now.  I think this is fine for
experimentation purposes (worst case should cause some minor UI glitches when
under load), but we should resolve it before deciding whether to ship this or
not.

+    return;
+
+  if (event.event.type != blink::WebInputEvent::GestureScrollUpdate)
+    return;
+
+  // Suspend sending touchmove events as long as the scroll events are handled.
+  absorbing_touch_moves_ = (ack_result == INPUT_EVENT_ACK_STATE_CONSUMED);
+}
+
 void TouchEventQueue::OnHasTouchEventHandlers(bool has_handlers) {
   DCHECK(!dispatching_touch_ack_);
   DCHECK(!dispatching_touch_);
 
   if (has_handlers) {
     if (touch_filtering_state_ == DROP_ALL_TOUCHES) {
       // If no touch handler was previously registered, ensure that we don't
       // send a partial touch sequence to the renderer.
       DCHECK(touch_queue_.empty());
       touch_filtering_state_ = DROP_TOUCHES_IN_SEQUENCE;
@@ skipping 90 matching lines @@
   if (touch_filtering_state_ == DROP_ALL_TOUCHES)
     return false;
 
   if (touch_filtering_state_ == DROP_TOUCHES_IN_SEQUENCE &&
       event.type != WebInputEvent::TouchCancel) {
     if (IsNewTouchSequence(event))
       return true;
     return false;
   }
 
+  if (absorbing_touch_moves_ && event.type == WebInputEvent::TouchMove)
+    return false;
+
   // Touch press events should always be forwarded to the renderer.
   if (event.type == WebInputEvent::TouchStart)
     return true;
 
   for (unsigned int i = 0; i < event.touchesLength; ++i) {
     const WebTouchPoint& point = event.touches[i];
     // If a point has been stationary, then don't take it into account.
     if (point.state == WebTouchPoint::StateStationary)
       continue;
 
@@ skipping 25 matching lines @@
     }
   } else if (event.type == WebInputEvent::TouchStart) {
     for (unsigned i = 0; i < event.touchesLength; ++i) {
       const WebTouchPoint& point = event.touches[i];
       if (point.state == WebTouchPoint::StatePressed)
         touch_ack_states_[point.id] = ack_result;
     }
   }
 }
 
+// static
+TouchEventQueue::TouchScrollingMode TouchEventQueue::GetTouchScrollingMode()

[jdduke (slow), 2014/01/31 20:01:16]

Any reason not to just put this in the anon namespace above and remove the
static member?  Or even better, have the mode be an arg to the TEQ and move
commandline parsing to the InputRouter?

[Rick Byers, 2014/02/01 23:09:34]

Done.

+{
+  std::string modeString = CommandLine::ForCurrentProcess()->
+      GetSwitchValueASCII(switches::kTouchScrollingMode);
+  if (modeString == switches::kTouchScrollingModeSyncTouchmove)
+    return TOUCH_SCROLLING_MODE_SYNC_TOUCHMOVE;
+  if (modeString == switches::kTouchScrollingModeAbsorbTouchmove)
+    return TOUCH_SCROLLING_MODE_ABSORB_TOUCHMOVE;
+  if (modeString != "" &&
+      modeString != switches::kTouchScrollingModeTouchcancel)
+    LOG(ERROR) << "Invalid --touch-scrolling-mode option: " << modeString;
+  return TOUCH_SCROLLING_MODE_TOUCHCANCEL;
+}
+
+
 }  // namespace content