Make the workspace cycler animation parameters editable via chrome://gesture

chrome/browser/ui/gesture_prefs_observer_factory_aura.cc

Index: chrome/browser/ui/gesture_prefs_observer_factory_aura.cc
diff --git a/chrome/browser/ui/gesture_prefs_observer_factory_aura.cc b/chrome/browser/ui/gesture_prefs_observer_factory_aura.cc
index a8c96811359c985a8ef25d2807db94efeb735026..a3fd8c4d31d034d07226bcfffc1a8daf29d785bf 100644
--- a/chrome/browser/ui/gesture_prefs_observer_factory_aura.cc
+++ b/chrome/browser/ui/gesture_prefs_observer_factory_aura.cc
@@ -4,6 +4,8 @@
 
 #include "chrome/browser/ui/gesture_prefs_observer_factory_aura.h"
 
+#include <vector>
+
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/compiler_specific.h"
@@ -17,6 +19,11 @@
 #include "content/public/browser/overscroll_configuration.h"
 #include "ui/base/gestures/gesture_configuration.h"
 
+#if defined(USE_ASH)
+#include "ash/wm/workspace/workspace_cycler_configuration.h"
+#endif  // USE_ASH
+
+using ash::WorkspaceCyclerConfiguration;
 using ui::GestureConfiguration;
 
 namespace {
@@ -26,15 +33,11 @@ struct OverscrollPref {
   content::OverscrollConfig config;
 };
 
-// This class manages gesture configuration preferences.
-class GesturePrefsObserver : public ProfileKeyedService {
- public:
-  explicit GesturePrefsObserver(PrefService* prefs);
-  virtual ~GesturePrefsObserver();
-
-  static const OverscrollPref* GetOverscrollPrefs() {
+const std::vector<OverscrollPref>& GetOverscrollPrefs() {
+  CR_DEFINE_STATIC_LOCAL(std::vector<OverscrollPref>, overscroll_prefs, ());

[sadrul, 2013/02/11 16:41:19]

Whats the reason for this change?

[pkotwicz, 2013/02/12 00:00:26]

The reason for this change is consistency with how I implemented the
WorkspaceCyclerPrefs.
In particular, I did not want to have WorkspaceCyclerConfiguration::NONE.
Other than making me happy, there is no reason for this change.

[sadrul, 2013/02/12 15:59:58]

Why would you need ::NONE?
Unless the change adds value (better follow style guide, performance
improvement, more readable etc.), it's better to not add code churn.

+  if (overscroll_prefs.empty()) {
     using namespace content;
-    static OverscrollPref overscroll_prefs[] = {
+    const OverscrollPref kOverscrollPrefs[] = {
       { prefs::kOverscrollHorizontalThresholdComplete,
         OVERSCROLL_CONFIG_HORIZ_THRESHOLD_COMPLETE },
       { prefs::kOverscrollVerticalThresholdComplete,
@@ -45,12 +48,62 @@ class GesturePrefsObserver : public ProfileKeyedService {
         OVERSCROLL_CONFIG_HORIZ_RESIST_AFTER },
       { prefs::kOverscrollVerticalResistThreshold,
         OVERSCROLL_CONFIG_VERT_RESIST_AFTER },
-      { NULL,
-        OVERSCROLL_CONFIG_NONE },
     };
+    overscroll_prefs.assign(kOverscrollPrefs,
+                            kOverscrollPrefs + arraysize(kOverscrollPrefs));
+  }
+  return overscroll_prefs;
+}
+
+#if defined(USE_ASH)
+struct WorkspaceCyclerPref {
+  const char* pref_name;
+  WorkspaceCyclerConfiguration::Property property;
+};
 
-    return overscroll_prefs;
+const std::vector<WorkspaceCyclerPref>& GetWorkspaceCyclerPrefs() {
+  CR_DEFINE_STATIC_LOCAL(std::vector<WorkspaceCyclerPref>, cycler_prefs, ());
+  if (cycler_prefs.empty() && WorkspaceCyclerConfiguration::IsCyclerEnabled()) {
+    const WorkspaceCyclerPref kCyclerPrefs[] = {
+      { prefs::kWorkspaceCyclerShallowerThanSelectedYOffsets,
+        WorkspaceCyclerConfiguration::SHALLOWER_THAN_SELECTED_Y_OFFSETS },
+      { prefs::kWorkspaceCyclerDeeperThanSelectedYOffsets,
+        WorkspaceCyclerConfiguration::DEEPER_THAN_SELECTED_Y_OFFSETS },
+      { prefs::kWorkspaceCyclerSelectedYOffset,
+        WorkspaceCyclerConfiguration::SELECTED_Y_OFFSET },
+      { prefs::kWorkspaceCyclerSelectedScale,
+        WorkspaceCyclerConfiguration::SELECTED_SCALE },
+      { prefs::kWorkspaceCyclerMinScale,
+        WorkspaceCyclerConfiguration::MIN_SCALE },
+      { prefs::kWorkspaceCyclerMaxScale,
+        WorkspaceCyclerConfiguration::MAX_SCALE },
+      { prefs::kWorkspaceCyclerMinBrightness,
+        WorkspaceCyclerConfiguration::MIN_BRIGHTNESS },
+      { prefs::kWorkspaceCyclerBackgroundOpacity,
+        WorkspaceCyclerConfiguration::BACKGROUND_OPACITY },
+      { prefs::kWorkspaceCyclerDistanceToInitiateCycling,
+        WorkspaceCyclerConfiguration::DISTANCE_TO_INITIATE_CYCLING },
+      { prefs::kWorkspaceCyclerScrollDistanceToCycleToNextWorkspace,
+        WorkspaceCyclerConfiguration::
+            SCROLL_DISTANCE_TO_CYCLE_TO_NEXT_WORKSPACE },
+      { prefs::kWorkspaceCyclerCyclerStepAnimationDurationRatio,
+        WorkspaceCyclerConfiguration::CYCLER_STEP_ANIMATION_DURATION_RATIO },
+      { prefs::kWorkspaceCyclerStartCyclerAnimationDuration,
+        WorkspaceCyclerConfiguration::START_CYCLER_ANIMATION_DURATION },
+      { prefs::kWorkspaceCyclerStopCyclerAnimationDuration,
+        WorkspaceCyclerConfiguration::STOP_CYCLER_ANIMATION_DURATION },
+    };
+    cycler_prefs.assign(kCyclerPrefs, kCyclerPrefs + arraysize(kCyclerPrefs));
   }
+  return cycler_prefs;
+}
+#endif  // USE_ASH
+
+// This class manages gesture configuration preferences.
+class GesturePrefsObserver : public ProfileKeyedService {
+ public:
+  explicit GesturePrefsObserver(PrefService* prefs);
+  virtual ~GesturePrefsObserver();
 
   // ProfileKeyedService implementation.
   virtual void Shutdown() OVERRIDE;
@@ -59,6 +112,7 @@ class GesturePrefsObserver : public ProfileKeyedService {
   void Update();
 
   void UpdateOverscrollPrefs();
+  void UpdateWorkspaceCyclerPrefs();
 
   PrefChangeRegistrar registrar_;
   PrefService* prefs_;
@@ -97,14 +151,6 @@ const char* kPrefsToObserve[] = {
   prefs::kSemiLongPressTimeInSeconds,
 };
 
-const char* kOverscrollPrefs[] = {
-  prefs::kOverscrollHorizontalThresholdComplete,
-  prefs::kOverscrollVerticalThresholdComplete,
-  prefs::kOverscrollMinimumThresholdStart,
-  prefs::kOverscrollHorizontalResistThreshold,
-  prefs::kOverscrollVerticalResistThreshold,
-};
-
 GesturePrefsObserver::GesturePrefsObserver(PrefService* prefs)
     : prefs_(prefs) {
   registrar_.Init(prefs);
@@ -113,8 +159,17 @@ GesturePrefsObserver::GesturePrefsObserver(PrefService* prefs)
                                       base::Unretained(this));
   for (size_t i = 0; i < arraysize(kPrefsToObserve); ++i)
     registrar_.Add(kPrefsToObserve[i], callback);
-  for (size_t i = 0; i < arraysize(kOverscrollPrefs); ++i)
-    registrar_.Add(kOverscrollPrefs[i], callback);
+
+  const std::vector<OverscrollPref>& overscroll_prefs = GetOverscrollPrefs();
+  for (size_t i = 0; i < overscroll_prefs.size(); ++i)
+    registrar_.Add(overscroll_prefs[i].pref_name, callback);
+
+#if defined(USE_ASH)
+  const std::vector<WorkspaceCyclerPref>& cycler_prefs =
+      GetWorkspaceCyclerPrefs();
+  for (size_t i = 0; i < cycler_prefs.size(); ++i)
+    registrar_.Add(cycler_prefs[i].pref_name, callback);
+#endif  // USE_ASH
 }
 
 GesturePrefsObserver::~GesturePrefsObserver() {}
@@ -197,17 +252,35 @@ void GesturePrefsObserver::Update() {
           prefs::kRailStartProportion));
 
   UpdateOverscrollPrefs();
+  UpdateWorkspaceCyclerPrefs();
 }
 
 void GesturePrefsObserver::UpdateOverscrollPrefs() {
-  const OverscrollPref* overscroll_prefs =
-      GesturePrefsObserver::GetOverscrollPrefs();
-  for (int i = 0; overscroll_prefs[i].pref_name; ++i) {
+  const std::vector<OverscrollPref>& overscroll_prefs = GetOverscrollPrefs();
+  for (size_t i = 0; i < overscroll_prefs.size(); ++i) {
     content::SetOverscrollConfig(overscroll_prefs[i].config,
         static_cast<float>(prefs_->GetDouble(overscroll_prefs[i].pref_name)));
   }
 }
 
+void GesturePrefsObserver::UpdateWorkspaceCyclerPrefs() {
+#if defined(USE_ASH)
+  const std::vector<WorkspaceCyclerPref>& cycler_prefs =
+      GetWorkspaceCyclerPrefs();
+  for (size_t i = 0; i < cycler_prefs.size(); ++i) {
+    WorkspaceCyclerConfiguration::Property property =
+        cycler_prefs[i].property;
+    if (WorkspaceCyclerConfiguration::IsListProperty(property)) {
+      WorkspaceCyclerConfiguration::SetListValue(property,
+          prefs_->GetList(cycler_prefs[i].pref_name));
+    } else {
+      WorkspaceCyclerConfiguration::SetDouble(property,
+          prefs_->GetDouble(cycler_prefs[i].pref_name));
+    }
+  }
+#endif  // USE_ASH
+}
+
 }  // namespace
 
 // static
@@ -229,10 +302,9 @@ ProfileKeyedService* GesturePrefsObserverFactoryAura::BuildServiceInstanceFor(
 
 void GesturePrefsObserverFactoryAura::RegisterOverscrollPrefs(
     PrefServiceSyncable* prefs) {
-  const OverscrollPref* overscroll_prefs =
-      GesturePrefsObserver::GetOverscrollPrefs();
+  const std::vector<OverscrollPref>& overscroll_prefs = GetOverscrollPrefs();
 
-  for (int i = 0; overscroll_prefs[i].pref_name; ++i) {
+  for (size_t i = 0; i < overscroll_prefs.size(); ++i) {
     prefs->RegisterDoublePref(
         overscroll_prefs[i].pref_name,
         content::GetOverscrollConfig(overscroll_prefs[i].config),
@@ -240,6 +312,29 @@ void GesturePrefsObserverFactoryAura::RegisterOverscrollPrefs(
   }
 }
 
+void GesturePrefsObserverFactoryAura::RegisterWorkspaceCyclerPrefs(
+    PrefServiceSyncable* prefs) {
+#if defined(USE_ASH)
+  const std::vector<WorkspaceCyclerPref>& cycler_prefs =
+      GetWorkspaceCyclerPrefs();
+  for (size_t i = 0; i < cycler_prefs.size(); ++i) {
+    WorkspaceCyclerConfiguration::Property property =
+        cycler_prefs[i].property;
+    if (WorkspaceCyclerConfiguration::IsListProperty(property)) {
+      prefs->RegisterListPref(
+          cycler_prefs[i].pref_name,
+          WorkspaceCyclerConfiguration::GetListValue(property)->DeepCopy(),
+          PrefServiceSyncable::UNSYNCABLE_PREF);
+    } else {
+      prefs->RegisterDoublePref(
+          cycler_prefs[i].pref_name,
+          WorkspaceCyclerConfiguration::GetDouble(property),
+          PrefServiceSyncable::UNSYNCABLE_PREF);
+    }
+  }
+#endif  // USE_ASH
+}
+
 void GesturePrefsObserverFactoryAura::RegisterUserPrefs(
     PrefServiceSyncable* prefs) {
   prefs->RegisterDoublePref(
@@ -356,6 +451,7 @@ void GesturePrefsObserverFactoryAura::RegisterUserPrefs(
   prefs->ClearPref(kTouchScreenFlingAccelerationAdjustment);
 
   RegisterOverscrollPrefs(prefs);
+  RegisterWorkspaceCyclerPrefs(prefs);
 }
 
 bool GesturePrefsObserverFactoryAura::ServiceIsCreatedWithProfile() const {