Revert 124071 - Gestures are now possible using touch events with any ids

ui/aura/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/aura/gestures/gesture_sequence.h"
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/time.h"
 #include "ui/aura/event.h"
 #include "ui/aura/root_window.h"
 #include "ui/aura/gestures/gesture_configuration.h"
 #include "ui/base/events.h"
 
+// TODO(sad): Pinch gestures currently always assume that the first two
+//            touch-points (i.e. at indices 0 and 1) are involved. This may not
+//            always be the case. This needs to be fixed eventually.
+//            http://crbug.com/113144
+
 namespace {
 
 // TODO(girard): Make these configurable in sync with this CL
 //               http://crbug.com/100773
 const float kMinimumPinchUpdateDistance = 5;  // in pixels
 const float kMinimumDistanceForPinchScroll = 20;
 const float kLongPressTimeInMilliseconds = 500;
 
 }  // namespace
 
@@ skipping 62 matching lines @@
 
   GST_SCROLL_FIRST_RELEASED =
       G(GS_SCROLL, 0, TS_RELEASED, false),
 
   GST_SCROLL_FIRST_MOVED =
       G(GS_SCROLL, 0, TS_MOVED, false),
 
   GST_SCROLL_FIRST_CANCELLED =
       G(GS_SCROLL, 0, TS_CANCELLED, false),
 
+  GST_SCROLL_FIRST_PRESSED =
+      G(GS_SCROLL, 0, TS_PRESSED, false),
+
+  GST_SCROLL_SECOND_RELEASED =
+      G(GS_SCROLL, 1, TS_RELEASED, false),
+
+  GST_SCROLL_SECOND_MOVED =
+      G(GS_SCROLL, 1, TS_MOVED, false),
+
+  GST_SCROLL_SECOND_CANCELLED =
+      G(GS_SCROLL, 1, TS_CANCELLED, false),
+
   GST_SCROLL_SECOND_PRESSED =
       G(GS_SCROLL, 1, TS_PRESSED, false),
 
   GST_PINCH_FIRST_MOVED =
       G(GS_PINCH, 0, TS_MOVED, false),
 
   GST_PINCH_SECOND_MOVED =
       G(GS_PINCH, 1, TS_MOVED, false),
 
   GST_PINCH_FIRST_RELEASED =
@@ skipping 33 matching lines @@
 // GestureSequence Public:
 
 GestureSequence::GestureSequence(RootWindow* root_window)
     : state_(GS_NO_GESTURE),
       flags_(0),
       pinch_distance_start_(0.f),
       pinch_distance_current_(0.f),
       long_press_timer_(CreateTimer()),
       point_count_(0),
       root_window_(root_window) {
+  for (int i = 0; i < kMaxGesturePoints; ++i) {
+    points_[i].set_touch_id(i);
+  }
 }
 
 GestureSequence::~GestureSequence() {
 }
 
 GestureSequence::Gestures* GestureSequence::ProcessTouchEventForGesture(
     const TouchEvent& event,
     ui::TouchStatus status) {
   if (status != ui::TOUCH_STATUS_UNKNOWN)
     return NULL;  // The event was consumed by a touch sequence.
 
   // Set a limit on the number of simultaneous touches in a gesture.
   if (event.touch_id() >= kMaxGesturePoints)
     return NULL;
 
   if (event.type() == ui::ET_TOUCH_PRESSED) {
     if (point_count_ == kMaxGesturePoints)
       return NULL;
-    GesturePoint* new_point = &points_[event.touch_id()];
-    // We shouldn't be able to get two PRESSED events, without a RELEASE
-    DCHECK(!points_[event.touch_id()].in_use());
-    new_point->set_point_id(point_count_++);
-  } else {
-    // Make sure the point we're modifying was PRESSED at some point in the past
-    DCHECK(points_[event.touch_id()].in_use());
+    ++point_count_;
   }
 
   GestureState last_state = state_;
 
   // NOTE: when modifying these state transitions, also update gestures.dot
   scoped_ptr<Gestures> gestures(new Gestures());
   GesturePoint& point = GesturePointForEvent(event);
   point.UpdateValues(event);
   flags_ = event.flags();
-  const int point_id = points_[event.touch_id()].point_id();
-  switch (Signature(state_, point_id, event.type(), false)) {
+  switch (Signature(state_, event.touch_id(), event.type(), false)) {
     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:
       if (Click(event, point, gestures.get()))
         point.UpdateForTap();
       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())) {
         set_state(GS_SCROLL);
         if (ScrollUpdate(event, point, gestures.get()))
           point.UpdateForScroll();
       }
       break;
     case GST_PENDING_SYNTHETIC_CLICK_FIRST_CANCELLED:
       NoGesture(event, point, gestures.get());
       break;
     case GST_SCROLL_FIRST_MOVED:
+    case GST_SCROLL_SECOND_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:
+    case GST_SCROLL_SECOND_RELEASED:
+    case GST_SCROLL_SECOND_CANCELLED:
       ScrollEnd(event, point, gestures.get());
       set_state(GS_NO_GESTURE);
       break;
+    case GST_SCROLL_FIRST_PRESSED:
     case GST_SCROLL_SECOND_PRESSED:
     case GST_PENDING_SYNTHETIC_CLICK_SECOND_PRESSED:
       PinchStart(event, point, gestures.get());
       set_state(GS_PINCH);
       break;
     case GST_PINCH_FIRST_MOVED:
     case GST_PINCH_SECOND_MOVED:
       if (PinchUpdate(event, point, gestures.get())) {
         points_[0].UpdateForScroll();
         points_[1].UpdateForScroll();
@@ skipping 13 matching lines @@
   }
 
   if (state_ != last_state)
     VLOG(4) << "Gesture Sequence"
             << " State: " << state_
             << " touch id: " << event.touch_id();
 
   if (last_state == GS_PENDING_SYNTHETIC_CLICK && state_ != last_state)
     long_press_timer_->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) {
-    GesturePoint& old_point = points_[event.touch_id()];
-    for (int i = 0; i < kMaxGesturePoints; ++i) {
-      GesturePoint& point = points_[i];
-      if (point.point_id() > old_point.point_id())
-        point.set_point_id(point.point_id() - 1);
-    }
-    old_point.Reset();
+  if (event.type() == ui::ET_TOUCH_RELEASED)
     --point_count_;
-  }
 
   return gestures.release();
 }
 
 void GestureSequence::Reset() {
   set_state(GS_NO_GESTURE);
-  for (int i = 0; i < kMaxGesturePoints; ++i)
+  for (int i = 0; i < point_count_; ++i)
     points_[i].Reset();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // GestureSequence Protected:
 
 base::OneShotTimer<GestureSequence>* GestureSequence::CreateTimer() {
   return new base::OneShotTimer<GestureSequence>();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // GestureSequence Private:
 
 GesturePoint& GestureSequence::GesturePointForEvent(
     const TouchEvent& event) {
   return points_[event.touch_id()];
 }
 
-GesturePoint* GestureSequence::GetPointByPointId(int point_id) {
-  DCHECK(0 <= point_id && point_id < kMaxGesturePoints);
-  for (int i = 0; i < kMaxGesturePoints; ++i) {
-    GesturePoint& point = points_[i];
-    if (point.in_use() && point.point_id() == point_id)
-      return &point;
-  }
-  NOTREACHED();
-  return NULL;
-}
-
 void GestureSequence::AppendTapDownGestureEvent(const GesturePoint& point,
                                                 Gestures* gestures) {
   gestures->push_back(linked_ptr<GestureEvent>(new GestureEvent(
       ui::ET_GESTURE_TAP_DOWN,
       point.first_touch_position().x(),
       point.first_touch_position().y(),
       flags_,
       base::Time::FromDoubleT(point.last_touch_time()),
       0.f, 0.f)));
 }
@@ skipping 170 matching lines @@
   AppendTapDownGestureEvent(point, gestures);
   long_press_timer_->Start(
       FROM_HERE,
       base::TimeDelta::FromMilliseconds(kLongPressTimeInMilliseconds),
       this,
       &GestureSequence::AppendLongPressGestureEvent);
   return true;
 }
 
 void GestureSequence::AppendLongPressGestureEvent() {
-  const GesturePoint* point = GetPointByPointId(0);
+  // TODO(tdresser) - this may not always be the first point
+  const GesturePoint& point = points_[0];
   GestureEvent* gesture = new GestureEvent(
       ui::ET_GESTURE_LONG_PRESS,
-      point->first_touch_position().x(),
-      point->first_touch_position().y(),
+      point.first_touch_position().x(),
+      point.first_touch_position().y(),
       flags_,
-      base::Time::FromDoubleT(point->last_touch_time()),
-      point->point_id(), 0.f);
+      base::Time::FromDoubleT(point.last_touch_time()),
+      point.touch_id(), 0.f);
+
   root_window_->DispatchGestureEvent(gesture);
 }
 
 bool GestureSequence::ScrollEnd(const TouchEvent& event,
     GesturePoint& point, Gestures* gestures) {
   DCHECK(state_ == GS_SCROLL);
   if (point.IsInFlickWindow(event)) {
     AppendScrollGestureEnd(point, point.last_touch_position(), gestures,
         point.XVelocity(), point.YVelocity());
   } else {
     AppendScrollGestureEnd(point, point.last_touch_position(), gestures,
         0.f, 0.f);
   }
   return true;
 }
 
 bool GestureSequence::PinchStart(const TouchEvent& event,
     const GesturePoint& point, Gestures* gestures) {
   DCHECK(state_ == GS_SCROLL ||
          state_ == GS_PENDING_SYNTHETIC_CLICK);
   AppendTapDownGestureEvent(point, gestures);
 
-  const GesturePoint* point1 = GetPointByPointId(0);
-  const GesturePoint* point2 = GetPointByPointId(1);
-
-  pinch_distance_current_ = point1->Distance(*point2);
+  pinch_distance_current_ = points_[0].Distance(points_[1]);
   pinch_distance_start_ = pinch_distance_current_;
-  AppendPinchGestureBegin(*point1, *point2, gestures);
+  AppendPinchGestureBegin(points_[0], points_[1], gestures);
 
   if (state_ == GS_PENDING_SYNTHETIC_CLICK) {
-    gfx::Point center = point1->last_touch_position().Middle(
-        point2->last_touch_position());
+    gfx::Point center = points_[0].last_touch_position().Middle(
+        points_[1].last_touch_position());
     AppendScrollGestureBegin(point, center, gestures);
   }
 
   return true;
 }
 
 bool GestureSequence::PinchUpdate(const TouchEvent& event,
     const GesturePoint& point, Gestures* gestures) {
   DCHECK(state_ == GS_PINCH);
-
-  const GesturePoint* point1 = GetPointByPointId(0);
-  const GesturePoint* point2 = GetPointByPointId(1);
-
-  float distance = point1->Distance(*point2);
+  float distance = points_[0].Distance(points_[1]);
   if (abs(distance - pinch_distance_current_) <
       GestureConfiguration::minimum_pinch_update_distance_in_pixels()) {
     // The fingers didn't move towards each other, or away from each other,
     // enough to constitute a pinch. But perhaps they moved enough in the same
     // direction to do a two-finger scroll.
-    if (!point1->DidScroll(event,
+    if (!points_[0].DidScroll(event,
         GestureConfiguration::minimum_distance_for_pinch_scroll_in_pixels()) ||
-        !point2->DidScroll(event,
+        !points_[1].DidScroll(event,
         GestureConfiguration::minimum_distance_for_pinch_scroll_in_pixels()))
       return false;
 
-    gfx::Point center = point1->last_touch_position().Middle(
-                        point2->last_touch_position());
+    gfx::Point center = points_[0].last_touch_position().Middle(
+                        points_[1].last_touch_position());
     AppendScrollGestureUpdate(point, center, gestures);
   } else {
-    AppendPinchGestureUpdate(*point1, *point2,
+    AppendPinchGestureUpdate(points_[0], points_[1],
         distance / pinch_distance_current_, gestures);
     pinch_distance_current_ = distance;
   }
   return true;
 }
 
 bool GestureSequence::PinchEnd(const TouchEvent& event,
     const GesturePoint& point, Gestures* gestures) {
   DCHECK(state_ == GS_PINCH);
-
-  const GesturePoint* point1 = GetPointByPointId(0);
-  const GesturePoint* point2 = GetPointByPointId(1);
-
-  float distance = point1->Distance(*point2);
-  AppendPinchGestureEnd(*point1, *point2,
+  float distance = points_[0].Distance(points_[1]);
+  AppendPinchGestureEnd(points_[0], points_[1],
       distance / pinch_distance_start_, gestures);
 
   pinch_distance_start_ = 0;
   pinch_distance_current_ = 0;
   return true;
 }
 
 }  // namespace aura