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);
 }
 
+bool GesturePoint::IsInTripleClickWindow(const TouchEvent& event) const {
+  return IsInThirdClickTimeWindow() &&
+         IsThirdClickInsideManhattanSquare(event);
+}
+
 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 51 matching lines @@
       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_;
   return duration < GestureConfiguration::max_seconds_between_double_click();
 }
 
+bool GesturePoint::IsInThirdClickTimeWindow() const {
+  double duration1 =  last_touch_time_ - last_tap_time_;
+  double duration2 =  last_tap_time_ - second_last_tap_time_;
+  return duration1 < GestureConfiguration::max_seconds_between_double_click() &&
+      duration2 < GestureConfiguration::max_seconds_between_double_click();
+}
+

[sadrul, 2013/05/28 17:48:46]

Refactor IsInSecondClickTimeWindow and IsInThirdClickTimeWindow into one
function:

  IsInClickAggregateTimeWindow(double before, double after)

[Yufeng Shen (Slow to review), 2013/05/28 19:31:44]

Done.

 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());
   return manhattan_distance <
       GestureConfiguration::max_distance_between_taps_for_double_tap();
 }
 
+bool GesturePoint::IsThirdClickInsideManhattanSquare(
+    const TouchEvent& event) const {
+  int manhattan_distance1 =
+      abs(event.location().x() - last_tap_position_.x()) +
+      abs(event.location().y() - last_tap_position_.y());
+  int manhattan_distance2 =
+      abs(last_tap_position_.x() - second_last_tap_position_.x()) +
+      abs(last_tap_position_.y() - second_last_tap_position_.y());
+
+  return manhattan_distance1 <
+      GestureConfiguration::max_distance_between_taps_for_double_tap() &&
+      manhattan_distance2 <
+      GestureConfiguration::max_distance_between_taps_for_double_tap();
+}
+

[sadrul, 2013/05/28 17:48:46]

Similarly,

 IsLocationsInsideManhattanSquare(point 1, point 2)

[Yufeng Shen (Slow to review), 2013/05/28 19:31:44]

Done.

 bool GesturePoint::IsOverMinFlickSpeed() {
   return velocity_calculator_.VelocitySquared() >
       GestureConfiguration::min_flick_speed_squared();
 }
 
 void GesturePoint::UpdateEnclosingRectangle(const TouchEvent& event) {
   int radius;
 
   // Ignore this TouchEvent if it has a radius larger than the maximum
   // allowed radius size.
@@ skipping 16 matching lines @@
                  event.location().y() - radius,
                  radius * 2,
                  radius * 2);
   if (IsInClickWindow(event))
     enclosing_rect_.Union(rect);
   else
     enclosing_rect_ = rect;
 }
 
 }  // namespace ui