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