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..9c70b864ce1105bad0a4e71a70b5fadc3e65c7ac 100644
--- a/chrome/browser/ui/webui/settings/chromeos/device_power_handler.cc
+++ b/chrome/browser/ui/webui/settings/chromeos/device_power_handler.cc
@@ -10,10 +10,15 @@
 #include "ash/resources/grit/ash_resources.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
+#include "base/memory/ptr_util.h"
 #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 +48,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 +62,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_ = base::MakeUnique<PrefChangeRegistrar>();
+  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 +118,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<PowerPolicyController::Action>(value)) {
+    case PowerPolicyController::ACTION_SUSPEND:
+      prefs_->ClearPref(prefs::kPowerLidClosedAction);
+      break;
+    case PowerPolicyController::ACTION_DO_NOTHING:
+      prefs_->SetInteger(prefs::kPowerLidClosedAction,
+                         PowerPolicyController::ACTION_DO_NOTHING);
+      break;
+    default:
+      NOTREACHED() << "Unsupported lid-closed behavior " << value;
+  }
+}
+
 void PowerHandler::SendBatteryStatus() {
   bool charging = power_status_->IsBatteryCharging();
   bool calculating = power_status_->IsBatteryTimeBeingCalculated();
@@ -136,5 +238,60 @@ 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 PowerPolicyController::Action idle_action =
+      static_cast<PowerPolicyController::Action>(
+          prefs_->GetInteger(prefs::kPowerAcIdleAction));
+  IdleBehavior idle_behavior = IdleBehavior::OTHER;
+  if (idle_action == PowerPolicyController::ACTION_SUSPEND) {
+    idle_behavior = IdleBehavior::DISPLAY_OFF_SLEEP;
+  } else if (idle_action == PowerPolicyController::ACTION_DO_NOTHING) {
+    idle_behavior = (prefs_->GetInteger(prefs::kPowerAcScreenOffDelayMs) > 0
+                         ? IdleBehavior::DISPLAY_OFF_STAY_AWAKE
+                         : IdleBehavior::DISPLAY_ON);
+  }
+
+  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);
+
+  const PowerPolicyController::Action lid_closed_behavior =
+      static_cast<PowerPolicyController::Action>(
+          prefs_->GetInteger(prefs::kPowerLidClosedAction));
+  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_)
+    return;
+
+  base::DictionaryValue dict;
+  dict.SetInteger("idleBehavior", static_cast<int>(idle_behavior));
+  dict.SetBoolean("idleManaged", idle_managed);
+  dict.SetInteger("lidClosedBehavior", 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