chrome/browser/chromeos/preferences.cc

   1 // Copyright (c) 2012 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/chromeos/preferences.h"
   6
   7 #include <vector>
   8
   9 #include "ash/autoclick/autoclick_controller.h"
  10 #include "ash/shell.h"
  11 #include "base/command_line.h"
  12 #include "base/i18n/time_formatting.h"
  13 #include "base/metrics/histogram.h"
  14 #include "base/prefs/pref_member.h"
  15 #include "base/prefs/pref_registry_simple.h"
  16 #include "base/prefs/scoped_user_pref_update.h"
  17 #include "base/strings/string_split.h"
  18 #include "base/strings/string_util.h"
  19 #include "base/strings/utf_string_conversions.h"
  20 #include "base/sys_info.h"
  21 #include "chrome/browser/browser_process.h"
  22 #include "chrome/browser/chrome_notification_types.h"
  23 #include "chrome/browser/chromeos/accessibility/magnification_manager.h"
  24 #include "chrome/browser/chromeos/drive/file_system_util.h"
  25 #include "chrome/browser/chromeos/input_method/input_method_syncer.h"
  26 #include "chrome/browser/chromeos/login/session/user_session_manager.h"
  27 #include "chrome/browser/chromeos/net/wake_on_wifi_manager.h"
  28 #include "chrome/browser/chromeos/system/input_device_settings.h"
  29 #include "chrome/browser/download/download_prefs.h"
  30 #include "chrome/browser/prefs/pref_service_syncable.h"
  31 #include "chrome/common/chrome_switches.h"
  32 #include "chrome/common/pref_names.h"
  33 #include "chromeos/chromeos_switches.h"
  34 #include "chromeos/system/statistics_provider.h"
  35 #include "chromeos/timezone/timezone_resolver.h"
  36 #include "components/feedback/tracing_manager.h"
  37 #include "components/pref_registry/pref_registry_syncable.h"
  38 #include "components/user_manager/user.h"
  39 #include "content/public/browser/browser_thread.h"
  40 #include "third_party/icu/source/i18n/unicode/timezone.h"
  41 #include "ui/base/ime/chromeos/extension_ime_util.h"
  42 #include "ui/base/ime/chromeos/ime_keyboard.h"
  43 #include "ui/base/ime/chromeos/input_method_manager.h"
  44 #include "ui/chromeos/accessibility_types.h"
  45 #include "ui/events/event_constants.h"
  46 #include "ui/events/event_utils.h"
  47 #include "url/gurl.h"
  48
  49 namespace chromeos {
  50
  51 static const char kFallbackInputMethodLocale[] = "en-US";
  52
  53 Preferences::Preferences()
  54     : prefs_(NULL),
  55       input_method_manager_(input_method::InputMethodManager::Get()),
  56       user_(NULL),
  57       user_is_primary_(false) {
  58   // Do not observe shell, if there is no shell instance; e.g., in some unit
  59   // tests.
  60   if (ash::Shell::HasInstance())
  61     ash::Shell::GetInstance()->AddShellObserver(this);
  62 }
  63
  64 Preferences::Preferences(input_method::InputMethodManager* input_method_manager)
  65     : prefs_(NULL),
  66       input_method_manager_(input_method_manager),
  67       user_(NULL),
  68       user_is_primary_(false) {
  69   // Do not observe shell, if there is no shell instance; e.g., in some unit
  70   // tests.
  71   if (ash::Shell::HasInstance())
  72     ash::Shell::GetInstance()->AddShellObserver(this);
  73 }
  74
  75 Preferences::~Preferences() {
  76   prefs_->RemoveObserver(this);
  77   user_manager::UserManager::Get()->RemoveSessionStateObserver(this);
  78   // If shell instance is destoryed before this preferences instance, there is
  79   // no need to remove this shell observer.
  80   if (ash::Shell::HasInstance())
  81     ash::Shell::GetInstance()->RemoveShellObserver(this);
  82 }
  83
  84 // static
  85 void Preferences::RegisterPrefs(PrefRegistrySimple* registry) {
  86   registry->RegisterBooleanPref(prefs::kOwnerPrimaryMouseButtonRight, false);
  87   registry->RegisterBooleanPref(prefs::kOwnerTapToClickEnabled, true);
  88   registry->RegisterBooleanPref(prefs::kAccessibilityVirtualKeyboardEnabled,
  89                                 false);
  90   registry->RegisterStringPref(prefs::kLogoutStartedLast, std::string());
  91   registry->RegisterBooleanPref(prefs::kResolveDeviceTimezoneByGeolocation,
  92                                 true);
  93 }
  94
  95 // static
  96 void Preferences::RegisterProfilePrefs(
  97     user_prefs::PrefRegistrySyncable* registry) {
  98   std::string hardware_keyboard_id;
  99   // TODO(yusukes): Remove the runtime hack.
 100   if (base::SysInfo::IsRunningOnChromeOS()) {
 101     DCHECK(g_browser_process);
 102     PrefService* local_state = g_browser_process->local_state();
 103     DCHECK(local_state);
 104     hardware_keyboard_id =
 105         local_state->GetString(prefs::kHardwareKeyboardLayout);
 106   } else {
 107     hardware_keyboard_id = "xkb:us::eng";  // only for testing.
 108   }
 109
 110   registry->RegisterBooleanPref(
 111       prefs::kPerformanceTracingEnabled,
 112       false,
 113       user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
 114
 115   registry->RegisterBooleanPref(
 116       prefs::kTapToClickEnabled,
 117       true,
 118       user_prefs::PrefRegistrySyncable::SYNCABLE_PRIORITY_PREF);
 119   registry->RegisterBooleanPref(
 120       prefs::kTapDraggingEnabled,
 121       false,
 122       user_prefs::PrefRegistrySyncable::SYNCABLE_PRIORITY_PREF);
 123   registry->RegisterBooleanPref(
 124       prefs::kEnableTouchpadThreeFingerClick,
 125       false,
 126       user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
 127   registry->RegisterBooleanPref(
 128       prefs::kNaturalScroll, base::CommandLine::ForCurrentProcess()->HasSwitch(
 129                                  switches::kNaturalScrollDefault),
 130       user_prefs::PrefRegistrySyncable::SYNCABLE_PRIORITY_PREF);
 131   registry->RegisterBooleanPref(
 132       prefs::kPrimaryMouseButtonRight,
 133       false,
 134       user_prefs::PrefRegistrySyncable::SYNCABLE_PRIORITY_PREF);
 135   registry->RegisterBooleanPref(
 136       prefs::kLabsMediaplayerEnabled,
 137       false,
 138       user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
 139   registry->RegisterBooleanPref(
 140       prefs::kLabsAdvancedFilesystemEnabled,
 141       false,
 142       user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
 143   registry->RegisterBooleanPref(
 144       prefs::kAccessibilityStickyKeysEnabled,
 145       false,
 146       user_prefs::PrefRegistrySyncable::SYNCABLE_PREF);
 147   registry->RegisterBooleanPref(
 148       prefs::kAccessibilityLargeCursorEnabled,
 149       false,
 150       user_prefs::PrefRegistrySyncable::SYNCABLE_PREF);
 151   registry->RegisterBooleanPref(
 152       prefs::kAccessibilitySpokenFeedbackEnabled,
 153       false,
 154       user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
 155   registry->RegisterBooleanPref(
 156       prefs::kAccessibilityHighContrastEnabled,
 157       false,
 158       user_prefs::PrefRegistrySyncable::SYNCABLE_PREF);
 159   registry->RegisterBooleanPref(
 160       prefs::kAccessibilityScreenMagnifierEnabled,
 161       false,
 162       user_prefs::PrefRegistrySyncable::SYNCABLE_PREF);
 163   registry->RegisterIntegerPref(
 164       prefs::kAccessibilityScreenMagnifierType,
 165       ui::kDefaultMagnifierType,
 166       user_prefs::PrefRegistrySyncable::SYNCABLE_PREF);
 167   registry->RegisterDoublePref(
 168       prefs::kAccessibilityScreenMagnifierScale,
 169       std::numeric_limits<double>::min(),
 170       user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
 171   registry->RegisterBooleanPref(
 172       prefs::kAccessibilityAutoclickEnabled,
 173       false,
 174       user_prefs::PrefRegistrySyncable::SYNCABLE_PREF);
 175   registry->RegisterIntegerPref(
 176       prefs::kAccessibilityAutoclickDelayMs,
 177       ash::AutoclickController::kDefaultAutoclickDelayMs,
 178       user_prefs::PrefRegistrySyncable::SYNCABLE_PREF);
 179   registry->RegisterBooleanPref(
 180       prefs::kAccessibilityVirtualKeyboardEnabled,
 181       false,
 182       user_prefs::PrefRegistrySyncable::SYNCABLE_PREF);
 183   registry->RegisterBooleanPref(
 184       prefs::kShouldAlwaysShowAccessibilityMenu,
 185       false,
 186       user_prefs::PrefRegistrySyncable::SYNCABLE_PREF);
 187   registry->RegisterIntegerPref(
 188       prefs::kMouseSensitivity,
 189       3,
 190       user_prefs::PrefRegistrySyncable::SYNCABLE_PRIORITY_PREF);
 191   registry->RegisterIntegerPref(
 192       prefs::kTouchpadSensitivity,
 193       3,
 194       user_prefs::PrefRegistrySyncable::SYNCABLE_PRIORITY_PREF);
 195   registry->RegisterBooleanPref(
 196       prefs::kUse24HourClock,
 197       base::GetHourClockType() == base::k24HourClock,
 198       user_prefs::PrefRegistrySyncable::SYNCABLE_PREF);
 199   registry->RegisterBooleanPref(
 200       prefs::kDisableDrive,
 201       false,
 202       user_prefs::PrefRegistrySyncable::SYNCABLE_PREF);
 203   registry->RegisterBooleanPref(
 204       prefs::kDisableDriveOverCellular,
 205       true,
 206       user_prefs::PrefRegistrySyncable::SYNCABLE_PREF);
 207   registry->RegisterBooleanPref(
 208       prefs::kDisableDriveHostedFiles,
 209       false,
 210       user_prefs::PrefRegistrySyncable::SYNCABLE_PREF);
 211   // We don't sync prefs::kLanguageCurrentInputMethod and PreviousInputMethod
 212   // because they're just used to track the logout state of the device.
 213   registry->RegisterStringPref(
 214       prefs::kLanguageCurrentInputMethod,
 215       "",
 216       user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
 217   registry->RegisterStringPref(
 218       prefs::kLanguagePreviousInputMethod,
 219       "",
 220       user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
 221   registry->RegisterStringPref(
 222       prefs::kLanguagePreferredLanguages,
 223       kFallbackInputMethodLocale,
 224       user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
 225   registry->RegisterStringPref(
 226       prefs::kLanguagePreloadEngines,
 227       hardware_keyboard_id,
 228       user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
 229   registry->RegisterStringPref(
 230       prefs::kLanguageEnabledExtensionImes,
 231       "",
 232       user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
 233
 234   registry->RegisterIntegerPref(
 235       prefs::kLanguageRemapSearchKeyTo,
 236       input_method::kSearchKey,
 237       user_prefs::PrefRegistrySyncable::SYNCABLE_PRIORITY_PREF);
 238   registry->RegisterIntegerPref(
 239       prefs::kLanguageRemapControlKeyTo,
 240       input_method::kControlKey,
 241       user_prefs::PrefRegistrySyncable::SYNCABLE_PRIORITY_PREF);
 242   registry->RegisterIntegerPref(
 243       prefs::kLanguageRemapAltKeyTo,
 244       input_method::kAltKey,
 245       user_prefs::PrefRegistrySyncable::SYNCABLE_PRIORITY_PREF);
 246   // We don't sync the CapsLock remapping pref, since the UI hides this pref
 247   // on certain devices, so syncing a non-default value to a device that
 248   // doesn't allow changing the pref would be odd. http://crbug.com/167237
 249   registry->RegisterIntegerPref(
 250       prefs::kLanguageRemapCapsLockKeyTo,
 251       input_method::kCapsLockKey,
 252       user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
 253   registry->RegisterIntegerPref(
 254       prefs::kLanguageRemapDiamondKeyTo,
 255       input_method::kControlKey,
 256       user_prefs::PrefRegistrySyncable::SYNCABLE_PRIORITY_PREF);
 257   // The following pref isn't synced since the user may desire a different value
 258   // depending on whether an external keyboard is attached to a particular
 259   // device.
 260   registry->RegisterBooleanPref(
 261       prefs::kLanguageSendFunctionKeys,
 262       false,
 263       user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
 264   registry->RegisterBooleanPref(
 265       prefs::kLanguageXkbAutoRepeatEnabled,
 266       true,
 267       user_prefs::PrefRegistrySyncable::SYNCABLE_PREF);
 268   registry->RegisterIntegerPref(
 269       prefs::kLanguageXkbAutoRepeatDelay,
 270       language_prefs::kXkbAutoRepeatDelayInMs,
 271       user_prefs::PrefRegistrySyncable::SYNCABLE_PREF);
 272   registry->RegisterIntegerPref(
 273       prefs::kLanguageXkbAutoRepeatInterval,
 274       language_prefs::kXkbAutoRepeatIntervalInMs,
 275       user_prefs::PrefRegistrySyncable::SYNCABLE_PREF);
 276
 277   // We don't sync wake-on-wifi related prefs because they are device specific.
 278   registry->RegisterBooleanPref(
 279       prefs::kWakeOnWifiSsid,
 280       true,
 281       user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
 282
 283   // Mobile plan notifications default to on.
 284   registry->RegisterBooleanPref(
 285       prefs::kShowPlanNotifications,
 286       true,
 287       user_prefs::PrefRegistrySyncable::SYNCABLE_PREF);
 288
 289   // 3G first-time usage promo will be shown at least once.
 290   registry->RegisterBooleanPref(
 291       prefs::kShow3gPromoNotification,
 292       true,
 293       user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
 294
 295   // Initially all existing users would see "What's new" for current version
 296   // after update.
 297   registry->RegisterStringPref(prefs::kChromeOSReleaseNotesVersion,
 298                                "0.0.0.0",
 299                                user_prefs::PrefRegistrySyncable::SYNCABLE_PREF);
 300
 301   registry->RegisterBooleanPref(
 302       prefs::kExternalStorageDisabled,
 303       false,
 304       user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
 305
 306   registry->RegisterStringPref(
 307       prefs::kTermsOfServiceURL,
 308       "",
 309       user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
 310
 311   registry->RegisterBooleanPref(
 312       prefs::kTouchHudProjectionEnabled,
 313       false,
 314       user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
 315
 316   registry->RegisterBooleanPref(
 317       prefs::kTouchVirtualKeyboardEnabled,
 318       false,
 319       user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
 320
 321   registry->RegisterBooleanPref(
 322       prefs::kResolveTimezoneByGeolocation, true,
 323       user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
 324
 325   input_method::InputMethodSyncer::RegisterProfilePrefs(registry);
 326 }
 327
 328 void Preferences::InitUserPrefs(PrefServiceSyncable* prefs) {
 329   prefs_ = prefs;
 330
 331   BooleanPrefMember::NamedChangeCallback callback =
 332       base::Bind(&Preferences::OnPreferenceChanged, base::Unretained(this));
 333
 334   performance_tracing_enabled_.Init(prefs::kPerformanceTracingEnabled,
 335                                     prefs, callback);
 336   tap_to_click_enabled_.Init(prefs::kTapToClickEnabled, prefs, callback);
 337   tap_dragging_enabled_.Init(prefs::kTapDraggingEnabled, prefs, callback);
 338   three_finger_click_enabled_.Init(prefs::kEnableTouchpadThreeFingerClick,
 339       prefs, callback);
 340   natural_scroll_.Init(prefs::kNaturalScroll, prefs, callback);
 341   mouse_sensitivity_.Init(prefs::kMouseSensitivity, prefs, callback);
 342   touchpad_sensitivity_.Init(prefs::kTouchpadSensitivity, prefs, callback);
 343   primary_mouse_button_right_.Init(prefs::kPrimaryMouseButtonRight,
 344                                    prefs, callback);
 345   download_default_directory_.Init(prefs::kDownloadDefaultDirectory,
 346                                    prefs, callback);
 347   touch_hud_projection_enabled_.Init(prefs::kTouchHudProjectionEnabled,
 348                                      prefs, callback);
 349   preload_engines_.Init(prefs::kLanguagePreloadEngines, prefs, callback);
 350   enabled_extension_imes_.Init(prefs::kLanguageEnabledExtensionImes,
 351                                prefs, callback);
 352   current_input_method_.Init(prefs::kLanguageCurrentInputMethod,
 353                              prefs, callback);
 354   previous_input_method_.Init(prefs::kLanguagePreviousInputMethod,
 355                               prefs, callback);
 356
 357   xkb_auto_repeat_enabled_.Init(
 358       prefs::kLanguageXkbAutoRepeatEnabled, prefs, callback);
 359   xkb_auto_repeat_delay_pref_.Init(
 360       prefs::kLanguageXkbAutoRepeatDelay, prefs, callback);
 361   xkb_auto_repeat_interval_pref_.Init(
 362       prefs::kLanguageXkbAutoRepeatInterval, prefs, callback);
 363
 364   wake_on_wifi_ssid_.Init(prefs::kWakeOnWifiSsid, prefs, callback);
 365
 366   pref_change_registrar_.Init(prefs);
 367   pref_change_registrar_.Add(prefs::kResolveTimezoneByGeolocation, callback);
 368 }
 369
 370 void Preferences::Init(Profile* profile, const user_manager::User* user) {
 371   DCHECK(profile);
 372   DCHECK(user);
 373   PrefServiceSyncable* prefs = PrefServiceSyncable::FromProfile(profile);
 374   // This causes OnIsSyncingChanged to be called when the value of
 375   // PrefService::IsSyncing() changes.
 376   prefs->AddObserver(this);
 377   user_ = user;
 378   user_is_primary_ =
 379       user_manager::UserManager::Get()->GetPrimaryUser() == user_;
 380   InitUserPrefs(prefs);
 381
 382   user_manager::UserManager::Get()->AddSessionStateObserver(this);
 383
 384   UserSessionManager* session_manager = UserSessionManager::GetInstance();
 385   DCHECK(session_manager);
 386   ime_state_ = session_manager->GetDefaultIMEState(profile);
 387
 388   // Initialize preferences to currently saved state.
 389   ApplyPreferences(REASON_INITIALIZATION, "");
 390
 391   // Note that |ime_state_| was modified by ApplyPreferences(), and
 392   // SetState() is modifying |current_input_method_| (via
 393   // PersistUserInputMethod() ). This way SetState() here may be called only
 394   // after ApplyPreferences().
 395   input_method_manager_->SetState(ime_state_);
 396
 397   input_method_syncer_.reset(
 398       new input_method::InputMethodSyncer(prefs, ime_state_));
 399   input_method_syncer_->Initialize();
 400
 401   // If a guest is logged in, initialize the prefs as if this is the first
 402   // login. For a regular user this is done in
 403   // UserSessionManager::InitProfilePreferences().
 404   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
 405           switches::kGuestSession))
 406     session_manager->SetFirstLoginPrefs(profile, std::string(), std::string());
 407 }
 408
 409 void Preferences::InitUserPrefsForTesting(
 410     PrefServiceSyncable* prefs,
 411     const user_manager::User* user,
 412     scoped_refptr<input_method::InputMethodManager::State> ime_state) {
 413   user_ = user;
 414   ime_state_ = ime_state;
 415
 416   if (ime_state.get())
 417     input_method_manager_->SetState(ime_state);
 418
 419   InitUserPrefs(prefs);
 420
 421   input_method_syncer_.reset(
 422       new input_method::InputMethodSyncer(prefs, ime_state_));
 423   input_method_syncer_->Initialize();
 424 }
 425
 426 void Preferences::SetInputMethodListForTesting() {
 427   SetInputMethodList();
 428 }
 429
 430 void Preferences::OnPreferenceChanged(const std::string& pref_name) {
 431   ApplyPreferences(REASON_PREF_CHANGED, pref_name);
 432 }
 433
 434 void Preferences::ApplyPreferences(ApplyReason reason,
 435                                    const std::string& pref_name) {
 436   DCHECK(reason != REASON_PREF_CHANGED || !pref_name.empty());
 437   const bool user_is_owner =
 438       user_manager::UserManager::Get()->GetOwnerEmail() == user_->email();
 439   const bool user_is_active = user_->is_active();
 440
 441   system::TouchpadSettings touchpad_settings;
 442   system::MouseSettings mouse_settings;
 443
 444   if (user_is_primary_ && (reason == REASON_INITIALIZATION ||
 445                            pref_name == prefs::kPerformanceTracingEnabled)) {
 446     const bool enabled = performance_tracing_enabled_.GetValue();
 447     if (enabled)
 448       tracing_manager_ = TracingManager::Create();
 449     else
 450       tracing_manager_.reset();
 451   }
 452   if (reason != REASON_PREF_CHANGED || pref_name == prefs::kTapToClickEnabled) {
 453     const bool enabled = tap_to_click_enabled_.GetValue();
 454     if (user_is_active)
 455       touchpad_settings.SetTapToClick(enabled);
 456     if (reason == REASON_PREF_CHANGED)
 457       UMA_HISTOGRAM_BOOLEAN("Touchpad.TapToClick.Changed", enabled);
 458     else if (reason == REASON_INITIALIZATION)
 459       UMA_HISTOGRAM_BOOLEAN("Touchpad.TapToClick.Started", enabled);
 460
 461     // Save owner preference in local state to use on login screen.
 462     if (user_is_owner) {
 463       PrefService* prefs = g_browser_process->local_state();
 464       if (prefs->GetBoolean(prefs::kOwnerTapToClickEnabled) != enabled)
 465         prefs->SetBoolean(prefs::kOwnerTapToClickEnabled, enabled);
 466     }
 467   }
 468   if (reason != REASON_PREF_CHANGED ||
 469       pref_name == prefs::kTapDraggingEnabled) {
 470     const bool enabled = tap_dragging_enabled_.GetValue();
 471     if (user_is_active)
 472       touchpad_settings.SetTapDragging(enabled);
 473     if (reason == REASON_PREF_CHANGED)
 474       UMA_HISTOGRAM_BOOLEAN("Touchpad.TapDragging.Changed", enabled);
 475     else if (reason == REASON_INITIALIZATION)
 476       UMA_HISTOGRAM_BOOLEAN("Touchpad.TapDragging.Started", enabled);
 477   }
 478   if (reason != REASON_PREF_CHANGED ||
 479       pref_name == prefs::kEnableTouchpadThreeFingerClick) {
 480     const bool enabled = three_finger_click_enabled_.GetValue();
 481     if (user_is_active)
 482       touchpad_settings.SetThreeFingerClick(enabled);
 483     if (reason == REASON_PREF_CHANGED)
 484       UMA_HISTOGRAM_BOOLEAN("Touchpad.ThreeFingerClick.Changed", enabled);
 485     else if (reason == REASON_INITIALIZATION)
 486       UMA_HISTOGRAM_BOOLEAN("Touchpad.ThreeFingerClick.Started", enabled);
 487   }
 488   if (reason != REASON_PREF_CHANGED || pref_name == prefs::kNaturalScroll) {
 489     // Force natural scroll default if we've sync'd and if the cmd line arg is
 490     // set.
 491     ForceNaturalScrollDefault();
 492
 493     const bool enabled = natural_scroll_.GetValue();
 494     DVLOG(1) << "Natural scroll set to " << enabled;
 495     if (user_is_active)
 496       touchpad_settings.SetNaturalScroll(enabled);
 497     if (reason == REASON_PREF_CHANGED)
 498       UMA_HISTOGRAM_BOOLEAN("Touchpad.NaturalScroll.Changed", enabled);
 499     else if (reason == REASON_INITIALIZATION)
 500       UMA_HISTOGRAM_BOOLEAN("Touchpad.NaturalScroll.Started", enabled);
 501   }
 502   if (reason != REASON_PREF_CHANGED || pref_name == prefs::kMouseSensitivity) {
 503     const int sensitivity = mouse_sensitivity_.GetValue();
 504     if (user_is_active)
 505       mouse_settings.SetSensitivity(sensitivity);
 506     if (reason == REASON_PREF_CHANGED) {
 507       UMA_HISTOGRAM_ENUMERATION("Mouse.PointerSensitivity.Changed",
 508                                 sensitivity,
 509                                 system::kMaxPointerSensitivity + 1);
 510     } else if (reason == REASON_INITIALIZATION) {
 511       UMA_HISTOGRAM_ENUMERATION("Mouse.PointerSensitivity.Started",
 512                                 sensitivity,
 513                                 system::kMaxPointerSensitivity + 1);
 514     }
 515   }
 516   if (reason != REASON_PREF_CHANGED ||
 517       pref_name == prefs::kTouchpadSensitivity) {
 518     const int sensitivity = touchpad_sensitivity_.GetValue();
 519     if (user_is_active)
 520       touchpad_settings.SetSensitivity(sensitivity);
 521     if (reason == REASON_PREF_CHANGED) {
 522       UMA_HISTOGRAM_ENUMERATION("Touchpad.PointerSensitivity.Changed",
 523                                 sensitivity,
 524                                 system::kMaxPointerSensitivity + 1);
 525     } else if (reason == REASON_INITIALIZATION) {
 526       UMA_HISTOGRAM_ENUMERATION("Touchpad.PointerSensitivity.Started",
 527                                 sensitivity,
 528                                 system::kMaxPointerSensitivity + 1);
 529     }
 530   }
 531   if (reason != REASON_PREF_CHANGED ||
 532       pref_name == prefs::kPrimaryMouseButtonRight) {
 533     const bool right = primary_mouse_button_right_.GetValue();
 534     if (user_is_active)
 535       mouse_settings.SetPrimaryButtonRight(right);
 536     if (reason == REASON_PREF_CHANGED)
 537       UMA_HISTOGRAM_BOOLEAN("Mouse.PrimaryButtonRight.Changed", right);
 538     else if (reason == REASON_INITIALIZATION)
 539       UMA_HISTOGRAM_BOOLEAN("Mouse.PrimaryButtonRight.Started", right);
 540     // Save owner preference in local state to use on login screen.
 541     if (user_is_owner) {
 542       PrefService* prefs = g_browser_process->local_state();
 543       if (prefs->GetBoolean(prefs::kOwnerPrimaryMouseButtonRight) != right)
 544         prefs->SetBoolean(prefs::kOwnerPrimaryMouseButtonRight, right);
 545     }
 546   }
 547   if (reason != REASON_PREF_CHANGED ||
 548       pref_name == prefs::kDownloadDefaultDirectory) {
 549     const bool default_download_to_drive = drive::util::IsUnderDriveMountPoint(
 550         download_default_directory_.GetValue());
 551     if (reason == REASON_PREF_CHANGED)
 552       UMA_HISTOGRAM_BOOLEAN(
 553           "FileBrowser.DownloadDestination.IsGoogleDrive.Changed",
 554           default_download_to_drive);
 555     else if (reason == REASON_INITIALIZATION)
 556       UMA_HISTOGRAM_BOOLEAN(
 557           "FileBrowser.DownloadDestination.IsGoogleDrive.Started",
 558           default_download_to_drive);
 559   }
 560   if (reason != REASON_PREF_CHANGED ||
 561       pref_name == prefs::kTouchHudProjectionEnabled) {
 562     if (user_is_active) {
 563       const bool enabled = touch_hud_projection_enabled_.GetValue();
 564       // There may not be a shell, e.g., in some unit tests.
 565       if (ash::Shell::HasInstance())
 566         ash::Shell::GetInstance()->SetTouchHudProjectionEnabled(enabled);
 567     }
 568   }
 569
 570   if (reason != REASON_PREF_CHANGED ||
 571       pref_name == prefs::kLanguageXkbAutoRepeatEnabled) {
 572     if (user_is_active) {
 573       const bool enabled = xkb_auto_repeat_enabled_.GetValue();
 574       input_method::InputMethodManager::Get()
 575           ->GetImeKeyboard()
 576           ->SetAutoRepeatEnabled(enabled);
 577     }
 578   }
 579   if (reason != REASON_PREF_CHANGED ||
 580       pref_name == prefs::kLanguageXkbAutoRepeatDelay ||
 581       pref_name == prefs::kLanguageXkbAutoRepeatInterval) {
 582     if (user_is_active)
 583       UpdateAutoRepeatRate();
 584   }
 585
 586   if (reason == REASON_INITIALIZATION)
 587     SetInputMethodList();
 588
 589   if (pref_name == prefs::kLanguagePreloadEngines &&
 590       reason == REASON_PREF_CHANGED) {
 591     SetLanguageConfigStringListAsCSV(language_prefs::kGeneralSectionName,
 592                                      language_prefs::kPreloadEnginesConfigName,
 593                                      preload_engines_.GetValue());
 594   }
 595
 596   if ((reason == REASON_INITIALIZATION) ||
 597       (pref_name == prefs::kLanguageEnabledExtensionImes &&
 598        reason == REASON_PREF_CHANGED)) {
 599     std::string value(enabled_extension_imes_.GetValue());
 600
 601     std::vector<std::string> split_values;
 602     if (!value.empty())
 603       base::SplitString(value, ',', &split_values);
 604
 605     ime_state_->SetEnabledExtensionImes(&split_values);
 606   }
 607
 608   if (user_is_active) {
 609     system::InputDeviceSettings::Get()->UpdateTouchpadSettings(
 610         touchpad_settings);
 611     system::InputDeviceSettings::Get()->UpdateMouseSettings(mouse_settings);
 612   }
 613
 614   if (user_is_primary_ && (reason != REASON_PREF_CHANGED ||
 615                            pref_name == prefs::kWakeOnWifiSsid)) {
 616     int features = wake_on_wifi_ssid_.GetValue() ?
 617         WakeOnWifiManager::WAKE_ON_SSID : WakeOnWifiManager::WAKE_ON_NONE;
 618     // The flag enables wake on packets but doesn't update a preference.
 619     if (base::CommandLine::ForCurrentProcess()->
 620             HasSwitch(switches::kWakeOnPackets)) {
 621       features |= WakeOnWifiManager::WAKE_ON_PACKET;
 622     }
 623     WakeOnWifiManager::Get()->OnPreferenceChanged(
 624         static_cast<WakeOnWifiManager::WakeOnWifiFeature>(features));
 625   }
 626
 627   if (pref_name == prefs::kResolveTimezoneByGeolocation &&
 628       reason != REASON_ACTIVE_USER_CHANGED) {
 629     const bool value = prefs_->GetBoolean(prefs::kResolveTimezoneByGeolocation);
 630     if (user_is_owner) {
 631       g_browser_process->local_state()->SetBoolean(
 632           prefs::kResolveDeviceTimezoneByGeolocation, value);
 633     }
 634     if (user_is_primary_) {
 635       if (value) {
 636         g_browser_process->platform_part()->GetTimezoneResolver()->Start();
 637       } else {
 638         g_browser_process->platform_part()->GetTimezoneResolver()->Stop();
 639         if (reason == REASON_PREF_CHANGED) {
 640           // Allow immediate timezone update on Stop + Start.
 641           g_browser_process->local_state()->ClearPref(
 642               TimeZoneResolver::kLastTimeZoneRefreshTime);
 643         }
 644       }
 645     }
 646   }
 647 }
 648
 649 void Preferences::OnIsSyncingChanged() {
 650   DVLOG(1) << "OnIsSyncingChanged";
 651   ForceNaturalScrollDefault();
 652 }
 653
 654 void Preferences::ForceNaturalScrollDefault() {
 655   DVLOG(1) << "ForceNaturalScrollDefault";
 656   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
 657           switches::kNaturalScrollDefault) &&
 658       prefs_->IsSyncing() && !prefs_->GetUserPrefValue(prefs::kNaturalScroll)) {
 659     DVLOG(1) << "Natural scroll forced to true";
 660     natural_scroll_.SetValue(true);
 661     UMA_HISTOGRAM_BOOLEAN("Touchpad.NaturalScroll.Forced", true);
 662   }
 663 }
 664
 665 void Preferences::SetLanguageConfigStringListAsCSV(const char* section,
 666                                                    const char* name,
 667                                                    const std::string& value) {
 668   VLOG(1) << "Setting " << name << " to '" << value << "'";
 669
 670   std::vector<std::string> split_values;
 671   if (!value.empty())
 672     base::SplitString(value, ',', &split_values);
 673
 674   // Transfers the xkb id to extension-xkb id.
 675   if (input_method_manager_->MigrateInputMethods(&split_values))
 676     preload_engines_.SetValue(JoinString(split_values, ','));
 677
 678   if (section == std::string(language_prefs::kGeneralSectionName) &&
 679       name == std::string(language_prefs::kPreloadEnginesConfigName)) {
 680     ime_state_->ReplaceEnabledInputMethods(split_values);
 681     return;
 682   }
 683 }
 684
 685 void Preferences::SetInputMethodList() {
 686   // When |preload_engines_| are set, InputMethodManager::ChangeInputMethod()
 687   // might be called to change the current input method to the first one in the
 688   // |preload_engines_| list. This also updates previous/current input method
 689   // prefs. That's why GetValue() calls are placed before the
 690   // SetLanguageConfigStringListAsCSV() call below.
 691   const std::string previous_input_method_id =
 692       previous_input_method_.GetValue();
 693   const std::string current_input_method_id = current_input_method_.GetValue();
 694   SetLanguageConfigStringListAsCSV(language_prefs::kGeneralSectionName,
 695                                    language_prefs::kPreloadEnginesConfigName,
 696                                    preload_engines_.GetValue());
 697
 698   // ChangeInputMethod() has to be called AFTER the value of |preload_engines_|
 699   // is sent to the InputMethodManager. Otherwise, the ChangeInputMethod request
 700   // might be ignored as an invalid input method ID. The ChangeInputMethod()
 701   // calls are also necessary to restore the previous/current input method prefs
 702   // which could have been modified by the SetLanguageConfigStringListAsCSV call
 703   // above to the original state.
 704   if (!previous_input_method_id.empty())
 705     ime_state_->ChangeInputMethod(previous_input_method_id,
 706                                   false /* show_message */);
 707   if (!current_input_method_id.empty())
 708     ime_state_->ChangeInputMethod(current_input_method_id,
 709                                   false /* show_message */);
 710 }
 711
 712 void Preferences::UpdateAutoRepeatRate() {
 713   input_method::AutoRepeatRate rate;
 714   rate.initial_delay_in_ms = xkb_auto_repeat_delay_pref_.GetValue();
 715   rate.repeat_interval_in_ms = xkb_auto_repeat_interval_pref_.GetValue();
 716   DCHECK(rate.initial_delay_in_ms > 0);
 717   DCHECK(rate.repeat_interval_in_ms > 0);
 718   input_method::InputMethodManager::Get()
 719       ->GetImeKeyboard()
 720       ->SetAutoRepeatRate(rate);
 721 }
 722
 723 void Preferences::OnTouchHudProjectionToggled(bool enabled) {
 724   if (touch_hud_projection_enabled_.GetValue() == enabled)
 725     return;
 726   if (!user_->is_active())
 727     return;
 728   touch_hud_projection_enabled_.SetValue(enabled);
 729 }
 730
 731 void Preferences::ActiveUserChanged(const user_manager::User* active_user) {
 732   if (active_user != user_)
 733     return;
 734   ApplyPreferences(REASON_ACTIVE_USER_CHANGED, "");
 735 }
 736
 737 }  // namespace chromeos