Eager Gesture Recognizer (WIP)

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 461 matching lines @@
           ui::INPUT_EVENT_LATENCY_BEGIN_RWH_COMPONENT);
     }
   }
 }
 
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 // GestureSequence Public:
 
-GestureSequence::GestureSequence(GestureSequenceDelegate* delegate)
+GestureSequence::GestureSequence(GestureEventQueueTimerInterface* geq_timers)
     : state_(GS_NO_GESTURE),
       flags_(0),
       pinch_distance_start_(0.f),
       pinch_distance_current_(0.f),
       scroll_type_(ST_FREE),
       point_count_(0),
-      delegate_(delegate) {
-  CHECK(delegate_);
+      geq_timers_(geq_timers) {
 }
 
 GestureSequence::~GestureSequence() {
 }
 
 GestureSequence::Gestures* GestureSequence::ProcessTouchEventForGesture(
-    const TouchEvent& event,
-    EventResult result) {
+    const TouchEvent& event) {
+  // TODO(tdresser): Remove depency on EventResult from GestureSequence.
+  EventResult result = ER_UNHANDLED;
   StopTimersIfRequired(event);
   last_touch_location_ = event.location();
   if (result & ER_CONSUMED)
     return NULL;
 
   // 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) {
@@ skipping 15 matching lines @@
 
   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);
   RecreateBoundingBox();
   flags_ = event.flags();
   const int point_id = point.point_id();
-  if (point_id < 0)
+  if (point_id < 0) {
+    LOG(ERROR) << "GS sees event for touch which isn't down " << event.type();
+    LOG(ERROR) << "Touch id is " << event.touch_id();
     return NULL;
+  }
 
   // Send GESTURE_BEGIN for any touch pressed.
   if (event.type() == ui::ET_TOUCH_PRESSED)
     AppendBeginGestureEvent(point, gestures.get());
 
   TouchStatusInternal status_internal = (result == ER_UNHANDLED) ?
       TSI_NOT_PROCESSED : TSI_PROCESSED;
 
   EdgeStateSignatureType signature = Signature(state_, point_id,
       event.type(), status_internal);
@@ skipping 198 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) {
-    GetLongPressTimer()->Stop();
-    GetShowPressTimer()->Stop();
+    if (GetLongPressTimer()->IsRunning()) {
+      GetLongPressTimer()->Stop();
+      geq_timers_->TimerCancelled();
+    }
+    if (GetShowPressTimer()->IsRunning()) {
+      GetShowPressTimer()->Stop();
+      geq_timers_->TimerCancelled();
+    }
   }
 
   // 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) {
     for (int i = 0; i < kMaxGesturePoints; ++i) {
       GesturePoint& iter_point = points_[i];
@@ skipping 45 matching lines @@
 void GestureSequence::ResetVelocities() {
   for (int i = 0; i < kMaxGesturePoints; ++i) {
     if (points_[i].in_use())
       points_[i].ResetVelocity();
   }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // GestureSequence Protected:
 
-base::OneShotTimer<GestureSequence>* GestureSequence::CreateTimer() {
-  return new base::OneShotTimer<GestureSequence>();
+base::OneShotTimer<GestureEventQueueTimerInterface>*
+GestureSequence::CreateTimer() {
+  return new base::OneShotTimer<GestureEventQueueTimerInterface>();
 }
 
-base::OneShotTimer<GestureSequence>* GestureSequence::GetLongPressTimer() {
+base::OneShotTimer<GestureEventQueueTimerInterface>*
+GestureSequence::GetLongPressTimer() {
   if (!long_press_timer_.get())
     long_press_timer_.reset(CreateTimer());
   return long_press_timer_.get();
 }
 
-base::OneShotTimer<GestureSequence>* GestureSequence::GetShowPressTimer() {
+base::OneShotTimer<GestureEventQueueTimerInterface>*
+GestureSequence::GetShowPressTimer() {
   if (!show_press_timer_.get())
     show_press_timer_.reset(CreateTimer());
   return show_press_timer_.get();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // GestureSequence Private:
 
 GesturePoint& GestureSequence::GesturePointForEvent(
     const TouchEvent& event) {
@@ skipping 261 matching lines @@
                             Gestures* gestures) {
   DCHECK(state_ == GS_PENDING_SYNTHETIC_CLICK);
   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();
+      geq_timers_->TimerCancelled();
     }
     AppendClickGestureEvent(point, tap_count, gestures);
     return true;
   } else if (point.IsInsideManhattanSquare(event) &&
       !GetLongPressTimer()->IsRunning()) {
     AppendLongTapGestureEvent(point, gestures);
   }
   return false;
 }
 
@@ skipping 33 matching lines @@
     return false;
   AppendScrollGestureUpdate(point, gestures);
   return true;
 }
 
 bool GestureSequence::TouchDown(const TouchEvent& event,
                                 const GesturePoint& point,
                                 Gestures* gestures) {
   DCHECK(state_ == GS_NO_GESTURE);
   AppendTapDownGestureEvent(point, gestures);
+  AppendLongPressGestureEvent(point, gestures);
+  AppendShowPressGestureEvent(point, gestures);
+
   GetLongPressTimer()->Start(
       FROM_HERE,
       base::TimeDelta::FromMilliseconds(
           GestureConfiguration::long_press_time_in_seconds() * 1000),
-      this,
-      &GestureSequence::AppendLongPressGestureEvent);
+      geq_timers_,
+      &GestureEventQueueTimerInterface::TimerFired);
 
   GetShowPressTimer()->Start(
       FROM_HERE,
       base::TimeDelta::FromMilliseconds(
           GestureConfiguration::show_press_delay_in_ms()),
-      this,
-      &GestureSequence::AppendShowPressGestureEvent);
+      geq_timers_,
+      &GestureEventQueueTimerInterface::TimerFired);
 
   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_SCROLL);
@@ skipping 28 matching lines @@
   DCHECK(state_ == GS_PENDING_TWO_FINGER_TAP ||
          state_ == GS_PENDING_TWO_FINGER_TAP_NO_PINCH);
   base::TimeDelta time_delta = event.time_stamp() - second_touch_time_;
   base::TimeDelta max_delta = base::TimeDelta::FromMilliseconds(1000 *
       ui::GestureConfiguration::max_touch_down_duration_in_seconds_for_click());
   if (time_delta < max_delta && point.IsInsideManhattanSquare(event))
     AppendTwoFingerTapGestureEvent(gestures);
   return true;
 }
 
-void GestureSequence::AppendLongPressGestureEvent() {
-  const GesturePoint* point = GetPointByPointId(0);
-  scoped_ptr<GestureEvent> gesture(CreateGestureEvent(
+void GestureSequence::AppendLongPressGestureEvent(const GesturePoint& point,
+                                                  Gestures* gestures) {
+  gestures->push_back(CreateGestureEvent(
       GestureEventDetails(ui::ET_GESTURE_LONG_PRESS, 0, 0),
-      point->first_touch_position(),
+      point.first_touch_position(),
       flags_,
-      base::Time::FromDoubleT(point->last_touch_time()),
-      1 << point->touch_id()));
-  delegate_->DispatchPostponedGestureEvent(gesture.get());
+      base::Time::FromDoubleT(point.last_touch_time()),
+      1 << point.touch_id()));
 }
 
-void GestureSequence::AppendShowPressGestureEvent() {
-  const GesturePoint* point = GetPointByPointId(0);
-  scoped_ptr<GestureEvent> gesture(CreateGestureEvent(
+
+void GestureSequence::AppendShowPressGestureEvent(const GesturePoint& point,
+                                                  Gestures* gestures) {
+  gestures->push_back(CreateGestureEvent(
       GestureEventDetails(ui::ET_GESTURE_SHOW_PRESS, 0, 0),
-      point->first_touch_position(),
+      point.first_touch_position(),
       flags_,
-      base::Time::FromDoubleT(point->last_touch_time()),
-      1 << point->touch_id()));
-  delegate_->DispatchPostponedGestureEvent(gesture.get());
+      base::Time::FromDoubleT(point.last_touch_time()),
+      1 << point.touch_id()));
 }
 
 void GestureSequence::AppendLongTapGestureEvent(const GesturePoint& point,
                                                 Gestures* gestures) {
   gfx::Rect er = point.enclosing_rectangle();
   gfx::Point center = er.CenterPoint();
   gestures->push_back(CreateGestureEvent(
       GestureEventDetails(ui::ET_GESTURE_LONG_TAP, 0, 0),
       center,
       flags_,
@@ skipping 175 matching lines @@
 void GestureSequence::StopTimersIfRequired(const TouchEvent& event) {
   if ((!GetLongPressTimer()->IsRunning() &&
        !GetShowPressTimer()->IsRunning()) ||
       event.type() != ui::ET_TOUCH_MOVED)
     return;
 
   // 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();
+    if (GetLongPressTimer()->IsRunning()) {
+      GetLongPressTimer()->Stop();
+      geq_timers_->TimerCancelled();
+    }
+    if (GetShowPressTimer()->IsRunning()) {
+      GetShowPressTimer()->Stop();
+      geq_timers_->TimerCancelled();
+    }
   }
 }
 
 }  // namespace ui