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);
+
+  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) {
   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_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) {
   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)
+    UpdatePowerManagementPolicy();
+
 }
 
 void Preferences::OnIsSyncingChanged() {
   DVLOG(1) << "OnIsSyncingChanged";
   ForceNaturalScrollDefault();
 }
 
 void Preferences::ForceNaturalScrollDefault() {
   DVLOG(1) << "ForceNaturalScrollDefault";
   if (CommandLine::ForCurrentProcess()->HasSwitch(
@@ skipping 96 matching lines @@
     return;
 
   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);
 }
 
+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