Refactor access to scroll deltas in GesturePoint

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),
       last_tap_time_(0.0),
       velocity_calculator_(
           GestureConfiguration::points_buffered_for_velocity()),
       point_id_(-1),
       touch_id_(-1) {
 }
 
 GesturePoint::~GesturePoint() {}
 
 void GesturePoint::Reset() {
-  first_touch_time_ = last_touch_time_ = 0.0;
+  first_touch_time_ = second_last_touch_time_ = last_touch_time_ = 0.0;
   velocity_calculator_.ClearHistory();
   point_id_ = -1;
   clear_enclosing_rectangle();
 }
 
 void GesturePoint::ResetVelocity() {
   velocity_calculator_.ClearHistory();
 }
 
+gfx::Vector2d GesturePoint::ScrollDelta() {
+  return last_touch_position_ - second_last_touch_position_;
+}
+
 void GesturePoint::UpdateValues(const TouchEvent& event) {
   const int64 event_timestamp_microseconds =
       event.time_stamp().InMicroseconds();
   if (event.type() == ui::ET_TOUCH_MOVED) {
     velocity_calculator_.PointSeen(event.location().x(),
                                    event.location().y(),
                                    event_timestamp_microseconds);
   }
 
   last_touch_time_ = event.time_stamp().InSecondsF();
   last_touch_position_ = event.location();
 
   if (event.type() == ui::ET_TOUCH_PRESSED) {
     first_touch_time_ = last_touch_time_;
     first_touch_position_ = event.location();
+    second_last_touch_position_ = last_touch_position_;
+    second_last_touch_time_ = last_touch_time_;
+
     velocity_calculator_.ClearHistory();
     velocity_calculator_.PointSeen(event.location().x(),
                                    event.location().y(),
                                    event_timestamp_microseconds);
     clear_enclosing_rectangle();
   }
 
   UpdateEnclosingRectangle(event);
 }
 
 void GesturePoint::UpdateForTap() {
   // Update the tap-position and time, and reset every other state.
   last_tap_time_ = last_touch_time_;
   last_tap_position_ = last_touch_position_;
 }
 
 void GesturePoint::UpdateForScroll() {
-  // Update the first-touch position and time so that the scroll-delta and
-  // scroll-velocity can be computed correctly for the next scroll gesture
-  // event.
-  first_touch_position_ = last_touch_position_;
-  first_touch_time_ = last_touch_time_;
+  second_last_touch_position_ = last_touch_position_;
+  second_last_touch_time_ = last_touch_time_;
 }
 
 bool GesturePoint::IsInClickWindow(const TouchEvent& event) const {
   return IsInClickTimeWindow() && IsInsideManhattanSquare(event);
 }
 
 bool GesturePoint::IsInDoubleClickWindow(const TouchEvent& event) const {
   return IsInSecondClickTimeWindow() &&
          IsSecondClickInsideManhattanSquare(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;
 }
 
 bool GesturePoint::DidScroll(const TouchEvent& event, int dist) const {
-  return abs(last_touch_position_.x() - first_touch_position_.x()) > dist ||
-         abs(last_touch_position_.y() - first_touch_position_.y()) > dist;
+  gfx::Vector2d d = last_touch_position_ - second_last_touch_position_;
+  return abs(d.x()) > dist || abs(d.y()) > dist;
 }
 
 bool GesturePoint::HasEnoughDataToEstablishRail() const {
-  int dx = x_delta();
-  int dy = y_delta();
-
-  int delta_squared = dx * dx + dy * dy;
+  gfx::Vector2d d = last_touch_position_ - first_touch_position_;
+  int64 delta_squared = d.LengthSquared();
   return delta_squared > GestureConfiguration::min_scroll_delta_squared();
 }
 
 bool GesturePoint::IsInHorizontalRailWindow() const {
-  int dx = x_delta();
-  int dy = y_delta();
-  return abs(dx) > GestureConfiguration::rail_start_proportion() * abs(dy);
+  gfx::Vector2d d = last_touch_position_ - second_last_touch_position_;
+  return abs(d.x()) >
+      GestureConfiguration::rail_start_proportion() * abs(d.y());
 }
 
 bool GesturePoint::IsInVerticalRailWindow() const {
-  int dx = x_delta();
-  int dy = y_delta();
-  return abs(dy) > GestureConfiguration::rail_start_proportion() * abs(dx);
+  gfx::Vector2d d = last_touch_position_ - second_last_touch_position_;
+  return abs(d.y()) >
+      GestureConfiguration::rail_start_proportion() * abs(d.x());
 }
 
 bool GesturePoint::BreaksHorizontalRail() {
   float vx = XVelocity();
   float vy = YVelocity();
   return fabs(vy) > GestureConfiguration::rail_break_proportion() * fabs(vx) +
       GestureConfiguration::min_rail_break_velocity();
 }
 
 bool GesturePoint::BreaksVerticalRail() {
@@ skipping 58 matching lines @@
                  event.location().y() - radius,
                  radius * 2,
                  radius * 2);
   if (IsInClickWindow(event))
     enclosing_rect_.Union(rect);
   else
     enclosing_rect_ = rect;
 }
 
 }  // namespace ui