Generate tap gesture with tap_count = 3 for triple-tap

ui/base/gestures/gesture_point.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/base/gestures/gesture_point.h"
 
 #include <cmath>
 
 #include "base/basictypes.h"
 #include "ui/base/events/event.h"
 #include "ui/base/events/event_constants.h"
 #include "ui/base/gestures/gesture_configuration.h"
 #include "ui/base/gestures/gesture_types.h"
 #include "ui/base/gestures/gesture_util.h"
 
 namespace ui {
 
 GesturePoint::GesturePoint()
     : first_touch_time_(0.0),
       second_last_touch_time_(0.0),
       last_touch_time_(0.0),
+      second_last_tap_time_(0.0),
       last_tap_time_(0.0),
       velocity_calculator_(
           GestureConfiguration::points_buffered_for_velocity()),
       point_id_(-1),
       touch_id_(-1) {
 }
 
 GesturePoint::~GesturePoint() {}
 
 void GesturePoint::Reset() {
@@ skipping 37 matching lines @@
     velocity_calculator_.PointSeen(event.location().x(),
                                    event.location().y(),
                                    event_timestamp_microseconds);
   }
 
   UpdateEnclosingRectangle(event);
 }
 
 void GesturePoint::UpdateForTap() {
   // Update the tap-position and time, and reset every other state.
+  second_last_tap_position_ = last_tap_position_;
+  second_last_tap_time_ = last_tap_time_;
   last_tap_time_ = last_touch_time_;
   last_tap_position_ = last_touch_position_;
 }
 
 void GesturePoint::UpdateForScroll() {
   second_last_touch_position_ = last_touch_position_;
   second_last_touch_time_ = last_touch_time_;
   same_direction_count_ = gfx::Vector2d();
 }
 
 bool GesturePoint::IsInClickWindow(const TouchEvent& event) const {
   return IsInClickTimeWindow() && IsInsideManhattanSquare(event);
 }
 
 bool GesturePoint::IsInDoubleClickWindow(const TouchEvent& event) const {
-  return IsInSecondClickTimeWindow() &&
-         IsSecondClickInsideManhattanSquare(event);
+  return IsInClickAggregateTimeWindow(last_tap_time_, last_touch_time_) &&
+         IsPointInsideManhattanSquare(event.location(), last_tap_position_);
+}
+
+bool GesturePoint::IsInTripleClickWindow(const TouchEvent& event) const {
+  return IsInClickAggregateTimeWindow(last_tap_time_, last_touch_time_) &&
+         IsInClickAggregateTimeWindow(second_last_tap_time_, last_tap_time_) &&
+         IsPointInsideManhattanSquare(event.location(), last_tap_position_) &&
+         IsPointInsideManhattanSquare(last_tap_position_,
+                                      second_last_tap_position_);
 }
 
 bool GesturePoint::IsInScrollWindow(const TouchEvent& event) const {
   return event.type() == ui::ET_TOUCH_MOVED &&
          !IsInsideManhattanSquare(event);
 }
 
 bool GesturePoint::IsInFlickWindow(const TouchEvent& event) {
   return IsOverMinFlickSpeed() &&
          event.type() != ui::ET_TOUCH_CANCELLED;
@@ skipping 48 matching lines @@
 }
 
 bool GesturePoint::IsInClickTimeWindow() const {
   double duration = last_touch_time_ - first_touch_time_;
   return duration >=
       GestureConfiguration::min_touch_down_duration_in_seconds_for_click() &&
       duration <
       GestureConfiguration::max_touch_down_duration_in_seconds_for_click();
 }
 
-bool GesturePoint::IsInSecondClickTimeWindow() const {
-  double duration =  last_touch_time_ - last_tap_time_;
+bool GesturePoint::IsInClickAggregateTimeWindow(double before,
+                                                double after) const {
+  double duration =  after - before;
   return duration < GestureConfiguration::max_seconds_between_double_click();
 }
 
 bool GesturePoint::IsInsideManhattanSquare(const TouchEvent& event) const {
   return ui::gestures::IsInsideManhattanSquare(event.location(),
                                                first_touch_position_);
 }
 
-bool GesturePoint::IsSecondClickInsideManhattanSquare(
-    const TouchEvent& event) const {
-  int manhattan_distance = abs(event.location().x() - last_tap_position_.x()) +
-                           abs(event.location().y() - last_tap_position_.y());
+bool GesturePoint::IsPointInsideManhattanSquare(gfx::Point p1,
+                                                gfx::Point p2) const {
+ int manhattan_distance = abs(p1.x() - p2.x()) + abs(p1.y() - p2.y());
   return manhattan_distance <
       GestureConfiguration::max_distance_between_taps_for_double_tap();
 }
 
 bool GesturePoint::IsOverMinFlickSpeed() {
   return velocity_calculator_.VelocitySquared() >
       GestureConfiguration::min_flick_speed_squared();
 }
 
 void GesturePoint::UpdateEnclosingRectangle(const TouchEvent& event) {
@@ skipping 20 matching lines @@
                  event.location().y() - radius,
                  radius * 2,
                  radius * 2);
   if (IsInClickWindow(event))
     enclosing_rect_.Union(rect);
   else
     enclosing_rect_ = rect;
 }
 
 }  // namespace ui