Don't treat first touch move differently from future touch moves

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/debug/trace_event.h"
 #include "base/stl_util.h"
 #include "content/browser/renderer_host/input/timeout_monitor.h"
@@ skipping 331 matching lines @@
       touch_filtering_state_(TOUCH_FILTERING_STATE_DEFAULT),
       ack_timeout_enabled_(config.touch_ack_timeout_supported),
       touchmove_slop_suppressor_(new TouchMoveSlopSuppressor(
           config.touchmove_slop_suppression_length_dips +
           (config.touchmove_slop_suppression_region_includes_boundary
                ? kSlopEpsilon
                : -kSlopEpsilon))),
       send_touch_events_async_(false),
       needs_async_touchmove_for_outer_slop_region_(false),
       last_sent_touch_timestamp_sec_(0),
-      touch_scrolling_mode_(config.touch_scrolling_mode) {
+  touch_scrolling_mode_(config.touch_scrolling_mode),
+  seen_scroll_update_this_sequence_(false) {
   DCHECK(client);
   if (ack_timeout_enabled_) {
     timeout_handler_.reset(
         new TouchTimeoutHandler(this, config.touch_ack_timeout_delay));
   }
 }
 
 TouchEventQueue::~TouchEventQueue() {
   if (!touch_queue_.empty())
     STLDeleteElements(&touch_queue_);
@@ skipping 164 matching lines @@
   if (dispatching_touch_ &&
       touch_filtering_state_ == FORWARD_TOUCHES_UNTIL_TIMEOUT &&
       ShouldTouchTriggerTimeout(touch.event)) {
     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_filtering_state_ != DROP_ALL_TOUCHES &&
+  if (gesture_event.event.type == blink::WebInputEvent::GestureScrollBegin &&
+      touch_filtering_state_ != DROP_ALL_TOUCHES &&
       touch_filtering_state_ != DROP_TOUCHES_IN_SEQUENCE) {
     DCHECK(!touchmove_slop_suppressor_->suppressing_touchmoves())
         << "The renderer should be offered a touchmove before scrolling begins";
   }
 
   if (touch_scrolling_mode_ == TOUCH_SCROLLING_MODE_ASYNC_TOUCHMOVE) {
-    if (touch_filtering_state_ != DROP_ALL_TOUCHES &&
+    if (gesture_event.event.type == blink::WebInputEvent::GestureScrollBegin &&
+        touch_filtering_state_ != DROP_ALL_TOUCHES &&
         touch_filtering_state_ != DROP_TOUCHES_IN_SEQUENCE) {
       // If no touch points have a consumer, prevent all subsequent touch events
       // received during the scroll from reaching the renderer. This ensures
       // that the first touchstart the renderer sees in any given sequence can
       // always be preventDefault'ed (cancelable == true).
       // TODO(jdduke): Revisit if touchstarts during scroll are made cancelable.
       if (touch_ack_states_.empty() ||
           AllTouchAckStatesHaveState(
               INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS)) {
         touch_filtering_state_ = DROP_TOUCHES_IN_SEQUENCE;
         return;
       }
     }
 
-    pending_async_touchmove_.reset();
-    send_touch_events_async_ = true;
-    needs_async_touchmove_for_outer_slop_region_ = true;
+    if (gesture_event.event.type == blink::WebInputEvent::GestureScrollBegin) {
+      seen_scroll_update_this_sequence_ = false;
+      return;
+    }
+
+    if (gesture_event.event.type == blink::WebInputEvent::GestureScrollUpdate &&
+        !seen_scroll_update_this_sequence_) {
+      pending_async_touchmove_.reset();
+      send_touch_events_async_ = true;
+      needs_async_touchmove_for_outer_slop_region_ = true;
+      return;
+    }
+  }
+
+  if (touch_scrolling_mode_ != TOUCH_SCROLLING_MODE_TOUCHCANCEL ||
+      gesture_event.event.type != blink::WebInputEvent::GestureScrollBegin) {

[jdduke (slow), 2014/07/02 17:46:37]

Hmm, I would think we also want the "first allowed scroll update" logic to apply
to the TOUCH_CANCEL mode, no?  Otherwise, if the page preventDefaults the first
touchmove, we'd still get a GSB which would cancel the touch sequence?

It might be easier if we do the GSB and GSU checks at the very beginning of this
function, and treat the first GSU like we do the first GSB (returning early
otherwise).

[tdresser, 2014/07/04 18:28:17]

Done.

     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;
 
@@ skipping 232 matching lines @@
        iter != end;
        ++iter) {
     if (iter->second != ack_state)
       return false;
   }
 
   return true;
 }
 
 }  // namespace content