chromeos: Add settings to control power management prefs.

chrome/browser/ui/webui/settings/chromeos/device_power_handler.cc

Index: chrome/browser/ui/webui/settings/chromeos/device_power_handler.cc
diff --git a/chrome/browser/ui/webui/settings/chromeos/device_power_handler.cc b/chrome/browser/ui/webui/settings/chromeos/device_power_handler.cc
index 8e4cc5f1f2fbcaa773d7853258fc06640f9a3d62..6d08efcf619179bdecb4d807b2676c4cd3a1e509 100644
--- a/chrome/browser/ui/webui/settings/chromeos/device_power_handler.cc
+++ b/chrome/browser/ui/webui/settings/chromeos/device_power_handler.cc
@@ -13,7 +13,11 @@
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
+#include "chrome/common/pref_names.h"
 #include "chrome/grit/generated_resources.h"
+#include "chromeos/dbus/power_policy_controller.h"
+#include "components/prefs/pref_change_registrar.h"
+#include "components/prefs/pref_service.h"
 #include "content/public/browser/web_ui.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/l10n/time_format.h"
@@ -43,8 +47,8 @@ base::string16 GetBatteryTimeText(base::TimeDelta time_left) {
 
 }  // namespace
 
-PowerHandler::PowerHandler()
-    : power_observer_(this) {
+PowerHandler::PowerHandler(PrefService* prefs)
+    : prefs_(prefs), power_observer_(this) {
   power_status_ = ash::PowerStatus::Get();
 }
 
@@ -57,14 +61,42 @@ void PowerHandler::RegisterMessages() {
   web_ui()->RegisterMessageCallback(
       "setPowerSource",
       base::Bind(&PowerHandler::HandleSetPowerSource, base::Unretained(this)));
+  web_ui()->RegisterMessageCallback(
+      "requestPowerManagementSettings",
+      base::Bind(&PowerHandler::HandleRequestPowerManagementSettings,
+                 base::Unretained(this)));
+  web_ui()->RegisterMessageCallback(
+      "setLidClosedBehavior",
+      base::Bind(&PowerHandler::HandleSetLidClosedBehavior,
+                 base::Unretained(this)));
+  web_ui()->RegisterMessageCallback(
+      "setIdleBehavior",
+      base::Bind(&PowerHandler::HandleSetIdleBehavior, base::Unretained(this)));
 }
 
 void PowerHandler::OnJavascriptAllowed() {
   power_observer_.Add(power_status_);
+
+  // Register to be notified about changes to power management prefs that are
+  // incorporated into the UI.
+  base::Closure callback(base::Bind(&PowerHandler::SendPowerManagementSettings,
+                                    base::Unretained(this), false /* force */));
+  pref_change_registrar_.reset(new PrefChangeRegistrar);

[michaelpg, 2017/05/04 17:36:26]

base::MakeUnique?

[Daniel Erat, 2017/05/06 00:15:48]

Done.

+  pref_change_registrar_->Init(prefs_);
+  pref_change_registrar_->Add(prefs::kPowerAcIdleAction, callback);
+  pref_change_registrar_->Add(prefs::kPowerAcScreenDimDelayMs, callback);
+  pref_change_registrar_->Add(prefs::kPowerAcScreenOffDelayMs, callback);
+  pref_change_registrar_->Add(prefs::kPowerAcScreenLockDelayMs, callback);
+  pref_change_registrar_->Add(prefs::kPowerBatteryIdleAction, callback);
+  pref_change_registrar_->Add(prefs::kPowerBatteryScreenDimDelayMs, callback);
+  pref_change_registrar_->Add(prefs::kPowerBatteryScreenOffDelayMs, callback);
+  pref_change_registrar_->Add(prefs::kPowerBatteryScreenLockDelayMs, callback);
+  pref_change_registrar_->Add(prefs::kPowerLidClosedAction, callback);
 }
 
 void PowerHandler::OnJavascriptDisallowed() {
   power_observer_.RemoveAll();
+  pref_change_registrar_.reset();
 }
 
 void PowerHandler::OnPowerStatusChanged() {
@@ -85,6 +117,75 @@ void PowerHandler::HandleSetPowerSource(const base::ListValue* args) {
   power_status_->SetPowerSource(id);
 }
 
+void PowerHandler::HandleRequestPowerManagementSettings(
+    const base::ListValue* args) {
+  AllowJavascript();
+  SendPowerManagementSettings(true /* force */);
+}
+
+void PowerHandler::HandleSetIdleBehavior(const base::ListValue* args) {
+  AllowJavascript();
+
+  int value = 0;
+  CHECK(args->GetInteger(0, &value));
+  switch (static_cast<IdleBehavior>(value)) {
+    case IdleBehavior::DISPLAY_OFF_SLEEP:
+      prefs_->ClearPref(prefs::kPowerAcIdleAction);
+      prefs_->ClearPref(prefs::kPowerAcScreenDimDelayMs);
+      prefs_->ClearPref(prefs::kPowerAcScreenOffDelayMs);
+      prefs_->ClearPref(prefs::kPowerAcScreenLockDelayMs);
+      prefs_->ClearPref(prefs::kPowerBatteryIdleAction);
+      prefs_->ClearPref(prefs::kPowerBatteryScreenDimDelayMs);
+      prefs_->ClearPref(prefs::kPowerBatteryScreenOffDelayMs);
+      prefs_->ClearPref(prefs::kPowerBatteryScreenLockDelayMs);
+      break;
+    case IdleBehavior::DISPLAY_OFF_STAY_AWAKE:
+      prefs_->SetInteger(prefs::kPowerAcIdleAction,
+                         PowerPolicyController::ACTION_DO_NOTHING);
+      prefs_->ClearPref(prefs::kPowerAcScreenDimDelayMs);
+      prefs_->ClearPref(prefs::kPowerAcScreenOffDelayMs);
+      prefs_->ClearPref(prefs::kPowerAcScreenLockDelayMs);
+      prefs_->SetInteger(prefs::kPowerBatteryIdleAction,
+                         PowerPolicyController::ACTION_DO_NOTHING);
+      prefs_->ClearPref(prefs::kPowerBatteryScreenDimDelayMs);
+      prefs_->ClearPref(prefs::kPowerBatteryScreenOffDelayMs);
+      prefs_->ClearPref(prefs::kPowerBatteryScreenLockDelayMs);
+      break;
+    case IdleBehavior::DISPLAY_ON:
+      prefs_->SetInteger(prefs::kPowerAcIdleAction,
+                         PowerPolicyController::ACTION_DO_NOTHING);
+      prefs_->SetInteger(prefs::kPowerAcScreenDimDelayMs, 0);
+      prefs_->SetInteger(prefs::kPowerAcScreenOffDelayMs, 0);
+      prefs_->SetInteger(prefs::kPowerAcScreenLockDelayMs, 0);
+      prefs_->SetInteger(prefs::kPowerBatteryIdleAction,
+                         PowerPolicyController::ACTION_DO_NOTHING);
+      prefs_->SetInteger(prefs::kPowerBatteryScreenDimDelayMs, 0);
+      prefs_->SetInteger(prefs::kPowerBatteryScreenOffDelayMs, 0);
+      prefs_->SetInteger(prefs::kPowerBatteryScreenLockDelayMs, 0);
+      break;
+    default:
+      NOTREACHED() << "Invalid idle behavior " << value;
+  }
+}
+
+void PowerHandler::HandleSetLidClosedBehavior(const base::ListValue* args) {
+  AllowJavascript();
+
+  int value = 0;
+  CHECK(args->GetInteger(0, &value));
+  switch (static_cast<LidClosedBehavior>(value)) {
+    case LidClosedBehavior::SLEEP:
+      prefs_->ClearPref(prefs::kPowerLidClosedAction);
+      break;
+    case LidClosedBehavior::STAY_AWAKE:
+      prefs_->SetInteger(prefs::kPowerLidClosedAction,
+                         PowerPolicyController::ACTION_DO_NOTHING);
+      break;
+    default:
+      NOTREACHED() << "Invalid lid-closed behavior " << value;
+  }
+}
+
 void PowerHandler::SendBatteryStatus() {
   bool charging = power_status_->IsBatteryCharging();
   bool calculating = power_status_->IsBatteryTimeBeingCalculated();
@@ -136,5 +237,61 @@ void PowerHandler::SendPowerSources() {
                          base::Value(power_status_->IsUsbChargerConnected()));
 }
 
+void PowerHandler::SendPowerManagementSettings(bool force) {
+  // Infer the idle behavior based on the idle action (determining whether we'll
+  // sleep eventually or not) and the AC screen-off delay. Policy can request
+  // more-nuanced combinations of AC/battery actions and delays, but we wouldn't
+  // be able to display something meaningful in the UI in those cases anyway.
+  const IdleBehavior idle_behavior =
+      prefs_->GetInteger(prefs::kPowerAcIdleAction) ==

[michaelpg, 2017/05/04 17:36:26]

could you unpack this into at least 1 if statement, so it's easier to modify in
the future?

[Daniel Erat, 2017/05/06 00:15:48]

Done.

+              PowerPolicyController::ACTION_DO_NOTHING
+          ? (prefs_->GetInteger(prefs::kPowerAcScreenOffDelayMs) > 0
+                 ? IdleBehavior::DISPLAY_OFF_STAY_AWAKE
+                 : IdleBehavior::DISPLAY_ON)
+          : IdleBehavior::DISPLAY_OFF_SLEEP;
+  const bool idle_managed =
+      prefs_->IsManagedPreference(prefs::kPowerAcIdleAction) ||
+      prefs_->IsManagedPreference(prefs::kPowerAcScreenDimDelayMs) ||
+      prefs_->IsManagedPreference(prefs::kPowerAcScreenOffDelayMs) ||
+      prefs_->IsManagedPreference(prefs::kPowerAcScreenLockDelayMs) ||
+      prefs_->IsManagedPreference(prefs::kPowerBatteryIdleAction) ||
+      prefs_->IsManagedPreference(prefs::kPowerBatteryScreenDimDelayMs) ||
+      prefs_->IsManagedPreference(prefs::kPowerBatteryScreenOffDelayMs) ||
+      prefs_->IsManagedPreference(prefs::kPowerBatteryScreenLockDelayMs);
+
+  // Assume we'll sleep on lid-closed if the pref isn't set to "do nothing".
+  // It's possible that a different action has been set by policy, but that's
+  // rare and we don't want to make other actions available to users in the
+  // unmanaged case.

[Daniel Erat, 2017/05/02 00:58:42]

let me know if i'm being appropriately or inappropriately lazy here. :-P

i could update the JS side to support displaying additional actions (sign out,
shut down), but i don't want to let users choose those, so i'd probably only
include them in the <select> when the setting is managed. that might be even
more confusing...

[michaelpg, 2017/05/04 17:36:26]

Up to you. This may confuse debugging efforts. "I set the policy to shut down on
close, but this enrolled device shows Sleep, that must be why the battery drains
too fast!"

[Daniel Erat, 2017/05/06 00:15:48]

as mentioned on the .h file, i've changed things around so we show the actual
lid-closed behavior and use "Other" for unhandled idle behaviors.

+  const LidClosedBehavior lid_closed_behavior =
+      prefs_->GetInteger(prefs::kPowerLidClosedAction) ==
+              PowerPolicyController::ACTION_DO_NOTHING
+          ? LidClosedBehavior::STAY_AWAKE
+          : LidClosedBehavior::SLEEP;
+  const bool lid_closed_managed =
+      prefs_->IsManagedPreference(prefs::kPowerLidClosedAction);
+
+  // Don't notify the UI if nothing changed.
+  if (!force && idle_behavior == last_idle_behavior_ &&
+      idle_managed == last_idle_managed_ &&
+      lid_closed_behavior == last_lid_closed_behavior_ &&
+      lid_closed_managed == last_lid_closed_managed_)

[michaelpg, 2017/05/04 17:36:26]

style guide mandates { } around if body, since the condition is >1 line

[Daniel Erat, 2017/05/06 00:15:47]

not mandated by either the google or chromium c++ guides, and i think we use
both forms in chromium. after squinting at both, i don't think the brackets help
with readability here, so i've left it like this.

+    return;
+
+  base::DictionaryValue dict;
+  dict.SetInteger("idleBehavior", static_cast<int>(idle_behavior));
+  dict.SetBoolean("idleManaged", idle_managed);
+  dict.SetInteger("lidClosedBehavior", static_cast<int>(lid_closed_behavior));
+  dict.SetBoolean("lidClosedManaged", lid_closed_managed);
+  CallJavascriptFunction("cr.webUIListenerCallback",
+                         base::Value("power-management-settings-changed"),
+                         dict);
+
+  last_idle_behavior_ = idle_behavior;
+  last_idle_managed_ = idle_managed;
+  last_lid_closed_behavior_ = lid_closed_behavior;
+  last_lid_closed_managed_ = lid_closed_managed;
+}
+
 }  // namespace settings
 }  // namespace chromeos