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

chrome/browser/ui/views/ash/gesture_prefs_aura.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 "base/memory/singleton.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/ui/gesture_prefs.h"
 #include "chrome/browser/prefs/pref_change_registrar.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/common/chrome_notification_types.h"
@@ skipping 26 matching lines @@
 
   PrefChangeRegistrar registrar_;
   PrefService* local_state_;
   DISALLOW_COPY_AND_ASSIGN(GesturePrefsObserverAura);
 };
 
 // The list of prefs we want to observe.
 // Note that this collection of settings should correspond to the settings used
 // in ui/aura/gestures/gesture_configuration.h
 const char* kPrefsToObserve[] = {
-  prefs::kMaximumSecondsBetweenDoubleClick,
-  prefs::kMaximumTouchDownDurationInSecondsForClick,
-  prefs::kMaximumTouchMoveInPixelsForClick,
+  prefs::kLongPressTimeInSeconds,
+  prefs::kMaxSecondsBetweenDoubleClick,
+  prefs::kMaxTouchDownDurationInSecondsForClick,
+  prefs::kMaxTouchMoveInPixelsForClick,
+  prefs::kMinDistanceForPinchScrollInPixels,
   prefs::kMinFlickSpeedSquared,
-  prefs::kMinimumTouchDownDurationInSecondsForClick,
+  prefs::kMinPinchUpdateDistanceInPixels,
+  prefs::kMinRailBreakVelocity,
+  prefs::kMinScrollDeltaSquared,
+  prefs::kMinTouchDownDurationInSecondsForClick,
+  prefs::kPointsBufferedForVelocity,
+  prefs::kRailBreakProportion,
+  prefs::kRailStartProportion,
 };
 
 const int kPrefsToObserveLength = arraysize(kPrefsToObserve);
 
 GesturePrefsObserverAura::GesturePrefsObserverAura()
     : local_state_(0) {
 }
 
 GesturePrefsObserverAura::~GesturePrefsObserverAura() {
 }
 
 GesturePrefsObserverAura* GesturePrefsObserverAura::GetInstance() {
   return Singleton<GesturePrefsObserverAura,
     LeakySingletonTraits<GesturePrefsObserverAura> >::get();
 }
 
 void GesturePrefsObserverAura::RegisterPrefs(PrefService* local_state) {
   if (local_state_ == 0) {
     local_state_ = local_state;
 
     if (local_state_) {
+      local_state->RegisterDoublePref(
+          prefs::kLongPressTimeInSeconds,
+          GestureConfiguration::long_press_time_in_seconds());
       local_state_->RegisterDoublePref(
-        prefs::kMaximumSecondsBetweenDoubleClick, 0.7);
+          prefs::kMaxSecondsBetweenDoubleClick,
+          GestureConfiguration::max_seconds_between_double_click());
       local_state_->RegisterDoublePref(
-        prefs::kMaximumTouchDownDurationInSecondsForClick, 0.8);
+          prefs::kMaxTouchDownDurationInSecondsForClick,
+          GestureConfiguration::max_touch_down_duration_in_seconds_for_click());
       local_state_->RegisterDoublePref(
-        prefs::kMaximumTouchMoveInPixelsForClick, 20);
+          prefs::kMaxTouchMoveInPixelsForClick,
+          GestureConfiguration::max_touch_move_in_pixels_for_click());
+      local_state->RegisterDoublePref(
+          prefs::kMinDistanceForPinchScrollInPixels,
+          GestureConfiguration::min_distance_for_pinch_scroll_in_pixels());
       local_state_->RegisterDoublePref(
-        prefs::kMinFlickSpeedSquared, 550.f*550.f);
+          prefs::kMinFlickSpeedSquared,
+          GestureConfiguration::min_flick_speed_squared());
+      local_state->RegisterDoublePref(
+          prefs::kMinPinchUpdateDistanceInPixels,
+          GestureConfiguration::min_pinch_update_distance_in_pixels());
       local_state_->RegisterDoublePref(
-        prefs::kMinimumTouchDownDurationInSecondsForClick, 0.01);
+          prefs::kMinRailBreakVelocity,
+          GestureConfiguration::min_rail_break_velocity());
+      local_state_->RegisterDoublePref(
+          prefs::kMinScrollDeltaSquared,
+          GestureConfiguration::min_scroll_delta_squared());
+      local_state_->RegisterDoublePref(
+          prefs::kMinTouchDownDurationInSecondsForClick,
+          GestureConfiguration::min_touch_down_duration_in_seconds_for_click());
+      local_state->RegisterIntegerPref(
+          prefs::kPointsBufferedForVelocity,
+          GestureConfiguration::points_buffered_for_velocity());
+      local_state->RegisterDoublePref(
+          prefs::kRailBreakProportion,
+          GestureConfiguration::rail_break_proportion());
+      local_state->RegisterDoublePref(
+          prefs::kRailStartProportion,
+          GestureConfiguration::rail_start_proportion());
 
       registrar_.Init(local_state_);
       registrar_.RemoveAll();
       for (int i = 0; i < kPrefsToObserveLength; ++i)
         registrar_.Add(kPrefsToObserve[i], this);
     }
   }
 }
 
 void GesturePrefsObserverAura::Update() {
   if (local_state_) {
+    GestureConfiguration::set_long_press_time_in_seconds(
+        local_state_->GetDouble(
+            prefs::kLongPressTimeInSeconds));
     GestureConfiguration::set_max_seconds_between_double_click(
-      local_state_->GetDouble(prefs::kMaximumSecondsBetweenDoubleClick));
+        local_state_->GetDouble(
+            prefs::kMaxSecondsBetweenDoubleClick));
     GestureConfiguration::set_max_touch_down_duration_in_seconds_for_click(
-      local_state_->GetDouble(
-      prefs::kMaximumTouchDownDurationInSecondsForClick));
+        local_state_->GetDouble(
+            prefs::kMaxTouchDownDurationInSecondsForClick));
     GestureConfiguration::set_max_touch_move_in_pixels_for_click(
-      local_state_->GetDouble(prefs::kMaximumTouchMoveInPixelsForClick));
+        local_state_->GetDouble(
+            prefs::kMaxTouchMoveInPixelsForClick));
+    GestureConfiguration::set_min_distance_for_pinch_scroll_in_pixels(
+        local_state_->GetDouble(
+            prefs::kMinDistanceForPinchScrollInPixels));
     GestureConfiguration::set_min_flick_speed_squared(
-      local_state_->GetDouble(prefs::kMinFlickSpeedSquared));
+        local_state_->GetDouble(
+            prefs::kMinFlickSpeedSquared));
+    GestureConfiguration::set_min_pinch_update_distance_in_pixels(
+        local_state_->GetDouble(
+            prefs::kMinPinchUpdateDistanceInPixels));
+    GestureConfiguration::set_min_rail_break_velocity(
+        local_state_->GetDouble(
+            prefs::kMinRailBreakVelocity));
+    GestureConfiguration::set_min_scroll_delta_squared(
+        local_state_->GetDouble(
+            prefs::kMinScrollDeltaSquared));
     GestureConfiguration::set_min_touch_down_duration_in_seconds_for_click(
-      local_state_->GetDouble(
-      prefs::kMinimumTouchDownDurationInSecondsForClick));
+        local_state_->GetDouble(
+            prefs::kMinTouchDownDurationInSecondsForClick));
+    GestureConfiguration::set_points_buffered_for_velocity(
+        local_state_->GetInteger(
+            prefs::kPointsBufferedForVelocity));
+    GestureConfiguration::set_rail_break_proportion(
+        local_state_->GetDouble(
+            prefs::kRailBreakProportion));
+    GestureConfiguration::set_rail_start_proportion(
+        local_state_->GetDouble(
+            prefs::kRailStartProportion));

[sadrul, 2012/03/26 19:56:59]

General comment: this is fairly icky. Updating all the configs when just one may
have changed is ugly. But that's not an issue with this CL. Regardless, this
should probably be cleaned up in some future CL.

   }
 }
 
 void GesturePrefsObserverAura::Observe(int type,
                            const content::NotificationSource& source,
                            const content::NotificationDetails& details) {
   Update();
 }
 
-} // namespace
+}  // namespace
 
 void GesturePrefsRegisterPrefs(PrefService* prefs) {
   GesturePrefsObserverAura::GetInstance()->RegisterPrefs(prefs);
 }