chromeos: Add settings to control power management prefs.

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

 // Copyright 2017 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/ui/webui/settings/chromeos/device_power_handler.h"
 
 #include <memory>
 #include <utility>
 
 #include "ash/resources/grit/ash_resources.h"
 #include "base/bind.h"
 #include "base/bind_helpers.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"
 #include "ui/base/webui/web_ui_util.h"
 
 namespace chromeos {
 namespace settings {
 namespace {
 
 base::string16 GetBatteryTimeText(base::TimeDelta time_left) {
   int hour = 0;
   int min = 0;
   ash::PowerStatus::SplitTimeIntoHoursAndMinutes(time_left, &hour, &min);
 
   base::string16 time_text;
   if (hour == 0 || min == 0) {
     // Display only one unit ("2 hours" or "10 minutes").
     return ui::TimeFormat::Simple(ui::TimeFormat::FORMAT_DURATION,
                                   ui::TimeFormat::LENGTH_LONG, time_left);
   }
 
   return ui::TimeFormat::Detailed(ui::TimeFormat::FORMAT_DURATION,
                                   ui::TimeFormat::LENGTH_LONG,
                                   -1,  // force hour and minute output
                                   time_left);
 }
 
 }  // namespace
 
-PowerHandler::PowerHandler()
-    : power_observer_(this) {
+PowerHandler::PowerHandler(PrefService* prefs)
+    : prefs_(prefs), power_observer_(this) {
   power_status_ = ash::PowerStatus::Get();
 }
 
 PowerHandler::~PowerHandler() {}
 
 void PowerHandler::RegisterMessages() {
   web_ui()->RegisterMessageCallback(
       "updatePowerStatus", base::Bind(&PowerHandler::HandleUpdatePowerStatus,
                                       base::Unretained(this)));
   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() {
   SendBatteryStatus();
   SendPowerSources();
 }
 
 void PowerHandler::HandleUpdatePowerStatus(const base::ListValue* args) {
   AllowJavascript();
   power_status_->RequestStatusUpdate();
 }
 
 void PowerHandler::HandleSetPowerSource(const base::ListValue* args) {
   AllowJavascript();
 
   std::string id;
   CHECK(args->GetString(0, &id));
   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();
   int percent = power_status_->GetRoundedBatteryPercent();
   base::TimeDelta time_left;
   bool show_time = false;
 
   if (!calculating) {
     time_left = charging ? power_status_->GetBatteryTimeToFull()
                          : power_status_->GetBatteryTimeToEmpty();
@@ skipping 31 matching lines @@
                     l10n_util::GetStringUTF16(source.description_id));
     sources_list.Append(std::move(dict));
   }
 
   CallJavascriptFunction("cr.webUIListenerCallback",
                          base::Value("power-sources-changed"), sources_list,
                          base::Value(power_status_->GetCurrentPowerSourceID()),
                          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