Use helper DeviceChangeHandler to call mousecontrol/tpcontrol whenever a device is attached.

chrome/browser/chromeos/preferences.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/chromeos/preferences.h"
 
 #include "ash/magnifier/magnifier_constants.h"
 #include "base/chromeos/chromeos_version.h"
 #include "base/command_line.h"
 #include "base/i18n/time_formatting.h"
@@ skipping 31 matching lines @@
 namespace chromeos {
 
 static const char kFallbackInputMethodLocale[] = "en-US";
 
 Preferences::Preferences()
     : prefs_(NULL),
       input_method_manager_(input_method::InputMethodManager::Get()) {
 }
 
 Preferences::Preferences(input_method::InputMethodManager* input_method_manager)
-    : input_method_manager_(input_method_manager) {
+    : prefs_(NULL),

[xiyuan, 2013/05/21 02:01:44]

Good catch.

+      input_method_manager_(input_method_manager) {
 }
 
 Preferences::~Preferences() {
   prefs_->RemoveObserver(this);
 }
 
 // static
 void Preferences::RegisterPrefs(PrefRegistrySimple* registry) {
   registry->RegisterBooleanPref(prefs::kHighContrastEnabled, false);
   registry->RegisterBooleanPref(prefs::kOwnerPrimaryMouseButtonRight, false);
@@ skipping 455 matching lines @@
 void Preferences::Init(PrefServiceSyncable* prefs) {
   InitUserPrefs(prefs);
 
   // This causes OnIsSyncingChanged to be called when the value of
   // PrefService::IsSyncing() changes.
   prefs->AddObserver(this);
 
   // Initialize preferences to currently saved state.
   NotifyPrefChanged(NULL);
 
+  // Listen to changes in device hierarchy.
+  pointer_device_observer_.reset(new system::PointerDeviceObserver());
+  pointer_device_observer_->AddObserver(this);
+  pointer_device_observer_->Init();
+
   // If a guest is logged in, initialize the prefs as if this is the first
   // login.
   if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kGuestSession)) {
     LoginUtils::Get()->SetFirstLoginPrefs(prefs);
   }
 }
 
 void Preferences::InitUserPrefsForTesting(PrefServiceSyncable* prefs) {
   InitUserPrefs(prefs);
 }
 
 void Preferences::SetInputMethodListForTesting() {
   SetInputMethodList();
 }
 
 void Preferences::OnPreferenceChanged(const std::string& pref_name) {
   NotifyPrefChanged(&pref_name);
 }
 
-void Preferences::NotifyPrefChanged(const std::string* pref_name) {
+void Preferences::SetTouchpadPrefs(const std::string* pref_name) {
   if (!pref_name || *pref_name == prefs::kTapToClickEnabled) {
     const bool enabled = tap_to_click_enabled_.GetValue();
     system::touchpad_settings::SetTapToClick(enabled);
     if (pref_name)
       UMA_HISTOGRAM_BOOLEAN("Touchpad.TapToClick.Changed", enabled);
     else
       UMA_HISTOGRAM_BOOLEAN("Touchpad.TapToClick.Started", enabled);
 
     // Save owner preference in local state to use on login screen.
     if (chromeos::UserManager::Get()->IsCurrentUserOwner()) {
@@ skipping 19 matching lines @@
       UMA_HISTOGRAM_BOOLEAN("Touchpad.ThreeFingerClick.Started", enabled);
   }
   if (!pref_name || *pref_name == prefs::kEnableTouchpadThreeFingerSwipe) {
     const bool enabled = three_finger_swipe_enabled_.GetValue();
     system::touchpad_settings::SetThreeFingerSwipe(enabled);
     if (pref_name)
       UMA_HISTOGRAM_BOOLEAN("Touchpad.ThreeFingerSwipe.Changed", enabled);
     else
       UMA_HISTOGRAM_BOOLEAN("Touchpad.ThreeFingerSwipe.Started", enabled);
   }
-  if (!pref_name || *pref_name == prefs::kNaturalScroll) {
-    // Force natural scroll default if we've sync'd and if the cmd line arg is
-    // set.
-    ForceNaturalScrollDefault();
+  if (!pref_name || *pref_name == prefs::kTouchpadSensitivity) {
+    const int sensitivity = touchpad_sensitivity_.GetValue();
+    system::touchpad_settings::SetSensitivity(sensitivity);
+    if (pref_name) {
+      UMA_HISTOGRAM_CUSTOM_COUNTS(
+          "Touchpad.Sensitivity.Changed", sensitivity, 1, 5, 5);
+    } else {
+      UMA_HISTOGRAM_CUSTOM_COUNTS(
+          "Touchpad.Sensitivity.Started", sensitivity, 1, 5, 5);
+    }
+  }
+}
 
-    const bool enabled = natural_scroll_.GetValue();
-    DVLOG(1) << "Natural scroll set to " << enabled;
-    ui::SetNaturalScroll(enabled);
-    if (pref_name)
-      UMA_HISTOGRAM_BOOLEAN("Touchpad.NaturalScroll.Changed", enabled);
-    else
-      UMA_HISTOGRAM_BOOLEAN("Touchpad.NaturalScroll.Started", enabled);
-  }
+void Preferences::SetMousePrefs(const std::string* pref_name) {
   if (!pref_name || *pref_name == prefs::kMouseSensitivity) {
     const int sensitivity = mouse_sensitivity_.GetValue();
     system::mouse_settings::SetSensitivity(sensitivity);
     if (pref_name) {
       UMA_HISTOGRAM_CUSTOM_COUNTS(
           "Mouse.Sensitivity.Changed", sensitivity, 1, 5, 5);
     } else {
       UMA_HISTOGRAM_CUSTOM_COUNTS(
           "Mouse.Sensitivity.Started", sensitivity, 1, 5, 5);
     }
   }
-  if (!pref_name || *pref_name == prefs::kTouchpadSensitivity) {
-    const int sensitivity = touchpad_sensitivity_.GetValue();
-    system::touchpad_settings::SetSensitivity(sensitivity);
-    if (pref_name) {
-      UMA_HISTOGRAM_CUSTOM_COUNTS(
-          "Touchpad.Sensitivity.Changed", sensitivity, 1, 5, 5);
-    } else {
-      UMA_HISTOGRAM_CUSTOM_COUNTS(
-          "Touchpad.Sensitivity.Started", sensitivity, 1, 5, 5);
-    }
-  }
   if (!pref_name || *pref_name == prefs::kPrimaryMouseButtonRight) {
     const bool right = primary_mouse_button_right_.GetValue();
     system::mouse_settings::SetPrimaryButtonRight(right);
     if (pref_name)
       UMA_HISTOGRAM_BOOLEAN("Mouse.PrimaryButtonRight.Changed", right);
     else
       UMA_HISTOGRAM_BOOLEAN("Mouse.PrimaryButtonRight.Started", right);
 
     // Save owner preference in local state to use on login screen.
     if (chromeos::UserManager::Get()->IsCurrentUserOwner()) {
       PrefService* prefs = g_browser_process->local_state();
       if (prefs->GetBoolean(prefs::kOwnerPrimaryMouseButtonRight) != right)
         prefs->SetBoolean(prefs::kOwnerPrimaryMouseButtonRight, right);
     }
   }
+}
+
+void Preferences::NotifyPrefChanged(const std::string* pref_name) {
+  SetTouchpadPrefs(pref_name);
+  SetMousePrefs(pref_name);
+
+  if (!pref_name || *pref_name == prefs::kNaturalScroll) {
+    // Force natural scroll default if we've sync'd and if the cmd line arg is
+    // set.
+    ForceNaturalScrollDefault();
+
+    const bool enabled = natural_scroll_.GetValue();
+    DVLOG(1) << "Natural scroll set to " << enabled;
+    ui::SetNaturalScroll(enabled);
+    if (pref_name)
+      UMA_HISTOGRAM_BOOLEAN("Touchpad.NaturalScroll.Changed", enabled);
+    else
+      UMA_HISTOGRAM_BOOLEAN("Touchpad.NaturalScroll.Started", enabled);
+  }
   if (!pref_name || *pref_name == prefs::kDownloadDefaultDirectory) {
     const base::FilePath pref_path = download_default_directory_.GetValue();
     // TODO(haruki): Remove this when migration completes. crbug.com/229304.
     if (drive::util::NeedsNamespaceMigration(pref_path)) {
       prefs_->SetFilePath(prefs::kDownloadDefaultDirectory,
                           drive::util::ConvertToMyDriveNamespace(pref_path));
     }
 
     const bool default_download_to_drive = drive::util::IsUnderDriveMountPoint(
         download_default_directory_.GetValue());
@@ skipping 235 matching lines @@
   if (CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kNaturalScrollDefault) &&
       prefs_->IsSyncing() &&
       !prefs_->GetUserPrefValue(prefs::kNaturalScroll)) {
     DVLOG(1) << "Natural scroll forced to true";
     natural_scroll_.SetValue(true);
     UMA_HISTOGRAM_BOOLEAN("Touchpad.NaturalScroll.Forced", true);
   }
 }
 
+void Preferences::TouchpadExists(bool exists) {
+  SetTouchpadPrefs(NULL);
+}
+
+void Preferences::MouseExists(bool exists) {
+  SetMousePrefs(NULL);
+}
+
 void Preferences::SetLanguageConfigBoolean(const char* section,
                                            const char* name,
                                            bool value) {
   input_method::InputMethodConfigValue config;
   config.type = input_method::InputMethodConfigValue::kValueTypeBool;
   config.bool_value = value;
   input_method_manager_->SetInputMethodConfig(section, name, config);
 }
 
 void Preferences::SetLanguageConfigInteger(const char* section,
@@ skipping 82 matching lines @@
 
   input_method::AutoRepeatRate rate;
   rate.initial_delay_in_ms = xkb_auto_repeat_delay_pref_.GetValue();
   rate.repeat_interval_in_ms = xkb_auto_repeat_interval_pref_.GetValue();
   DCHECK(rate.initial_delay_in_ms > 0);
   DCHECK(rate.repeat_interval_in_ms > 0);
   input_method::XKeyboard::SetAutoRepeatRate(rate);
 }
 
 }  // namespace chromeos