chromeos: Add power management policy prefs.

chrome/browser/chromeos/preferences.cc

Index: chrome/browser/chromeos/preferences.cc
diff --git a/chrome/browser/chromeos/preferences.cc b/chrome/browser/chromeos/preferences.cc
index 7f5233f748fff1f5c3ac287cd54187696f8630cf..ab0e21acc10147f8c3e14635678ea28bfe03d902 100644
--- a/chrome/browser/chromeos/preferences.cc
+++ b/chrome/browser/chromeos/preferences.cc
@@ -32,6 +32,8 @@
 #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"
@@ -296,6 +298,47 @@ void Preferences::RegisterUserPrefs(PrefServiceSyncable* prefs) {
   prefs->RegisterBooleanPref(prefs::kExternalStorageDisabled,
                              false,
                              PrefServiceSyncable::UNSYNCABLE_PREF);
+
+  prefs->RegisterIntegerPref(prefs::kPowerAcScreenDimDelayMs,
+                             chromeos::PowerPolicyController::kUnsetDelayMs,

[bartfab (slow), 2013/02/04 10:04:35]

You do not need magic value constants such as "kUnsetDelayMs", "ACTION_UNSET",
"BOOL_UNSET" to detect if a pref has been set. You should just set the prefs to
their actual default state in this file. In the code that sends power management
policy to powerd, you can then use PrefServiceBase::Preference::IsDefaultValue()
to check whether the pref is still at its default or not.

When we decide to make these prefs available in the UI, we may run into a
problem here: The default values shown to the user should match the defaults on
the current platform. But you mentioned that the defaults may vary per board. I
guess we will need to pass them into Chrome somehow.

[Daniel Erat, 2013/02/04 13:35:45]

Sure, I'll update this.  I didn't realize that IsDefaultValue() would
differentiate between unset prefs and set-to-the-same-value-as-the-default
prefs, but I now see that that's the case.
I'm not sure how many of these, if any, we'll want to make available in the UI. 
My longer-term intent is for the default values to live in Chrome instead of in
powerd, though, i.e. Chrome should always be passing values to powerd instead of
leaving them unset.

[bartfab (slow), 2013/02/04 14:43:52]

That's perfect. And yes, the issue will not arise for now anyway as we are not
exposing any of the settings in the UI.

+                             PrefServiceSyncable::UNSYNCABLE_PREF);

[Daniel Erat, 2013/02/04 03:10:07]

I'm assuming that none of these should be synced, but let me know if I'm wrong.

[bartfab (slow), 2013/02/04 10:04:35]

I'd agree. If you have multiple Chrome OS devices, you probably want the freedom
to configure them independently.

+  prefs->RegisterIntegerPref(prefs::kPowerAcScreenOffDelayMs,
+                             chromeos::PowerPolicyController::kUnsetDelayMs,
+                             PrefServiceSyncable::UNSYNCABLE_PREF);
+  prefs->RegisterIntegerPref(prefs::kPowerAcScreenLockDelayMs,
+                             chromeos::PowerPolicyController::kUnsetDelayMs,
+                             PrefServiceSyncable::UNSYNCABLE_PREF);
+  prefs->RegisterIntegerPref(prefs::kPowerAcIdleDelayMs,
+                             chromeos::PowerPolicyController::kUnsetDelayMs,
+                             PrefServiceSyncable::UNSYNCABLE_PREF);
+  prefs->RegisterIntegerPref(prefs::kPowerBatteryScreenDimDelayMs,
+                             chromeos::PowerPolicyController::kUnsetDelayMs,
+                             PrefServiceSyncable::UNSYNCABLE_PREF);
+  prefs->RegisterIntegerPref(prefs::kPowerBatteryScreenOffDelayMs,
+                             chromeos::PowerPolicyController::kUnsetDelayMs,
+                             PrefServiceSyncable::UNSYNCABLE_PREF);
+  prefs->RegisterIntegerPref(prefs::kPowerBatteryScreenLockDelayMs,
+                             chromeos::PowerPolicyController::kUnsetDelayMs,
+                             PrefServiceSyncable::UNSYNCABLE_PREF);
+  prefs->RegisterIntegerPref(prefs::kPowerBatteryIdleDelayMs,
+                             chromeos::PowerPolicyController::kUnsetDelayMs,
+                             PrefServiceSyncable::UNSYNCABLE_PREF);
+  prefs->RegisterIntegerPref(prefs::kPowerIdleAction,
+                             chromeos::PowerPolicyController::ACTION_UNSET,

[Daniel Erat, 2013/02/04 03:10:07]

Will the enterprise code automatically reset all of these to the default "unset"
values if the policy is removed?

[bartfab (slow), 2013/02/04 10:04:35]

Yes. When a policy is removed, any prefs controlled by it drop back to their
default values and you get a pref change notification.

+                             PrefServiceSyncable::UNSYNCABLE_PREF);
+  prefs->RegisterIntegerPref(prefs::kPowerLidClosedAction,
+                             chromeos::PowerPolicyController::ACTION_UNSET,
+                             PrefServiceSyncable::UNSYNCABLE_PREF);
+  prefs->RegisterIntegerPref(prefs::kPowerUseAudioActivity,
+                             chromeos::PowerPolicyController::BOOL_UNSET,
+                             PrefServiceSyncable::UNSYNCABLE_PREF);
+  prefs->RegisterIntegerPref(prefs::kPowerUseVideoActivity,
+                             chromeos::PowerPolicyController::BOOL_UNSET,
+                             PrefServiceSyncable::UNSYNCABLE_PREF);
+  prefs->RegisterDoublePref(prefs::kPowerPresentationIdleDelayFactor,
+                            chromeos::PowerPolicyController::
+                                kUnsetPresentationIdleDelayFactor,
+                            PrefServiceSyncable::UNSYNCABLE_PREF);
 }
 
 void Preferences::InitUserPrefs(PrefServiceSyncable* prefs) {
@@ -388,6 +431,32 @@ void Preferences::InitUserPrefs(PrefServiceSyncable* prefs) {
   enable_screen_lock_.Init(prefs::kEnableScreenLock, prefs, callback);
 
   enable_drm_.Init(prefs::kEnableCrosDRM, prefs, callback);
+
+  power_ac_screen_dim_delay_ms_pref_.Init(
+      prefs::kPowerAcScreenDimDelayMs, prefs, callback);
+  power_ac_screen_off_delay_ms_pref_.Init(
+      prefs::kPowerAcScreenOffDelayMs, prefs, callback);
+  power_ac_screen_lock_delay_ms_pref_.Init(
+      prefs::kPowerAcScreenLockDelayMs, prefs, callback);
+  power_ac_idle_delay_ms_pref_.Init(
+      prefs::kPowerAcIdleDelayMs, prefs, callback);
+  power_battery_screen_dim_delay_ms_pref_.Init(
+      prefs::kPowerBatteryScreenDimDelayMs, prefs, callback);
+  power_battery_screen_off_delay_ms_pref_.Init(
+      prefs::kPowerBatteryScreenOffDelayMs, prefs, callback);
+  power_battery_screen_lock_delay_ms_pref_.Init(
+      prefs::kPowerBatteryScreenLockDelayMs, prefs, callback);
+  power_battery_idle_delay_ms_pref_.Init(
+      prefs::kPowerBatteryIdleDelayMs, prefs, callback);
+  power_idle_action_pref_.Init(prefs::kPowerIdleAction, prefs, callback);
+  power_lid_closed_action_pref_.Init(
+      prefs::kPowerLidClosedAction, prefs, callback);
+  power_use_audio_activity_pref_.Init(
+      prefs::kPowerUseAudioActivity, prefs, callback);
+  power_use_video_activity_pref_.Init(
+      prefs::kPowerUseVideoActivity, prefs, callback);
+  power_presentation_idle_delay_factor_pref_.Init(
+      prefs::kPowerPresentationIdleDelayFactor, prefs, callback);
 }
 
 void Preferences::Init(PrefServiceSyncable* prefs) {
@@ -678,6 +747,23 @@ void Preferences::NotifyPrefChanged(const std::string* pref_name) {
       }
     }
   }
+
+  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)
+    UpdatePowerManagementPolicy();
+
 }
 
 void Preferences::OnIsSyncingChanged() {
@@ -794,4 +880,41 @@ void Preferences::UpdateAutoRepeatRate() {
   input_method::XKeyboard::SetAutoRepeatRate(rate);
 }
 
+void Preferences::UpdatePowerManagementPolicy() {
+  PowerPolicyController::PolicyPrefs policy;
+
+  policy.ac_screen_dim_delay = base::TimeDelta::FromMilliseconds(
+      power_ac_screen_dim_delay_ms_pref_.GetValue());
+  policy.ac_screen_off_delay = base::TimeDelta::FromMilliseconds(
+      power_ac_screen_off_delay_ms_pref_.GetValue());
+  policy.ac_screen_lock_delay = base::TimeDelta::FromMilliseconds(
+      power_ac_screen_lock_delay_ms_pref_.GetValue());
+  policy.ac_idle_delay = base::TimeDelta::FromMilliseconds(
+      power_ac_idle_delay_ms_pref_.GetValue());
+
+  policy.battery_screen_dim_delay = base::TimeDelta::FromMilliseconds(
+      power_battery_screen_dim_delay_ms_pref_.GetValue());
+  policy.battery_screen_off_delay = base::TimeDelta::FromMilliseconds(
+      power_battery_screen_off_delay_ms_pref_.GetValue());
+  policy.battery_screen_lock_delay = base::TimeDelta::FromMilliseconds(
+      power_battery_screen_lock_delay_ms_pref_.GetValue());
+  policy.battery_idle_delay = base::TimeDelta::FromMilliseconds(
+      power_battery_idle_delay_ms_pref_.GetValue());
+
+  policy.idle_action = static_cast<PowerPolicyController::OptionalAction>(
+      power_idle_action_pref_.GetValue());
+  policy.lid_closed_action = static_cast<PowerPolicyController::OptionalAction>(
+      power_lid_closed_action_pref_.GetValue());
+
+  policy.use_audio_activity = static_cast<PowerPolicyController::OptionalBool>(
+      power_use_audio_activity_pref_.GetValue());
+  policy.use_video_activity = static_cast<PowerPolicyController::OptionalBool>(
+      power_use_video_activity_pref_.GetValue());
+  policy.presentation_idle_delay_factor =
+      power_presentation_idle_delay_factor_pref_.GetValue();
+
+  DBusThreadManager::Get()->GetPowerPolicyController()->UpdatePolicyFromPrefs(
+      policy);
+}
+
 }  // namespace chromeos