Skip to content

GitLab

T
tangled
Commit ac7fe1b3 authored by derat@chromium.org's avatar derat@chromium.org
Browse files
Options

chromeos: Move default power management policy into Chrome. 

This updates PowerPolicyController to always send the power
management policy contained in Chrome's preferences to the
power manager, rather than only sending prefs that have been
changed from their defaults.  Note that this currently only
takes effect once the user has logged in.

It also makes the screen get locked at the same time as when
it's turned off when the "Require password to wake from
sleep" setting is enabled.

BUG=225730,225969

Review URL: https://codereview.chromium.org/14134004

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@195376 0039d316-1c4b-4281-b951-d872f2087c98
parent 382720d8
Expand all Hide whitespace changes
Inline Side-by-side
Showing with 370 additions and 313 deletions
chrome/browser/chromeos/preferences.cc
View file @ ac7fe1b3
......@@ -283,13 +283,6 @@ void Preferences::RegisterUserPrefs(PrefRegistrySyncable* registry) {
false,
PrefRegistrySyncable::UNSYNCABLE_PREF);
// TODO(derat): Right now, these values are just copied from powerd's
// defaults. Make this file be the canonical source of default power
// management settings. Note that these prefs' default values aren't
// currently expressive enough to convey powerd's default behavior, e.g.
// powerd shuts down instead of suspending when no user is logged in, and
// the default screen-lock delays are only used when
// prefs::kEnableScreenLock is set.
registry->RegisterIntegerPref(prefs::kPowerAcScreenDimDelayMs,
420000,
PrefRegistrySyncable::UNSYNCABLE_PREF);
......@@ -297,7 +290,7 @@ void Preferences::RegisterUserPrefs(PrefRegistrySyncable* registry) {
480000,
PrefRegistrySyncable::UNSYNCABLE_PREF);
registry->RegisterIntegerPref(prefs::kPowerAcScreenLockDelayMs,
600000,
0,
PrefRegistrySyncable::UNSYNCABLE_PREF);
registry->RegisterIntegerPref(prefs::kPowerAcIdleWarningDelayMs,
0,
......@@ -312,7 +305,7 @@ void Preferences::RegisterUserPrefs(PrefRegistrySyncable* registry) {
360000,
PrefRegistrySyncable::UNSYNCABLE_PREF);
registry->RegisterIntegerPref(prefs::kPowerBatteryScreenLockDelayMs,
600000,
0,
PrefRegistrySyncable::UNSYNCABLE_PREF);
registry->RegisterIntegerPref(prefs::kPowerBatteryIdleWarningDelayMs,
0,
......@@ -321,10 +314,10 @@ void Preferences::RegisterUserPrefs(PrefRegistrySyncable* registry) {
600000,
PrefRegistrySyncable::UNSYNCABLE_PREF);
registry->RegisterIntegerPref(prefs::kPowerIdleAction,
chromeos::PowerPolicyController::ACTION_SUSPEND,
PowerPolicyController::ACTION_SUSPEND,
PrefRegistrySyncable::UNSYNCABLE_PREF);
registry->RegisterIntegerPref(prefs::kPowerLidClosedAction,
chromeos::PowerPolicyController::ACTION_SUSPEND,
PowerPolicyController::ACTION_SUSPEND,
PrefRegistrySyncable::UNSYNCABLE_PREF);
registry->RegisterBooleanPref(prefs::kPowerUseAudioActivity,
true,
......@@ -789,23 +782,35 @@ void Preferences::NotifyPrefChanged(const std::string* pref_name) {
*pref_name == prefs::kPowerLidClosedAction ||
*pref_name == prefs::kPowerUseAudioActivity ||
*pref_name == prefs::kPowerUseVideoActivity ||
*pref_name == prefs::kPowerPresentationIdleDelayFactor) {
DBusThreadManager::Get()->GetPowerPolicyController()->UpdatePolicyFromPrefs(
*prefs_->FindPreference(prefs::kPowerAcScreenDimDelayMs),
*prefs_->FindPreference(prefs::kPowerAcScreenOffDelayMs),
*prefs_->FindPreference(prefs::kPowerAcScreenLockDelayMs),
*prefs_->FindPreference(prefs::kPowerAcIdleWarningDelayMs),
*prefs_->FindPreference(prefs::kPowerAcIdleDelayMs),
*prefs_->FindPreference(prefs::kPowerBatteryScreenDimDelayMs),
*prefs_->FindPreference(prefs::kPowerBatteryScreenOffDelayMs),
*prefs_->FindPreference(prefs::kPowerBatteryScreenLockDelayMs),
*prefs_->FindPreference(prefs::kPowerBatteryIdleWarningDelayMs),
*prefs_->FindPreference(prefs::kPowerBatteryIdleDelayMs),
*prefs_->FindPreference(prefs::kPowerIdleAction),
*prefs_->FindPreference(prefs::kPowerLidClosedAction),
*prefs_->FindPreference(prefs::kPowerUseAudioActivity),
*prefs_->FindPreference(prefs::kPowerUseVideoActivity),
*prefs_->FindPreference(prefs::kPowerPresentationIdleDelayFactor));
*pref_name == prefs::kPowerPresentationIdleDelayFactor ||
*pref_name == prefs::kEnableScreenLock) {
PowerPolicyController::PrefValues values;
values.ac_screen_dim_delay_ms = power_ac_screen_dim_delay_ms_.GetValue();
values.ac_screen_off_delay_ms = power_ac_screen_off_delay_ms_.GetValue();
values.ac_screen_lock_delay_ms = power_ac_screen_lock_delay_ms_.GetValue();
values.ac_idle_warning_delay_ms =
power_ac_idle_warning_delay_ms_.GetValue();
values.ac_idle_delay_ms = power_ac_idle_delay_ms_.GetValue();
values.battery_screen_dim_delay_ms =
power_battery_screen_dim_delay_ms_.GetValue();
values.battery_screen_off_delay_ms =
power_battery_screen_off_delay_ms_.GetValue();
values.battery_screen_lock_delay_ms =
power_battery_screen_lock_delay_ms_.GetValue();
values.battery_idle_warning_delay_ms =
power_battery_idle_warning_delay_ms_.GetValue();
values.battery_idle_delay_ms = power_battery_idle_delay_ms_.GetValue();
values.idle_action = static_cast<PowerPolicyController::Action>(
power_idle_action_.GetValue());
values.lid_closed_action = static_cast<PowerPolicyController::Action>(
power_lid_closed_action_.GetValue());
values.use_audio_activity = power_use_audio_activity_.GetValue();
values.use_video_activity = power_use_video_activity_.GetValue();
values.enable_screen_lock = enable_screen_lock_.GetValue();
values.presentation_idle_delay_factor =
power_presentation_idle_delay_factor_.GetValue();
DBusThreadManager::Get()->GetPowerPolicyController()->ApplyPrefs(values);
}
}
......
chromeos/dbus/power_policy_controller.cc
View file @ ac7fe1b3
This diff is collapsed.
chromeos/dbus/power_policy_controller.h
View file @ ac7fe1b3
......@@ -10,7 +10,6 @@
#include "base/basictypes.h"
#include "base/compiler_specific.h"
#include "base/prefs/pref_service.h"
#include "chromeos/chromeos_export.h"
#include "chromeos/dbus/dbus_thread_manager_observer.h"
#include "chromeos/dbus/power_manager/policy.pb.h"
......@@ -34,37 +33,47 @@ class CHROMEOS_EXPORT PowerPolicyController
ACTION_DO_NOTHING = 3,
};
// Values of various power-management-related preferences.
struct PrefValues {
PrefValues();
int ac_screen_dim_delay_ms;
int ac_screen_off_delay_ms;
int ac_screen_lock_delay_ms;
int ac_idle_warning_delay_ms;
int ac_idle_delay_ms;
int battery_screen_dim_delay_ms;
int battery_screen_off_delay_ms;
int battery_screen_lock_delay_ms;
int battery_idle_warning_delay_ms;
int battery_idle_delay_ms;
Action idle_action;
Action lid_closed_action;
bool use_audio_activity;
bool use_video_activity;
bool enable_screen_lock;
double presentation_idle_delay_factor;
};
// Returns a string describing |policy|. Useful for tests.
static std::string GetPolicyDebugString(
const power_manager::PowerManagementPolicy& policy);
PowerPolicyController(DBusThreadManager* manager, PowerManagerClient* client);
virtual ~PowerPolicyController();
// Sends an updated policy to the power manager based on the current
// values of the passed-in prefs.
void UpdatePolicyFromPrefs(
const PrefService::Preference& ac_screen_dim_delay_ms_pref,
const PrefService::Preference& ac_screen_off_delay_ms_pref,
const PrefService::Preference& ac_screen_lock_delay_ms_pref,
const PrefService::Preference& ac_idle_warning_delay_ms_pref,
const PrefService::Preference& ac_idle_delay_ms_pref,
const PrefService::Preference& battery_screen_dim_delay_ms_pref,
const PrefService::Preference& battery_screen_off_delay_ms_pref,
const PrefService::Preference& battery_screen_lock_delay_ms_pref,
const PrefService::Preference& battery_idle_warning_delay_ms_pref,
const PrefService::Preference& battery_idle_delay_ms_pref,
const PrefService::Preference& idle_action_pref,
const PrefService::Preference& lid_closed_action_pref,
const PrefService::Preference& use_audio_activity_pref,
const PrefService::Preference& use_video_activity_pref,
const PrefService::Preference& presentation_idle_delay_factor_pref);
// Updates |prefs_policy_| with |values| and sends an updated policy.
void ApplyPrefs(const PrefValues& values);
// Registers a request to temporarily prevent the screen from getting
// dimmed or turned off or the system from suspending in response to user
// inactivity. Returns a unique ID that can be passed to RemoveBlock()
// later.
// inactivity and sends an updated policy. Returns a unique ID that can
// be passed to RemoveBlock() later.
int AddScreenBlock(const std::string& reason);
int AddSuspendBlock(const std::string& reason);
// Unregisters a request previously created via AddScreenBlock() or
// AddSuspendBlock().
// AddSuspendBlock() and sends an updated policy.
void RemoveBlock(int id);
// DBusThreadManagerObserver implementation:
......@@ -86,11 +95,10 @@ class CHROMEOS_EXPORT PowerPolicyController
DBusThreadManager* manager_; // not owned
PowerManagerClient* client_; // not owned
// Policy specified by the prefs that were last passed to
// UpdatePolicyFromPrefs().
// Policy derived from values passed to ApplyPrefs().
power_manager::PowerManagementPolicy prefs_policy_;
// Are one or more fields set in |prefs_policy_|?
// Was ApplyPrefs() called?
bool prefs_were_set_;
// Maps from an ID representing a request to prevent the screen from
......
chromeos/dbus/power_policy_controller_unittest.cc
View file @ ac7fe1b3
......@@ -26,12 +26,7 @@ class PowerPolicyControllerTest : public testing::Test {
power_client_ = dbus_manager_->mock_power_manager_client();
EXPECT_CALL(*power_client_, SetPolicy(_))
.WillRepeatedly(SaveArg<0>(&last_policy_));
policy_controller_ = dbus_manager_->GetPowerPolicyController();
// TODO(derat): Write what looks like it will be a ridiculously large
// amount of code to register prefs so that UpdatePolicyFromPrefs() can
// be tested.
}
virtual void TearDown() OVERRIDE {
......@@ -46,6 +41,76 @@ class PowerPolicyControllerTest : public testing::Test {
power_manager::PowerManagementPolicy last_policy_;
};
TEST_F(PowerPolicyControllerTest, Prefs) {
PowerPolicyController::PrefValues prefs;
prefs.ac_screen_dim_delay_ms = 600000;
prefs.ac_screen_off_delay_ms = 660000;
prefs.ac_idle_delay_ms = 720000;
prefs.battery_screen_dim_delay_ms = 300000;
prefs.battery_screen_off_delay_ms = 360000;
prefs.battery_idle_delay_ms = 420000;
prefs.idle_action = PowerPolicyController::ACTION_SUSPEND;
prefs.lid_closed_action = PowerPolicyController::ACTION_SHUT_DOWN;
prefs.use_audio_activity = true;
prefs.use_video_activity = true;
prefs.enable_screen_lock = false;
prefs.presentation_idle_delay_factor = 2.0;
policy_controller_->ApplyPrefs(prefs);
power_manager::PowerManagementPolicy expected_policy;
expected_policy.mutable_ac_delays()->set_screen_dim_ms(600000);
expected_policy.mutable_ac_delays()->set_screen_off_ms(660000);
expected_policy.mutable_ac_delays()->set_screen_lock_ms(-1);
expected_policy.mutable_ac_delays()->set_idle_warning_ms(-1);
expected_policy.mutable_ac_delays()->set_idle_ms(720000);
expected_policy.mutable_battery_delays()->set_screen_dim_ms(300000);
expected_policy.mutable_battery_delays()->set_screen_off_ms(360000);
expected_policy.mutable_battery_delays()->set_screen_lock_ms(-1);
expected_policy.mutable_battery_delays()->set_idle_warning_ms(-1);
expected_policy.mutable_battery_delays()->set_idle_ms(420000);
expected_policy.set_idle_action(
power_manager::PowerManagementPolicy_Action_SUSPEND);
expected_policy.set_lid_closed_action(
power_manager::PowerManagementPolicy_Action_SHUT_DOWN);
expected_policy.set_use_audio_activity(true);
expected_policy.set_use_video_activity(true);
expected_policy.set_presentation_idle_delay_factor(2.0);
expected_policy.set_reason("Prefs");
EXPECT_EQ(PowerPolicyController::GetPolicyDebugString(expected_policy),
PowerPolicyController::GetPolicyDebugString(last_policy_));
// Change some prefs and check that an updated policy is sent.
prefs.ac_idle_warning_delay_ms = 700000;
prefs.battery_idle_warning_delay_ms = 400000;
prefs.lid_closed_action = PowerPolicyController::ACTION_SUSPEND;
policy_controller_->ApplyPrefs(prefs);
expected_policy.mutable_ac_delays()->set_idle_warning_ms(700000);
expected_policy.mutable_battery_delays()->set_idle_warning_ms(400000);
expected_policy.set_lid_closed_action(
power_manager::PowerManagementPolicy_Action_SUSPEND);
EXPECT_EQ(PowerPolicyController::GetPolicyDebugString(expected_policy),
PowerPolicyController::GetPolicyDebugString(last_policy_));
// The enable-screen-lock pref should force the screen-lock delays to
// match the screen-off delays.
prefs.enable_screen_lock = true;
policy_controller_->ApplyPrefs(prefs);
expected_policy.mutable_ac_delays()->set_screen_lock_ms(660000);
expected_policy.mutable_battery_delays()->set_screen_lock_ms(360000);
EXPECT_EQ(PowerPolicyController::GetPolicyDebugString(expected_policy),
PowerPolicyController::GetPolicyDebugString(last_policy_));
// If the screen-lock-delay prefs are set to lower values than the
// screen-off delays, the lock prefs should take precedence.
prefs.ac_screen_lock_delay_ms = 70000;
prefs.battery_screen_lock_delay_ms = 60000;
policy_controller_->ApplyPrefs(prefs);
expected_policy.mutable_ac_delays()->set_screen_lock_ms(70000);
expected_policy.mutable_battery_delays()->set_screen_lock_ms(60000);
EXPECT_EQ(PowerPolicyController::GetPolicyDebugString(expected_policy),
PowerPolicyController::GetPolicyDebugString(last_policy_));
}
TEST_F(PowerPolicyControllerTest, Blocks) {
const char kSuspendBlockReason[] = "suspend";
const int suspend_id =
......@@ -54,8 +119,8 @@ TEST_F(PowerPolicyControllerTest, Blocks) {
expected_policy.set_idle_action(
power_manager::PowerManagementPolicy_Action_DO_NOTHING);
expected_policy.set_reason(kSuspendBlockReason);
EXPECT_EQ(expected_policy.SerializeAsString(),
last_policy_.SerializeAsString());
EXPECT_EQ(PowerPolicyController::GetPolicyDebugString(expected_policy),
PowerPolicyController::GetPolicyDebugString(last_policy_));
const char kScreenBlockReason[] = "screen";
const int screen_id = policy_controller_->AddScreenBlock(kScreenBlockReason);
......@@ -65,18 +130,18 @@ TEST_F(PowerPolicyControllerTest, Blocks) {
expected_policy.mutable_battery_delays()->set_screen_off_ms(0);
expected_policy.set_reason(
std::string(kScreenBlockReason) + ", " + kSuspendBlockReason);
EXPECT_EQ(expected_policy.SerializeAsString(),
last_policy_.SerializeAsString());
EXPECT_EQ(PowerPolicyController::GetPolicyDebugString(expected_policy),
PowerPolicyController::GetPolicyDebugString(last_policy_));
policy_controller_->RemoveBlock(suspend_id);
expected_policy.set_reason(kScreenBlockReason);
EXPECT_EQ(expected_policy.SerializeAsString(),
last_policy_.SerializeAsString());
EXPECT_EQ(PowerPolicyController::GetPolicyDebugString(expected_policy),
PowerPolicyController::GetPolicyDebugString(last_policy_));
policy_controller_->RemoveBlock(screen_id);
expected_policy.Clear();
EXPECT_EQ(expected_policy.SerializeAsString(),
last_policy_.SerializeAsString());
EXPECT_EQ(PowerPolicyController::GetPolicyDebugString(expected_policy),
PowerPolicyController::GetPolicyDebugString(last_policy_));
}
} // namespace chromeos
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment