Event smoothing in CrOS gesture recognizer.

ui/aura/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/aura/gestures/gesture_point.h"
 
 #include "ui/aura/event.h"
 #include "ui/base/events.h"
 
 namespace {
 
 // TODO(girard): Make these configurable in sync with this CL
 //               http://crbug.com/100773
 const double kMaximumTouchDownDurationInSecondsForClick = 0.8;
 const double kMinimumTouchDownDurationInSecondsForClick = 0.01;
 const double kMaximumSecondsBetweenDoubleClick = 0.7;
 const int kMaximumTouchMoveInPixelsForClick = 20;
 const float kMinFlickSpeedSquared = 550.f * 550.f;
+const int kBufferedPoints = 10;
 
-}  // namespace aura
+}  // namespace
 
 namespace aura {
 
 GesturePoint::GesturePoint()
     : first_touch_time_(0.0),
       last_touch_time_(0.0),
       last_tap_time_(0.0),
       x_velocity_(0.0),
-      y_velocity_(0.0) {
+      y_velocity_(0.0),
+      velocity_calculator_(kBufferedPoints) {
 }
 
 void GesturePoint::Reset() {
   first_touch_time_ = last_touch_time_ = 0.0;
   x_velocity_ = y_velocity_ = 0.0;
 }
 
 void GesturePoint::UpdateValues(const TouchEvent& event, GestureState state) {
+  const double event_timestamp_seconds = event.time_stamp().InSecondsF();

[rjkroege, 2012/02/02 15:58:37]

if our compiler is doing the right thing with SSE, float would give us a
non-trivial performance boost.

   if (state != GS_NO_GESTURE && event.type() == ui::ET_TOUCH_MOVED) {
-    double interval(event.time_stamp().InSecondsF() - last_touch_time_);
-    x_velocity_ = (event.x() - last_touch_position_.x()) / interval;
-    y_velocity_ = (event.y() - last_touch_position_.y()) / interval;
+    velocity_calculator_.PointSeen(event.x(),

[rjkroege, 2012/02/02 15:58:37]

you need to move these over one char I think. 

+                                  event.y(),
+                                  event_timestamp_seconds);
+    velocity_calculator_.Velocity(&x_velocity_, &y_velocity_);
   }
 
-  last_touch_time_ = event.time_stamp().InSecondsF();
+  last_touch_time_ = event_timestamp_seconds;
   last_touch_position_ = event.location();
 
   if (state == GS_NO_GESTURE) {
     first_touch_time_ = last_touch_time_;
     first_touch_position_ = event.location();
+    velocity_calculator_.ClearHistory();
+    velocity_calculator_.PointSeen(event.x(),
+                                  event.y(),
+                                  event_timestamp_seconds);
     x_velocity_ = 0.0;
     y_velocity_ = 0.0;
   }
 }
 
 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_;
   Reset();
@@ skipping 53 matching lines @@
                           abs(event.y() - last_tap_position_.y());
   return manhattanDistance < kMaximumTouchMoveInPixelsForClick;
 }
 
 bool GesturePoint::IsOverMinFlickSpeed() const {
   return (x_velocity_ * x_velocity_ + y_velocity_ * y_velocity_) >
           kMinFlickSpeedSquared;
 }
 
 }  // namespace aura