chromeos: Add power management policy prefs.

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 14 matching lines @@
 #include "chrome/browser/chromeos/system/drm_settings.h"
 #include "chrome/browser/chromeos/system/input_device_settings.h"
 #include "chrome/browser/chromeos/system/power_manager_settings.h"
 #include "chrome/browser/chromeos/system/statistics_provider.h"
 #include "chrome/browser/download/download_util.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/prefs/scoped_user_pref_update.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
+#include "chromeos/dbus/dbus_thread_manager.h"
+#include "chromeos/dbus/power_policy_controller.h"
 #include "googleurl/src/gurl.h"
 #include "third_party/icu/public/i18n/unicode/timezone.h"
 #include "ui/base/events/event_constants.h"
 #include "ui/base/events/event_utils.h"
 
 namespace chromeos {
 
 static const char kFallbackInputMethodLocale[] = "en-US";
 
 Preferences::Preferences()
@@ skipping 244 matching lines @@
 
   // TODO(wad): Once UI is connected, a final default can be set. At that point
   // change this pref from UNSYNCABLE to SYNCABLE.
   prefs->RegisterBooleanPref(prefs::kEnableCrosDRM,
                              true,
                              PrefServiceSyncable::UNSYNCABLE_PREF);
 
   prefs->RegisterBooleanPref(prefs::kExternalStorageDisabled,
                              false,
                              PrefServiceSyncable::UNSYNCABLE_PREF);
+
+  // TODO(derat): Right now, these values are just copied from powerd's
+  // defaults.  Make this file be the canonical source of default power
+  // management settings.  Note that these prefs' default values aren't
+  // currently expressive enough to convey powerd's default behavior, e.g.
+  // powerd shuts down instead of suspending when no user is logged in, and
+  // the default screen-lock delays are only used when
+  // prefs::kEnableScreenLock is set.
+  prefs->RegisterIntegerPref(prefs::kPowerAcScreenDimDelayMs,
+                             420000,
+                             PrefServiceSyncable::UNSYNCABLE_PREF);
+  prefs->RegisterIntegerPref(prefs::kPowerAcScreenOffDelayMs,
+                             480000,
+                             PrefServiceSyncable::UNSYNCABLE_PREF);
+  prefs->RegisterIntegerPref(prefs::kPowerAcScreenLockDelayMs,
+                             600000,
+                             PrefServiceSyncable::UNSYNCABLE_PREF);
+  prefs->RegisterIntegerPref(prefs::kPowerAcIdleDelayMs,
+                             1800000,
+                             PrefServiceSyncable::UNSYNCABLE_PREF);
+  prefs->RegisterIntegerPref(prefs::kPowerBatteryScreenDimDelayMs,
+                             300000,
+                             PrefServiceSyncable::UNSYNCABLE_PREF);
+  prefs->RegisterIntegerPref(prefs::kPowerBatteryScreenOffDelayMs,
+                             360000,
+                             PrefServiceSyncable::UNSYNCABLE_PREF);
+  prefs->RegisterIntegerPref(prefs::kPowerBatteryScreenLockDelayMs,
+                             600000,
+                             PrefServiceSyncable::UNSYNCABLE_PREF);
+  prefs->RegisterIntegerPref(prefs::kPowerBatteryIdleDelayMs,
+                             600000,
+                             PrefServiceSyncable::UNSYNCABLE_PREF);
+  prefs->RegisterIntegerPref(prefs::kPowerIdleAction,
+                             chromeos::PowerPolicyController::ACTION_SUSPEND,
+                             PrefServiceSyncable::UNSYNCABLE_PREF);
+  prefs->RegisterIntegerPref(prefs::kPowerLidClosedAction,
+                             chromeos::PowerPolicyController::ACTION_SUSPEND,
+                             PrefServiceSyncable::UNSYNCABLE_PREF);
+  prefs->RegisterBooleanPref(prefs::kPowerUseAudioActivity,
+                             true,
+                             PrefServiceSyncable::UNSYNCABLE_PREF);
+  prefs->RegisterBooleanPref(prefs::kPowerUseVideoActivity,
+                             true,
+                             PrefServiceSyncable::UNSYNCABLE_PREF);
+  prefs->RegisterDoublePref(prefs::kPowerPresentationIdleDelayFactor,
+                            2.0,
+                            PrefServiceSyncable::UNSYNCABLE_PREF);
 }
 
 void Preferences::InitUserPrefs(PrefServiceSyncable* prefs) {
   prefs_ = prefs;
 
   BooleanPrefMember::NamedChangeCallback callback =
       base::Bind(&Preferences::OnPreferenceChanged, base::Unretained(this));
 
   tap_to_click_enabled_.Init(prefs::kTapToClickEnabled, prefs, callback);
   tap_dragging_enabled_.Init(prefs::kTapDraggingEnabled, prefs, callback);
@@ skipping 72 matching lines @@
   xkb_auto_repeat_enabled_.Init(
       prefs::kLanguageXkbAutoRepeatEnabled, prefs, callback);
   xkb_auto_repeat_delay_pref_.Init(
       prefs::kLanguageXkbAutoRepeatDelay, prefs, callback);
   xkb_auto_repeat_interval_pref_.Init(
       prefs::kLanguageXkbAutoRepeatInterval, prefs, callback);
 
   enable_screen_lock_.Init(prefs::kEnableScreenLock, prefs, callback);
 
   enable_drm_.Init(prefs::kEnableCrosDRM, prefs, callback);
+
+  power_ac_screen_dim_delay_ms_.Init(
+      prefs::kPowerAcScreenDimDelayMs, prefs, callback);
+  power_ac_screen_off_delay_ms_.Init(
+      prefs::kPowerAcScreenOffDelayMs, prefs, callback);
+  power_ac_screen_lock_delay_ms_.Init(
+      prefs::kPowerAcScreenLockDelayMs, prefs, callback);
+  power_ac_idle_delay_ms_.Init(prefs::kPowerAcIdleDelayMs, prefs, callback);
+  power_battery_screen_dim_delay_ms_.Init(
+      prefs::kPowerBatteryScreenDimDelayMs, prefs, callback);
+  power_battery_screen_off_delay_ms_.Init(
+      prefs::kPowerBatteryScreenOffDelayMs, prefs, callback);
+  power_battery_screen_lock_delay_ms_.Init(
+      prefs::kPowerBatteryScreenLockDelayMs, prefs, callback);
+  power_battery_idle_delay_ms_.Init(
+      prefs::kPowerBatteryIdleDelayMs, prefs, callback);
+  power_idle_action_.Init(prefs::kPowerIdleAction, prefs, callback);
+  power_lid_closed_action_.Init(prefs::kPowerLidClosedAction, prefs, callback);
+  power_use_audio_activity_.Init(
+      prefs::kPowerUseAudioActivity, prefs, callback);
+  power_use_video_activity_.Init(
+      prefs::kPowerUseVideoActivity, prefs, callback);
+  power_presentation_idle_delay_factor_.Init(
+      prefs::kPowerPresentationIdleDelayFactor, prefs, callback);
 }
 
 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.
@@ skipping 270 matching lines @@
   // selected and Drive is disabled.
   if (!pref_name || *pref_name == prefs::kDisableDrive) {
     if (disable_drive_.GetValue()) {
       if (drive::util::IsUnderDriveMountPoint(
           download_default_directory_.GetValue())) {
         prefs_->SetFilePath(prefs::kDownloadDefaultDirectory,
                             download_util::GetDefaultDownloadDirectory());
       }
     }
   }
+
+  if (!pref_name ||
+      *pref_name == prefs::kPowerAcScreenDimDelayMs ||
+      *pref_name == prefs::kPowerAcScreenOffDelayMs ||
+      *pref_name == prefs::kPowerAcScreenLockDelayMs ||
+      *pref_name == prefs::kPowerAcIdleDelayMs ||
+      *pref_name == prefs::kPowerBatteryScreenDimDelayMs ||
+      *pref_name == prefs::kPowerBatteryScreenOffDelayMs ||
+      *pref_name == prefs::kPowerBatteryScreenLockDelayMs ||
+      *pref_name == prefs::kPowerBatteryIdleDelayMs ||
+      *pref_name == prefs::kPowerIdleAction ||
+      *pref_name == prefs::kPowerLidClosedAction ||
+      *pref_name == prefs::kPowerUseAudioActivity ||
+      *pref_name == prefs::kPowerUseVideoActivity ||
+      *pref_name == prefs::kPowerPresentationIdleDelayFactor) {
+    DBusThreadManager::Get()->GetPowerPolicyController()->UpdatePolicyFromPrefs(
+        *prefs_->FindPreference(prefs::kPowerAcScreenDimDelayMs),
+        *prefs_->FindPreference(prefs::kPowerAcScreenOffDelayMs),
+        *prefs_->FindPreference(prefs::kPowerAcScreenLockDelayMs),
+        *prefs_->FindPreference(prefs::kPowerAcIdleDelayMs),
+        *prefs_->FindPreference(prefs::kPowerBatteryScreenDimDelayMs),
+        *prefs_->FindPreference(prefs::kPowerBatteryScreenOffDelayMs),
+        *prefs_->FindPreference(prefs::kPowerBatteryScreenLockDelayMs),
+        *prefs_->FindPreference(prefs::kPowerBatteryIdleDelayMs),
+        *prefs_->FindPreference(prefs::kPowerIdleAction),
+        *prefs_->FindPreference(prefs::kPowerLidClosedAction),
+        *prefs_->FindPreference(prefs::kPowerUseAudioActivity),
+        *prefs_->FindPreference(prefs::kPowerUseVideoActivity),
+        *prefs_->FindPreference(prefs::kPowerPresentationIdleDelayFactor));
+  }
 }
 
 void Preferences::OnIsSyncingChanged() {
   DVLOG(1) << "OnIsSyncingChanged";
   ForceNaturalScrollDefault();
 }
 
 void Preferences::ForceNaturalScrollDefault() {
   DVLOG(1) << "ForceNaturalScrollDefault";
   if (CommandLine::ForCurrentProcess()->HasSwitch(
@@ skipping 97 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