Consuming any touch move before SCROLL_START prevents the scroll from occuring in Aura

ui/events/gestures/gesture_sequence.cc

 // Copyright (c) 2012 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 "ui/events/gestures/gesture_sequence.h"
 
 #include <stdlib.h>
 #include <cmath>
 
 #include "base/command_line.h"
@@ skipping 111 matching lines @@
 
   GST_PENDING_SYNTHETIC_CLICK_NO_SCROLL_FIRST_STATIONARY =
       G(GS_PENDING_SYNTHETIC_CLICK_NO_SCROLL, 0, TS_STATIONARY, TSI_ALWAYS),
 
   GST_PENDING_SYNTHETIC_CLICK_NO_SCROLL_FIRST_CANCELLED =
       G(GS_PENDING_SYNTHETIC_CLICK_NO_SCROLL, 0, TS_CANCELLED, TSI_ALWAYS),
 
   GST_PENDING_SYNTHETIC_CLICK_NO_SCROLL_SECOND_PRESSED =
       G(GS_PENDING_SYNTHETIC_CLICK_NO_SCROLL, 1, TS_PRESSED, TSI_NOT_PROCESSED),
 
+  GST_SYNTHETIC_CLICK_ABORTED_FIRST_RELEASED =
+      G(GS_SYNTHETIC_CLICK_ABORTED, 0, TS_RELEASED, TSI_ALWAYS),
+
+  GST_SYNTHETIC_CLICK_ABORTED_SECOND_PRESSED =
+      G(GS_SYNTHETIC_CLICK_ABORTED, 1, TS_PRESSED, TSI_NOT_PROCESSED),
+
   GST_SCROLL_FIRST_RELEASED =
       G(GS_SCROLL, 0, TS_RELEASED, TSI_ALWAYS),
 
   // Once scroll has started, process all touch-move events.
   GST_SCROLL_FIRST_MOVED =
       G(GS_SCROLL, 0, TS_MOVED, TSI_ALWAYS),
 
   GST_SCROLL_FIRST_CANCELLED =
       G(GS_SCROLL, 0, TS_CANCELLED, TSI_ALWAYS),
 
@@ skipping 193 matching lines @@
     case GST_PENDING_SYNTHETIC_CLICK_FIRST_MOVED_PROCESSED:
     case GST_PENDING_SYNTHETIC_CLICK_FIRST_STATIONARY:
     case GST_PENDING_SYNTHETIC_CLICK_FIRST_CANCELLED:
     case GST_PENDING_SYNTHETIC_CLICK_SECOND_PRESSED:
     case GST_PENDING_SYNTHETIC_CLICK_NO_SCROLL_FIRST_RELEASED:
     case GST_PENDING_SYNTHETIC_CLICK_NO_SCROLL_FIRST_RELEASED_HANDLED:
     case GST_PENDING_SYNTHETIC_CLICK_NO_SCROLL_FIRST_MOVED:
     case GST_PENDING_SYNTHETIC_CLICK_NO_SCROLL_FIRST_STATIONARY:
     case GST_PENDING_SYNTHETIC_CLICK_NO_SCROLL_FIRST_CANCELLED:
     case GST_PENDING_SYNTHETIC_CLICK_NO_SCROLL_SECOND_PRESSED:
+    case GST_SYNTHETIC_CLICK_ABORTED_FIRST_RELEASED:
+    case GST_SYNTHETIC_CLICK_ABORTED_SECOND_PRESSED:
     case GST_SCROLL_FIRST_RELEASED:
     case GST_SCROLL_FIRST_MOVED:
     case GST_SCROLL_FIRST_CANCELLED:
     case GST_SCROLL_SECOND_PRESSED:
     case GST_PENDING_TWO_FINGER_TAP_FIRST_RELEASED:
     case GST_PENDING_TWO_FINGER_TAP_FIRST_RELEASED_HANDLED:
     case GST_PENDING_TWO_FINGER_TAP_SECOND_RELEASED:
     case GST_PENDING_TWO_FINGER_TAP_SECOND_RELEASED_HANDLED:
     case GST_PENDING_TWO_FINGER_TAP_FIRST_MOVED:
     case GST_PENDING_TWO_FINGER_TAP_SECOND_MOVED:
@@ skipping 112 matching lines @@
       ui::LatencyInfo* gesture_latency = (*it)->latency();
       *gesture_latency = *touch_latency;
       gesture_latency->trace_id = -1;
       gesture_latency->terminated = false;
       gesture_latency->RemoveLatency(
           ui::INPUT_EVENT_LATENCY_BEGIN_RWH_COMPONENT);
     }
   }
 }
 
+bool GestureStateSupportsActiveTimer(GestureState state) {
+  switch(state) {
+    case GS_PENDING_SYNTHETIC_CLICK:
+    case GS_PENDING_SYNTHETIC_CLICK_NO_SCROLL:
+      return true;
+    default:
+      return false;
+  }
+}
+
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 // GestureSequence Public:
 
 GestureSequence::GestureSequence(GestureSequenceDelegate* delegate)
     : state_(GS_NO_GESTURE),
       flags_(0),
       pinch_distance_start_(0.f),
       pinch_distance_current_(0.f),
@@ skipping 63 matching lines @@
 
   switch (signature) {
     case GST_INVALID:
       break;
 
     case GST_NO_GESTURE_FIRST_PRESSED:
       TouchDown(event, point, gestures.get());
       set_state(GS_PENDING_SYNTHETIC_CLICK);
       break;
     case GST_PENDING_SYNTHETIC_CLICK_FIRST_RELEASED:
+    case GST_PENDING_SYNTHETIC_CLICK_NO_SCROLL_FIRST_RELEASED:
       if (Click(event, point, gestures.get()))
         point.UpdateForTap();
       else
         PrependTapCancelGestureEvent(point, gestures.get());
       set_state(GS_NO_GESTURE);
       break;
     case GST_PENDING_SYNTHETIC_CLICK_FIRST_MOVED:
     case GST_PENDING_SYNTHETIC_CLICK_FIRST_STATIONARY:
       if (ScrollStart(event, point, gestures.get())) {
         PrependTapCancelGestureEvent(point, gestures.get());
         set_state(GS_SCROLL);
         if (ScrollUpdate(event, point, gestures.get()))
           point.UpdateForScroll();
       }
       break;
+    case GST_PENDING_SYNTHETIC_CLICK_FIRST_MOVED_PROCESSED:
     case GST_PENDING_SYNTHETIC_CLICK_NO_SCROLL_FIRST_MOVED:
     case GST_PENDING_SYNTHETIC_CLICK_NO_SCROLL_FIRST_STATIONARY:
-      // No scrolling allowed, so nothing happens.
-      break;
-    case GST_PENDING_SYNTHETIC_CLICK_FIRST_MOVED_PROCESSED:
       if (point.IsInScrollWindow(event)) {
         PrependTapCancelGestureEvent(point, gestures.get());
+        set_state(GS_SYNTHETIC_CLICK_ABORTED);
+      } else {
         set_state(GS_PENDING_SYNTHETIC_CLICK_NO_SCROLL);
       }
       break;
     case GST_PENDING_SYNTHETIC_CLICK_FIRST_RELEASED_HANDLED:
     case GST_PENDING_SYNTHETIC_CLICK_FIRST_CANCELLED:
+    case GST_PENDING_SYNTHETIC_CLICK_NO_SCROLL_FIRST_RELEASED_HANDLED:
+    case GST_PENDING_SYNTHETIC_CLICK_NO_SCROLL_FIRST_CANCELLED:
       PrependTapCancelGestureEvent(point, gestures.get());
       set_state(GS_NO_GESTURE);
       break;
-    case GST_PENDING_SYNTHETIC_CLICK_NO_SCROLL_FIRST_RELEASED:
-    case GST_PENDING_SYNTHETIC_CLICK_NO_SCROLL_FIRST_RELEASED_HANDLED:
-    case GST_PENDING_SYNTHETIC_CLICK_NO_SCROLL_FIRST_CANCELLED:
+    case GST_SYNTHETIC_CLICK_ABORTED_FIRST_RELEASED:
       set_state(GS_NO_GESTURE);
       break;
     case GST_SCROLL_FIRST_MOVED:
       if (scroll_type_ == ST_VERTICAL ||
           scroll_type_ == ST_HORIZONTAL)
         BreakRailScroll(event, point, gestures.get());
       if (ScrollUpdate(event, point, gestures.get()))
         point.UpdateForScroll();
       break;
     case GST_SCROLL_FIRST_RELEASED:
     case GST_SCROLL_FIRST_CANCELLED:
       ScrollEnd(event, point, gestures.get());
       set_state(GS_NO_GESTURE);
       break;
     case GST_PENDING_SYNTHETIC_CLICK_SECOND_PRESSED:
+    case GST_PENDING_SYNTHETIC_CLICK_NO_SCROLL_SECOND_PRESSED:
       PrependTapCancelGestureEvent(point, gestures.get());
       TwoFingerTapOrPinch(event, point, gestures.get());
       break;
-    case GST_PENDING_SYNTHETIC_CLICK_NO_SCROLL_SECOND_PRESSED:
+    case GST_SYNTHETIC_CLICK_ABORTED_SECOND_PRESSED:
       TwoFingerTapOrPinch(event, point, gestures.get());
       break;
     case GST_SCROLL_SECOND_PRESSED:
       PinchStart(event, point, gestures.get());
       set_state(GS_PINCH);
       break;
     case GST_PENDING_TWO_FINGER_TAP_FIRST_RELEASED:
     case GST_PENDING_TWO_FINGER_TAP_SECOND_RELEASED:
       TwoFingerTouchReleased(event, point, gestures.get());
       set_state(GS_SCROLL);
@@ skipping 122 matching lines @@
 
   if (event.type() == ui::ET_TOUCH_RELEASED ||
       event.type() == ui::ET_TOUCH_CANCELLED)
     AppendEndGestureEvent(point, gestures.get());
 
   if (state_ != last_state)
     DVLOG(4) << "Gesture Sequence"
              << " State: " << state_
              << " touch id: " << event.touch_id();
 
-  if (last_state == GS_PENDING_SYNTHETIC_CLICK && state_ != last_state) {
+  // If the state has changed from one in which a long/show press is possible to
+  // one in which they are not possible, cancel the timers.
+  if (GestureStateSupportsActiveTimer(last_state) &&
+      !GestureStateSupportsActiveTimer(state_)) {
     GetLongPressTimer()->Stop();
     GetShowPressTimer()->Stop();
   }
 
   // The set of point_ids must be contiguous and include 0.
   // When a touch point is released, all points with ids greater than the
   // released point must have their ids decremented, or the set of point_ids
   // could end up with gaps.
   if (event.type() == ui::ET_TOUCH_RELEASED ||
       event.type() == ui::ET_TOUCH_CANCELLED) {
@@ skipping 330 matching lines @@
                           rect.height()),
       point->enclosing_rectangle().CenterPoint(),
       flags_,
       base::Time::FromDoubleT(point->last_touch_time()),
       1 << point->touch_id()));
 }
 
 bool GestureSequence::Click(const TouchEvent& event,
                             const GesturePoint& point,
                             Gestures* gestures) {
-  DCHECK(state_ == GS_PENDING_SYNTHETIC_CLICK);
+  DCHECK(state_ == GS_PENDING_SYNTHETIC_CLICK ||
+         state_ == GS_PENDING_SYNTHETIC_CLICK_NO_SCROLL);
   if (point.IsInClickWindow(event)) {
     int tap_count = 1;
     if (point.IsInTripleClickWindow(event))
       tap_count = 3;
     else if (point.IsInDoubleClickWindow(event))
       tap_count = 2;
     if (tap_count == 1 && GetShowPressTimer()->IsRunning()) {
       GetShowPressTimer()->Stop();
       AppendShowPressGestureEvent();
     }
@@ skipping 64 matching lines @@
       &GestureSequence::AppendShowPressGestureEvent);
 
   return true;
 }
 
 bool GestureSequence::TwoFingerTouchDown(const TouchEvent& event,
                                          const GesturePoint& point,
                                          Gestures* gestures) {
   DCHECK(state_ == GS_PENDING_SYNTHETIC_CLICK ||
          state_ == GS_PENDING_SYNTHETIC_CLICK_NO_SCROLL ||
+         state_ == GS_SYNTHETIC_CLICK_ABORTED ||
          state_ == GS_SCROLL);
 
   if (state_ == GS_SCROLL) {
     AppendScrollGestureEnd(point, point.last_touch_position(), gestures,
         0.f, 0.f);
   }
   second_touch_time_ = event.time_stamp();
   return true;
 }
 
@@ skipping 240 matching lines @@
   // Since a timer is running, there should be a non-NULL point.
   const GesturePoint* point = GetPointByPointId(0);
   if (!ui::gestures::IsInsideManhattanSquare(point->first_touch_position(),
                                              event.location())) {
     GetLongPressTimer()->Stop();
     GetShowPressTimer()->Stop();
   }
 }
 
 }  // namespace ui