Gesture recognition constants should all be stored in the GestureConfiguration object.

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 <cmath>
 
 #include "base/basictypes.h"
 #include "ui/aura/event.h"
 #include "ui/aura/gestures/gesture_configuration.h"
 #include "ui/base/events.h"
 
-namespace {
-
-const int kMinRailBreakVelocity = 200;
-const int kMinScrollDeltaSquared = 5 * 5;
-const int kRailBreakProportion = 15;
-const int kRailStartProportion = 2;
-const int kBufferedPoints = 10;
-
-}  // namespace
-
 namespace aura {
 
 GesturePoint::GesturePoint()
     : first_touch_time_(0.0),
       last_touch_time_(0.0),
       last_tap_time_(0.0),
-      velocity_calculator_(kBufferedPoints),
+      velocity_calculator_(
+          GestureConfiguration::points_buffered_for_velocity()),

[girard, 2012/03/20 18:30:59]

As per my other comment.  This should not be configurable.

       point_id_(-1) {
 }
 
 GesturePoint::~GesturePoint() {}
 
 void GesturePoint::Reset() {
   first_touch_time_ = last_touch_time_ = 0.0;
   velocity_calculator_.ClearHistory();
   point_id_ = -1;
 }
@@ skipping 62 matching lines @@
   float x_diff = point.last_touch_position_.x() - last_touch_position_.x();
   float y_diff = point.last_touch_position_.y() - last_touch_position_.y();
   return sqrt(x_diff * x_diff + y_diff * y_diff);
 }
 
 bool GesturePoint::HasEnoughDataToEstablishRail() const {
   int dx = x_delta();
   int dy = y_delta();
 
   int delta_squared = dx * dx + dy * dy;
-  return delta_squared > kMinScrollDeltaSquared;
+  return delta_squared > GestureConfiguration::min_scroll_delta_squared();
 }
 
 bool GesturePoint::IsInHorizontalRailWindow() const {
   int dx = x_delta();
   int dy = y_delta();
-  return abs(dx) > kRailStartProportion * abs(dy);
+  return abs(dx) > GestureConfiguration::rail_start_proportion() * abs(dy);
 }
 
 bool GesturePoint::IsInVerticalRailWindow() const {
   int dx = x_delta();
   int dy = y_delta();
-  return abs(dy) > kRailStartProportion * abs(dx);
+  return abs(dy) > GestureConfiguration::rail_start_proportion() * abs(dx);
 }
 
 bool GesturePoint::BreaksHorizontalRail() {
   float vx = XVelocity();
   float vy = YVelocity();
-  return fabs(vy) > kRailBreakProportion * fabs(vx) + kMinRailBreakVelocity;
+  return fabs(vy) > GestureConfiguration::rail_break_proportion() * fabs(vx) +
+      GestureConfiguration::min_rail_break_velocity();
 }
 
 bool GesturePoint::BreaksVerticalRail() {
   float vx = XVelocity();
   float vy = YVelocity();
-  return fabs(vx) > kRailBreakProportion * fabs(vy) + kMinRailBreakVelocity;
+  return fabs(vx) > GestureConfiguration::rail_break_proportion() * fabs(vy) +
+      GestureConfiguration::min_rail_break_velocity();
 }
 
 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();
 }
 
@@ skipping 16 matching lines @@
   return manhattanDistance <
       GestureConfiguration::max_touch_move_in_pixels_for_click();
 }
 
 bool GesturePoint::IsOverMinFlickSpeed() {
   return velocity_calculator_.VelocitySquared() >
       GestureConfiguration::min_flick_speed_squared();
 }
 
 }  // namespace aura