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

chrome/browser/ui/gesture_prefs_observer_factory_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 "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"
 #include "base/prefs/public/pref_change_registrar.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_dependency_manager.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/pref_names.h"
 #include "content/public/browser/notification_observer.h"
 #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 {
 
 struct OverscrollPref {
   const char* pref_name;
   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,
         OVERSCROLL_CONFIG_VERT_THRESHOLD_COMPLETE },
       { prefs::kOverscrollMinimumThresholdStart,
         OVERSCROLL_CONFIG_MIN_THRESHOLD_START },
       { prefs::kOverscrollHorizontalResistThreshold,
         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;
+}
 
-    return overscroll_prefs;
+#if defined(USE_ASH)
+struct WorkspaceCyclerPref {
+  const char* pref_name;
+  WorkspaceCyclerConfiguration::Property property;
+};
+
+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;
 
  private:
   void Update();
 
   void UpdateOverscrollPrefs();
+  void UpdateWorkspaceCyclerPrefs();
 
   PrefChangeRegistrar registrar_;
   PrefService* prefs_;
 
   DISALLOW_COPY_AND_ASSIGN(GesturePrefsObserver);
 };
 
 // The list of prefs we want to observe.
 // Note that this collection of settings should correspond to the settings used
 // in ui/base/gestures/gesture_configuration.h
@@ skipping 18 matching lines @@
   prefs::kMinRailBreakVelocity,
   prefs::kMinScrollDeltaSquared,
   prefs::kMinSwipeSpeed,
   prefs::kMinTouchDownDurationInSecondsForClick,
   prefs::kPointsBufferedForVelocity,
   prefs::kRailBreakProportion,
   prefs::kRailStartProportion,
   prefs::kSemiLongPressTimeInSeconds,
 };
 
-const char* kOverscrollPrefs[] = {
-  prefs::kOverscrollHorizontalThresholdComplete,
-  prefs::kOverscrollVerticalThresholdComplete,
-  prefs::kOverscrollMinimumThresholdStart,
-  prefs::kOverscrollHorizontalResistThreshold,
-  prefs::kOverscrollVerticalResistThreshold,
-};
-
 GesturePrefsObserver::GesturePrefsObserver(PrefService* prefs)
     : prefs_(prefs) {
   registrar_.Init(prefs);
   registrar_.RemoveAll();
   base::Closure callback = base::Bind(&GesturePrefsObserver::Update,
                                       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() {}
 
 void GesturePrefsObserver::Shutdown() {
   registrar_.RemoveAll();
 }
 
 void GesturePrefsObserver::Update() {
   GestureConfiguration::set_fling_acceleration_curve_coefficients(0,
@@ skipping 62 matching lines @@
       prefs_->GetInteger(
           prefs::kPointsBufferedForVelocity));
   GestureConfiguration::set_rail_break_proportion(
       prefs_->GetDouble(
           prefs::kRailBreakProportion));
   GestureConfiguration::set_rail_start_proportion(
       prefs_->GetDouble(
           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
 GesturePrefsObserverFactoryAura*
 GesturePrefsObserverFactoryAura::GetInstance() {
   return Singleton<GesturePrefsObserverFactoryAura>::get();
 }
 
 GesturePrefsObserverFactoryAura::GesturePrefsObserverFactoryAura()
     : ProfileKeyedServiceFactory("GesturePrefsObserverAura",
                                  ProfileDependencyManager::GetInstance()) {}
 
 GesturePrefsObserverFactoryAura::~GesturePrefsObserverFactoryAura() {}
 
 ProfileKeyedService* GesturePrefsObserverFactoryAura::BuildServiceInstanceFor(
     Profile* profile) const {
   return new GesturePrefsObserver(profile->GetPrefs());
 }
 
 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),
         PrefServiceSyncable::UNSYNCABLE_PREF);
   }
 }
 
+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(
       prefs::kFlingAccelerationCurveCoefficient0,
       GestureConfiguration::fling_acceleration_curve_coefficients(0),
       PrefServiceSyncable::UNSYNCABLE_PREF);
   prefs->RegisterDoublePref(
       prefs::kFlingAccelerationCurveCoefficient1,
       GestureConfiguration::fling_acceleration_curve_coefficients(1),
       PrefServiceSyncable::UNSYNCABLE_PREF);
@@ skipping 96 matching lines @@
 
   // TODO(rjkroege): Remove this in M29. http://crbug.com/160243.
   const char kTouchScreenFlingAccelerationAdjustment[] =
       "gesture.touchscreen_fling_acceleration_adjustment";
   prefs->RegisterDoublePref(kTouchScreenFlingAccelerationAdjustment,
                             0.0,
                             PrefServiceSyncable::UNSYNCABLE_PREF);
   prefs->ClearPref(kTouchScreenFlingAccelerationAdjustment);
 
   RegisterOverscrollPrefs(prefs);
+  RegisterWorkspaceCyclerPrefs(prefs);
 }
 
 bool GesturePrefsObserverFactoryAura::ServiceIsCreatedWithProfile() const {
   // Create the observer as soon as the profile is created.
   return true;
 }
 
 bool GesturePrefsObserverFactoryAura::ServiceRedirectedInIncognito() const {
   // Use same gesture preferences on incognito windows.
   return true;
 }
 
 bool GesturePrefsObserverFactoryAura::ServiceIsNULLWhileTesting() const {
   // Some tests replace the PrefService of the TestingProfile after the
   // GesturePrefsObserver has been created, which makes Shutdown()
   // remove the registrar from a non-existent PrefService.
   return true;
 }