gesture_prefs_observer_factory_aura.cc revision b2df76ea8fec9e32f6f3718986dba0d95315b29c 
1// Copyright (c) 2013 The Chromium Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#include "chrome/browser/ui/gesture_prefs_observer_factory_aura.h"
6
7#include <vector>
8
9#include "base/bind.h"
10#include "base/bind_helpers.h"
11#include "base/compiler_specific.h"
12#include "base/prefs/pref_change_registrar.h"
13#include "base/prefs/pref_service.h"
14#include "chrome/browser/profiles/incognito_helpers.h"
15#include "chrome/browser/profiles/profile.h"
16#include "chrome/browser/profiles/profile_dependency_manager.h"
17#include "chrome/common/chrome_notification_types.h"
18#include "chrome/common/pref_names.h"
19#include "components/user_prefs/pref_registry_syncable.h"
20#include "content/public/browser/notification_observer.h"
21#include "content/public/browser/notification_service.h"
22#include "content/public/browser/overscroll_configuration.h"
23#include "content/public/common/renderer_preferences.h"
24#include "ui/base/gestures/gesture_configuration.h"
25
26#if defined(USE_ASH)
27#include "ash/wm/workspace/workspace_cycler_configuration.h"
28#endif  // USE_ASH
29
30#if defined(USE_ASH)
31using ash::WorkspaceCyclerConfiguration;
32#endif  // USE_ASH
33
34using ui::GestureConfiguration;
35
36namespace {
37
38// TODO(rjkroege): Remove this deprecated pref in M29. http://crbug.com/160243.
39const char kTouchScreenFlingAccelerationAdjustment[] =
40    "gesture.touchscreen_fling_acceleration_adjustment";
41
42struct OverscrollPref {
43  const char* pref_name;
44  content::OverscrollConfig config;
45};
46
47const std::vector<OverscrollPref>& GetOverscrollPrefs() {
48  CR_DEFINE_STATIC_LOCAL(std::vector<OverscrollPref>, overscroll_prefs, ());
49  if (overscroll_prefs.empty()) {
50    using namespace content;
51    const OverscrollPref kOverscrollPrefs[] = {
52      { prefs::kOverscrollHorizontalThresholdComplete,
53        OVERSCROLL_CONFIG_HORIZ_THRESHOLD_COMPLETE },
54      { prefs::kOverscrollVerticalThresholdComplete,
55        OVERSCROLL_CONFIG_VERT_THRESHOLD_COMPLETE },
56      { prefs::kOverscrollMinimumThresholdStart,
57        OVERSCROLL_CONFIG_MIN_THRESHOLD_START },
58      { prefs::kOverscrollHorizontalResistThreshold,
59        OVERSCROLL_CONFIG_HORIZ_RESIST_AFTER },
60      { prefs::kOverscrollVerticalResistThreshold,
61        OVERSCROLL_CONFIG_VERT_RESIST_AFTER },
62    };
63    overscroll_prefs.assign(kOverscrollPrefs,
64                            kOverscrollPrefs + arraysize(kOverscrollPrefs));
65  }
66  return overscroll_prefs;
67}
68
69#if defined(USE_ASH)
70const char* kImmersiveModePrefs[] = {
71  prefs::kImmersiveModeRevealDelayMs,
72  prefs::kImmersiveModeRevealXThresholdPixels,
73};
74
75struct WorkspaceCyclerPref {
76  const char* pref_name;
77  WorkspaceCyclerConfiguration::Property property;
78};
79
80const std::vector<WorkspaceCyclerPref>& GetWorkspaceCyclerPrefs() {
81  CR_DEFINE_STATIC_LOCAL(std::vector<WorkspaceCyclerPref>, cycler_prefs, ());
82  if (cycler_prefs.empty()) {
83    const WorkspaceCyclerPref kCyclerPrefs[] = {
84      { prefs::kWorkspaceCyclerShallowerThanSelectedYOffsets,
85        WorkspaceCyclerConfiguration::SHALLOWER_THAN_SELECTED_Y_OFFSETS },
86      { prefs::kWorkspaceCyclerDeeperThanSelectedYOffsets,
87        WorkspaceCyclerConfiguration::DEEPER_THAN_SELECTED_Y_OFFSETS },
88      { prefs::kWorkspaceCyclerSelectedYOffset,
89        WorkspaceCyclerConfiguration::SELECTED_Y_OFFSET },
90      { prefs::kWorkspaceCyclerSelectedScale,
91        WorkspaceCyclerConfiguration::SELECTED_SCALE },
92      { prefs::kWorkspaceCyclerMinScale,
93        WorkspaceCyclerConfiguration::MIN_SCALE },
94      { prefs::kWorkspaceCyclerMaxScale,
95        WorkspaceCyclerConfiguration::MAX_SCALE },
96      { prefs::kWorkspaceCyclerMinBrightness,
97        WorkspaceCyclerConfiguration::MIN_BRIGHTNESS },
98      { prefs::kWorkspaceCyclerBackgroundOpacity,
99        WorkspaceCyclerConfiguration::BACKGROUND_OPACITY },
100      { prefs::kWorkspaceCyclerDesktopWorkspaceBrightness,
101        WorkspaceCyclerConfiguration::DESKTOP_WORKSPACE_BRIGHTNESS },
102      { prefs::kWorkspaceCyclerDistanceToInitiateCycling,
103        WorkspaceCyclerConfiguration::DISTANCE_TO_INITIATE_CYCLING },
104      { prefs::kWorkspaceCyclerScrollDistanceToCycleToNextWorkspace,
105        WorkspaceCyclerConfiguration::
106            SCROLL_DISTANCE_TO_CYCLE_TO_NEXT_WORKSPACE },
107      { prefs::kWorkspaceCyclerCyclerStepAnimationDurationRatio,
108        WorkspaceCyclerConfiguration::CYCLER_STEP_ANIMATION_DURATION_RATIO },
109      { prefs::kWorkspaceCyclerStartCyclerAnimationDuration,
110        WorkspaceCyclerConfiguration::START_CYCLER_ANIMATION_DURATION },
111      { prefs::kWorkspaceCyclerStopCyclerAnimationDuration,
112        WorkspaceCyclerConfiguration::STOP_CYCLER_ANIMATION_DURATION },
113    };
114    cycler_prefs.assign(kCyclerPrefs, kCyclerPrefs + arraysize(kCyclerPrefs));
115  }
116  return cycler_prefs;
117}
118#endif  // USE_ASH
119
120// This class manages gesture configuration preferences.
121class GesturePrefsObserver : public ProfileKeyedService {
122 public:
123  explicit GesturePrefsObserver(PrefService* prefs);
124  virtual ~GesturePrefsObserver();
125
126  // ProfileKeyedService implementation.
127  virtual void Shutdown() OVERRIDE;
128
129 private:
130  // Notification callback invoked when browser-side preferences
131  // are updated and need to be pushed into ui::GesturePreferences.
132  void Update();
133
134  // Notification callback invoked when the fling deacceleration
135  // gesture preferences are changed from chrome://gesture.
136  // Broadcasts the changes all renderers where they are used.
137  void Notify();
138
139  // Notification helper to push overscroll preferences into
140  // content.
141  void UpdateOverscrollPrefs();
142
143  void UpdateImmersiveModePrefs();
144  void UpdateWorkspaceCyclerPrefs();
145
146  PrefChangeRegistrar registrar_;
147  PrefService* prefs_;
148
149  DISALLOW_COPY_AND_ASSIGN(GesturePrefsObserver);
150};
151
152// The list of prefs we want to observe.
153// Note that this collection of settings should correspond to the settings used
154// in ui/base/gestures/gesture_configuration.h
155const char* kPrefsToObserve[] = {
156  prefs::kFlingAccelerationCurveCoefficient0,
157  prefs::kFlingAccelerationCurveCoefficient1,
158  prefs::kFlingAccelerationCurveCoefficient2,
159  prefs::kFlingAccelerationCurveCoefficient3,
160  prefs::kFlingMaxCancelToDownTimeInMs,
161  prefs::kFlingMaxTapGapTimeInMs,
162  prefs::kTabScrubActivationDelayInMS,
163  prefs::kFlingVelocityCap,
164  prefs::kLongPressTimeInSeconds,
165  prefs::kMaxDistanceForTwoFingerTapInPixels,
166  prefs::kMaxSecondsBetweenDoubleClick,
167  prefs::kMaxSeparationForGestureTouchesInPixels,
168  prefs::kMaxSwipeDeviationRatio,
169  prefs::kMaxTouchDownDurationInSecondsForClick,
170  prefs::kMaxTouchMoveInPixelsForClick,
171  prefs::kMinDistanceForPinchScrollInPixels,
172  prefs::kMinFlickSpeedSquared,
173  prefs::kMinPinchUpdateDistanceInPixels,
174  prefs::kMinRailBreakVelocity,
175  prefs::kMinScrollDeltaSquared,
176  prefs::kMinSwipeSpeed,
177  prefs::kMinTouchDownDurationInSecondsForClick,
178  prefs::kPointsBufferedForVelocity,
179  prefs::kRailBreakProportion,
180  prefs::kRailStartProportion,
181  prefs::kSemiLongPressTimeInSeconds,
182};
183
184const char* kFlingTouchpadPrefs[] = {
185  prefs::kFlingCurveTouchpadAlpha,
186  prefs::kFlingCurveTouchpadBeta,
187  prefs::kFlingCurveTouchpadGamma
188};
189
190const char* kFlingTouchscreenPrefs[] = {
191  prefs::kFlingCurveTouchscreenAlpha,
192  prefs::kFlingCurveTouchscreenBeta,
193  prefs::kFlingCurveTouchscreenGamma,
194};
195
196GesturePrefsObserver::GesturePrefsObserver(PrefService* prefs)
197    : prefs_(prefs) {
198  // Clear for migration.
199  prefs->ClearPref(kTouchScreenFlingAccelerationAdjustment);
200
201  registrar_.Init(prefs);
202  registrar_.RemoveAll();
203  base::Closure callback = base::Bind(&GesturePrefsObserver::Update,
204                                      base::Unretained(this));
205
206  base::Closure notify_callback = base::Bind(&GesturePrefsObserver::Notify,
207                                             base::Unretained(this));
208
209  for (size_t i = 0; i < arraysize(kPrefsToObserve); ++i)
210    registrar_.Add(kPrefsToObserve[i], callback);
211
212  const std::vector<OverscrollPref>& overscroll_prefs = GetOverscrollPrefs();
213  for (size_t i = 0; i < overscroll_prefs.size(); ++i)
214    registrar_.Add(overscroll_prefs[i].pref_name, callback);
215
216  for (size_t i = 0; i < arraysize(kFlingTouchpadPrefs); ++i)
217    registrar_.Add(kFlingTouchpadPrefs[i], notify_callback);
218  for (size_t i = 0; i < arraysize(kFlingTouchscreenPrefs); ++i)
219    registrar_.Add(kFlingTouchscreenPrefs[i], notify_callback);
220
221#if defined(USE_ASH)
222  for (size_t i = 0; i < arraysize(kImmersiveModePrefs); ++i)
223    registrar_.Add(kImmersiveModePrefs[i], callback);
224
225  const std::vector<WorkspaceCyclerPref>& cycler_prefs =
226      GetWorkspaceCyclerPrefs();
227  for (size_t i = 0; i < cycler_prefs.size(); ++i)
228    registrar_.Add(cycler_prefs[i].pref_name, callback);
229#endif  // USE_ASH
230  Update();
231}
232
233GesturePrefsObserver::~GesturePrefsObserver() {}
234
235void GesturePrefsObserver::Shutdown() {
236  registrar_.RemoveAll();
237}
238
239void GesturePrefsObserver::Update() {
240  GestureConfiguration::set_fling_acceleration_curve_coefficients(0,
241      prefs_->GetDouble(prefs::kFlingAccelerationCurveCoefficient0));
242  GestureConfiguration::set_fling_acceleration_curve_coefficients(1,
243      prefs_->GetDouble(prefs::kFlingAccelerationCurveCoefficient1));
244  GestureConfiguration::set_fling_acceleration_curve_coefficients(2,
245      prefs_->GetDouble(prefs::kFlingAccelerationCurveCoefficient2));
246  GestureConfiguration::set_fling_acceleration_curve_coefficients(3,
247      prefs_->GetDouble(prefs::kFlingAccelerationCurveCoefficient3));
248  GestureConfiguration::set_fling_max_cancel_to_down_time_in_ms(
249      prefs_->GetInteger(prefs::kFlingMaxCancelToDownTimeInMs));
250  GestureConfiguration::set_fling_max_tap_gap_time_in_ms(
251      prefs_->GetInteger(prefs::kFlingMaxTapGapTimeInMs));
252  GestureConfiguration::set_tab_scrub_activation_delay_in_ms(
253      prefs_->GetInteger(prefs::kTabScrubActivationDelayInMS));
254  GestureConfiguration::set_fling_velocity_cap(
255      prefs_->GetDouble(prefs::kFlingVelocityCap));
256  GestureConfiguration::set_long_press_time_in_seconds(
257      prefs_->GetDouble(
258          prefs::kLongPressTimeInSeconds));
259  GestureConfiguration::set_semi_long_press_time_in_seconds(
260      prefs_->GetDouble(
261          prefs::kSemiLongPressTimeInSeconds));
262  GestureConfiguration::set_max_distance_for_two_finger_tap_in_pixels(
263      prefs_->GetDouble(
264          prefs::kMaxDistanceForTwoFingerTapInPixels));
265  GestureConfiguration::set_max_seconds_between_double_click(
266      prefs_->GetDouble(
267          prefs::kMaxSecondsBetweenDoubleClick));
268  GestureConfiguration::set_max_separation_for_gesture_touches_in_pixels(
269      prefs_->GetDouble(
270          prefs::kMaxSeparationForGestureTouchesInPixels));
271  GestureConfiguration::set_max_swipe_deviation_ratio(
272      prefs_->GetDouble(
273          prefs::kMaxSwipeDeviationRatio));
274  GestureConfiguration::set_max_touch_down_duration_in_seconds_for_click(
275      prefs_->GetDouble(
276          prefs::kMaxTouchDownDurationInSecondsForClick));
277  GestureConfiguration::set_max_touch_move_in_pixels_for_click(
278      prefs_->GetDouble(
279          prefs::kMaxTouchMoveInPixelsForClick));
280  GestureConfiguration::set_max_distance_between_taps_for_double_tap(
281      prefs_->GetDouble(
282          prefs::kMaxDistanceBetweenTapsForDoubleTap));
283  GestureConfiguration::set_min_distance_for_pinch_scroll_in_pixels(
284      prefs_->GetDouble(
285          prefs::kMinDistanceForPinchScrollInPixels));
286  GestureConfiguration::set_min_flick_speed_squared(
287      prefs_->GetDouble(
288          prefs::kMinFlickSpeedSquared));
289  GestureConfiguration::set_min_pinch_update_distance_in_pixels(
290      prefs_->GetDouble(
291          prefs::kMinPinchUpdateDistanceInPixels));
292  GestureConfiguration::set_min_rail_break_velocity(
293      prefs_->GetDouble(
294          prefs::kMinRailBreakVelocity));
295  GestureConfiguration::set_min_scroll_delta_squared(
296      prefs_->GetDouble(
297          prefs::kMinScrollDeltaSquared));
298  GestureConfiguration::set_min_swipe_speed(
299      prefs_->GetDouble(
300          prefs::kMinSwipeSpeed));
301  GestureConfiguration::set_min_touch_down_duration_in_seconds_for_click(
302      prefs_->GetDouble(
303          prefs::kMinTouchDownDurationInSecondsForClick));
304  GestureConfiguration::set_points_buffered_for_velocity(
305      prefs_->GetInteger(
306          prefs::kPointsBufferedForVelocity));
307  GestureConfiguration::set_rail_break_proportion(
308      prefs_->GetDouble(
309          prefs::kRailBreakProportion));
310  GestureConfiguration::set_rail_start_proportion(
311      prefs_->GetDouble(
312          prefs::kRailStartProportion));
313
314  UpdateOverscrollPrefs();
315  UpdateImmersiveModePrefs();
316  UpdateWorkspaceCyclerPrefs();
317}
318
319void GesturePrefsObserver::UpdateOverscrollPrefs() {
320  const std::vector<OverscrollPref>& overscroll_prefs = GetOverscrollPrefs();
321  for (size_t i = 0; i < overscroll_prefs.size(); ++i) {
322    content::SetOverscrollConfig(overscroll_prefs[i].config,
323        static_cast<float>(prefs_->GetDouble(overscroll_prefs[i].pref_name)));
324  }
325}
326
327void GesturePrefsObserver::UpdateImmersiveModePrefs() {
328#if defined(USE_ASH)
329  GestureConfiguration::set_immersive_mode_reveal_delay_ms(
330      prefs_->GetInteger(prefs::kImmersiveModeRevealDelayMs));
331  GestureConfiguration::set_immersive_mode_reveal_x_threshold_pixels(
332      prefs_->GetInteger(prefs::kImmersiveModeRevealXThresholdPixels));
333#endif  // USE_ASH
334}
335
336void GesturePrefsObserver::UpdateWorkspaceCyclerPrefs() {
337#if defined(USE_ASH)
338  const std::vector<WorkspaceCyclerPref>& cycler_prefs =
339      GetWorkspaceCyclerPrefs();
340  for (size_t i = 0; i < cycler_prefs.size(); ++i) {
341    WorkspaceCyclerConfiguration::Property property =
342        cycler_prefs[i].property;
343    if (WorkspaceCyclerConfiguration::IsListProperty(property)) {
344      WorkspaceCyclerConfiguration::SetListValue(property,
345          *prefs_->GetList(cycler_prefs[i].pref_name));
346    } else {
347      WorkspaceCyclerConfiguration::SetDouble(property,
348          prefs_->GetDouble(cycler_prefs[i].pref_name));
349    }
350  }
351#endif  // USE_ASH
352}
353
354void GesturePrefsObserver::Notify() {
355  // Must do a notify to distribute the changes to all renderers.
356  content::NotificationService* service =
357      content::NotificationService::current();
358  service->Notify(chrome::NOTIFICATION_BROWSER_FLING_CURVE_PARAMETERS_CHANGED,
359                  content::Source<GesturePrefsObserver>(this),
360                  content::NotificationService::NoDetails());
361}
362
363}  // namespace
364
365// static
366GesturePrefsObserverFactoryAura*
367GesturePrefsObserverFactoryAura::GetInstance() {
368  return Singleton<GesturePrefsObserverFactoryAura>::get();
369}
370
371GesturePrefsObserverFactoryAura::GesturePrefsObserverFactoryAura()
372    : ProfileKeyedServiceFactory("GesturePrefsObserverAura",
373                                 ProfileDependencyManager::GetInstance()) {}
374
375GesturePrefsObserverFactoryAura::~GesturePrefsObserverFactoryAura() {}
376
377ProfileKeyedService* GesturePrefsObserverFactoryAura::BuildServiceInstanceFor(
378    content::BrowserContext* profile) const {
379  return new GesturePrefsObserver(static_cast<Profile*>(profile)->GetPrefs());
380}
381
382void GesturePrefsObserverFactoryAura::RegisterOverscrollPrefs(
383    user_prefs::PrefRegistrySyncable* registry) {
384  const std::vector<OverscrollPref>& overscroll_prefs = GetOverscrollPrefs();
385
386  for (size_t i = 0; i < overscroll_prefs.size(); ++i) {
387    registry->RegisterDoublePref(
388        overscroll_prefs[i].pref_name,
389        content::GetOverscrollConfig(overscroll_prefs[i].config),
390        user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
391  }
392}
393
394void GesturePrefsObserverFactoryAura::RegisterFlingCurveParameters(
395    user_prefs::PrefRegistrySyncable* registry) {
396  content::RendererPreferences def_prefs;
397
398  for (size_t i = 0; i < arraysize(kFlingTouchpadPrefs); i++)
399    registry->RegisterDoublePref(
400        kFlingTouchpadPrefs[i],
401        def_prefs.touchpad_fling_profile[i],
402        user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
403
404  for (size_t i = 0; i < arraysize(kFlingTouchscreenPrefs); i++)
405    registry->RegisterDoublePref(
406        kFlingTouchscreenPrefs[i],
407        def_prefs.touchscreen_fling_profile[i],
408        user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
409}
410
411void GesturePrefsObserverFactoryAura::RegisterImmersiveModePrefs(
412    user_prefs::PrefRegistrySyncable* registry) {
413#if defined(USE_ASH)
414  registry->RegisterIntegerPref(
415      prefs::kImmersiveModeRevealDelayMs,
416      GestureConfiguration::immersive_mode_reveal_delay_ms(),
417      user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
418  registry->RegisterIntegerPref(
419      prefs::kImmersiveModeRevealXThresholdPixels,
420      GestureConfiguration::immersive_mode_reveal_x_threshold_pixels(),
421      user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
422#endif  // USE_ASH
423}
424
425void GesturePrefsObserverFactoryAura::RegisterWorkspaceCyclerPrefs(
426    user_prefs::PrefRegistrySyncable* registry) {
427#if defined(USE_ASH)
428  const std::vector<WorkspaceCyclerPref>& cycler_prefs =
429      GetWorkspaceCyclerPrefs();
430  for (size_t i = 0; i < cycler_prefs.size(); ++i) {
431    WorkspaceCyclerConfiguration::Property property =
432        cycler_prefs[i].property;
433    if (WorkspaceCyclerConfiguration::IsListProperty(property)) {
434      registry->RegisterListPref(
435          cycler_prefs[i].pref_name,
436          WorkspaceCyclerConfiguration::GetListValue(property).DeepCopy(),
437          user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
438    } else {
439      registry->RegisterDoublePref(
440          cycler_prefs[i].pref_name,
441          WorkspaceCyclerConfiguration::GetDouble(property),
442          user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
443    }
444  }
445#endif  // USE_ASH
446}
447
448void GesturePrefsObserverFactoryAura::RegisterUserPrefs(
449    user_prefs::PrefRegistrySyncable* registry) {
450  registry->RegisterDoublePref(
451      prefs::kFlingAccelerationCurveCoefficient0,
452      GestureConfiguration::fling_acceleration_curve_coefficients(0),
453      user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
454  registry->RegisterDoublePref(
455      prefs::kFlingAccelerationCurveCoefficient1,
456      GestureConfiguration::fling_acceleration_curve_coefficients(1),
457      user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
458  registry->RegisterDoublePref(
459      prefs::kFlingAccelerationCurveCoefficient2,
460      GestureConfiguration::fling_acceleration_curve_coefficients(2),
461      user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
462  registry->RegisterDoublePref(
463      prefs::kFlingAccelerationCurveCoefficient3,
464      GestureConfiguration::fling_acceleration_curve_coefficients(3),
465      user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
466  registry->RegisterIntegerPref(
467      prefs::kFlingMaxCancelToDownTimeInMs,
468      GestureConfiguration::fling_max_cancel_to_down_time_in_ms(),
469      user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
470  registry->RegisterIntegerPref(
471      prefs::kFlingMaxTapGapTimeInMs,
472      GestureConfiguration::fling_max_tap_gap_time_in_ms(),
473      user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
474  registry->RegisterIntegerPref(
475      prefs::kTabScrubActivationDelayInMS,
476      GestureConfiguration::tab_scrub_activation_delay_in_ms(),
477      user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
478  registry->RegisterDoublePref(
479      prefs::kFlingVelocityCap,
480      GestureConfiguration::fling_velocity_cap(),
481      user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
482  registry->RegisterDoublePref(
483      prefs::kLongPressTimeInSeconds,
484      GestureConfiguration::long_press_time_in_seconds(),
485      user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
486  registry->RegisterDoublePref(
487      prefs::kSemiLongPressTimeInSeconds,
488      GestureConfiguration::semi_long_press_time_in_seconds(),
489      user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
490  registry->RegisterDoublePref(
491      prefs::kMaxDistanceForTwoFingerTapInPixels,
492      GestureConfiguration::max_distance_for_two_finger_tap_in_pixels(),
493      user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
494  registry->RegisterDoublePref(
495      prefs::kMaxSecondsBetweenDoubleClick,
496      GestureConfiguration::max_seconds_between_double_click(),
497      user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
498  registry->RegisterDoublePref(
499      prefs::kMaxSeparationForGestureTouchesInPixels,
500      GestureConfiguration::max_separation_for_gesture_touches_in_pixels(),
501      user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
502  registry->RegisterDoublePref(
503      prefs::kMaxSwipeDeviationRatio,
504      GestureConfiguration::max_swipe_deviation_ratio(),
505      user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
506  registry->RegisterDoublePref(
507      prefs::kMaxTouchDownDurationInSecondsForClick,
508      GestureConfiguration::max_touch_down_duration_in_seconds_for_click(),
509      user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
510  registry->RegisterDoublePref(
511      prefs::kMaxTouchMoveInPixelsForClick,
512      GestureConfiguration::max_touch_move_in_pixels_for_click(),
513      user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
514  registry->RegisterDoublePref(
515      prefs::kMaxDistanceBetweenTapsForDoubleTap,
516      GestureConfiguration::max_distance_between_taps_for_double_tap(),
517      user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
518  registry->RegisterDoublePref(
519      prefs::kMinDistanceForPinchScrollInPixels,
520      GestureConfiguration::min_distance_for_pinch_scroll_in_pixels(),
521      user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
522  registry->RegisterDoublePref(
523      prefs::kMinFlickSpeedSquared,
524      GestureConfiguration::min_flick_speed_squared(),
525      user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
526  registry->RegisterDoublePref(
527      prefs::kMinPinchUpdateDistanceInPixels,
528      GestureConfiguration::min_pinch_update_distance_in_pixels(),
529      user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
530  registry->RegisterDoublePref(
531      prefs::kMinRailBreakVelocity,
532      GestureConfiguration::min_rail_break_velocity(),
533      user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
534  registry->RegisterDoublePref(
535      prefs::kMinScrollDeltaSquared,
536      GestureConfiguration::min_scroll_delta_squared(),
537      user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
538  registry->RegisterDoublePref(
539      prefs::kMinSwipeSpeed,
540      GestureConfiguration::min_swipe_speed(),
541      user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
542  registry->RegisterDoublePref(
543      prefs::kMinTouchDownDurationInSecondsForClick,
544      GestureConfiguration::min_touch_down_duration_in_seconds_for_click(),
545      user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
546  registry->RegisterIntegerPref(
547      prefs::kPointsBufferedForVelocity,
548      GestureConfiguration::points_buffered_for_velocity(),
549      user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
550  registry->RegisterDoublePref(
551      prefs::kRailBreakProportion,
552      GestureConfiguration::rail_break_proportion(),
553      user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
554  registry->RegisterDoublePref(
555      prefs::kRailStartProportion,
556      GestureConfiguration::rail_start_proportion(),
557      user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
558
559  // Register for migration.
560  registry->RegisterDoublePref(
561      kTouchScreenFlingAccelerationAdjustment,
562      0.0,
563      user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
564
565  RegisterOverscrollPrefs(registry);
566  RegisterFlingCurveParameters(registry);
567  RegisterImmersiveModePrefs(registry);
568  RegisterWorkspaceCyclerPrefs(registry);
569}
570
571bool GesturePrefsObserverFactoryAura::ServiceIsCreatedWithProfile() const {
572  // Create the observer as soon as the profile is created.
573  return true;
574}
575
576content::BrowserContext*
577GesturePrefsObserverFactoryAura::GetBrowserContextToUse(
578    content::BrowserContext* context) const {
579  // Use same gesture preferences on incognito windows.
580  return chrome::GetBrowserContextRedirectedInIncognito(context);
581}
582
583bool GesturePrefsObserverFactoryAura::ServiceIsNULLWhileTesting() const {
584  // Some tests replace the PrefService of the TestingProfile after the
585  // GesturePrefsObserver has been created, which makes Shutdown()
586  // remove the registrar from a non-existent PrefService.
587  return true;
588}
589