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
Hide whitespace changes
Inline Side-by-side
Showing with 370 additions and 313 deletions
chrome/browser/chromeos/policy/power_policy_browsertest.cc
View file @ ac7fe1b3
...@@ -18,6 +18,7 @@ ...@@ -18,6 +18,7 @@
#include "chromeos/dbus/mock_session_manager_client.h" #include "chromeos/dbus/mock_session_manager_client.h"
#include "chromeos/dbus/mock_update_engine_client.h" #include "chromeos/dbus/mock_update_engine_client.h"
#include "chromeos/dbus/power_manager/policy.pb.h" #include "chromeos/dbus/power_manager/policy.pb.h"
#include "chromeos/dbus/power_policy_controller.h"
#include "policy/policy_constants.h" #include "policy/policy_constants.h"
#include "testing/gmock/include/gmock/gmock.h" #include "testing/gmock/include/gmock/gmock.h"
...@@ -29,28 +30,11 @@ using ::testing::AnyNumber; ...@@ -29,28 +30,11 @@ using ::testing::AnyNumber;
using ::testing::AtLeast; using ::testing::AtLeast;
using ::testing::Mock; using ::testing::Mock;
using ::testing::Return; using ::testing::Return;
using ::testing::SaveArg;
using ::testing::_; using ::testing::_;
namespace pm = power_manager; namespace pm = power_manager;
MATCHER_P(PowerManagementPolicyMatches, expected_power_management_policy,
std::string(negation ? "matches" : "does not match") +
"the expected power management policy") {
// A power management policy without an |ac_delays| message is equivalent to
// a power management policy with an empty |ac_delays| message but their
// serializations are different. To simplify the equality check, ensure that
// the expected and actual power management policies both have an |ac_delays|
// message. The same applies to the |battery_delays| message.
pm::PowerManagementPolicy expected(expected_power_management_policy);
expected.mutable_ac_delays();
expected.mutable_battery_delays();
pm::PowerManagementPolicy actual(arg);
actual.mutable_ac_delays();
actual.mutable_battery_delays();
actual.clear_reason();
return actual.SerializeAsString() == expected.SerializeAsString();
}
} // namespace } // namespace
class PowerPolicyBrowserTest : public InProcessBrowserTest { class PowerPolicyBrowserTest : public InProcessBrowserTest {
...@@ -58,13 +42,18 @@ class PowerPolicyBrowserTest : public InProcessBrowserTest { ...@@ -58,13 +42,18 @@ class PowerPolicyBrowserTest : public InProcessBrowserTest {
// InProcessBrowserTest: // InProcessBrowserTest:
virtual void SetUpInProcessBrowserTestFixture() OVERRIDE; virtual void SetUpInProcessBrowserTestFixture() OVERRIDE;
void SetUserPolicyAndVerifyPowerManagementPolicy( // Sets |user_policy_name| to |user_policy_value|.
const std::string& user_policy_name, void SetUserPolicy(const std::string& user_policy_name,
base::Value* user_policy_value, base::Value* user_policy_value);
const pm::PowerManagementPolicy& power_management_policy);
// Returns a string describing |policy|.
std::string GetDebugString(const pm::PowerManagementPolicy& policy);
chromeos::MockPowerManagerClient* power_manager_client_; chromeos::MockPowerManagerClient* power_manager_client_;
// Last PowerManagementPolicy sent by |power_manager_client_|.
pm::PowerManagementPolicy last_power_management_policy_;
private: private:
MockConfigurationPolicyProvider provider_; MockConfigurationPolicyProvider provider_;
}; };
...@@ -72,152 +61,151 @@ class PowerPolicyBrowserTest : public InProcessBrowserTest { ...@@ -72,152 +61,151 @@ class PowerPolicyBrowserTest : public InProcessBrowserTest {
void PowerPolicyBrowserTest::SetUpInProcessBrowserTestFixture() { void PowerPolicyBrowserTest::SetUpInProcessBrowserTestFixture() {
chromeos::MockDBusThreadManager* dbus_thread_manager = chromeos::MockDBusThreadManager* dbus_thread_manager =
new chromeos::MockDBusThreadManager; new chromeos::MockDBusThreadManager;
power_manager_client_ = dbus_thread_manager->mock_power_manager_client();
// Capture the PowerManagementPolicy that's sent before tests start
// making changes to the user policy.
EXPECT_CALL(*power_manager_client_, SetPolicy(_))
.WillRepeatedly(SaveArg<0>(&last_power_management_policy_));
// Ignore uninteresting calls.
EXPECT_CALL(*power_manager_client_, AddObserver(_))
.Times(AnyNumber());
EXPECT_CALL(*power_manager_client_, RemoveObserver(_))
.Times(AnyNumber());
chromeos::DBusThreadManager::InitializeForTesting(dbus_thread_manager); chromeos::DBusThreadManager::InitializeForTesting(dbus_thread_manager);
EXPECT_CALL(*dbus_thread_manager->mock_session_manager_client(), EXPECT_CALL(*dbus_thread_manager->mock_session_manager_client(),
RetrieveUserPolicy(_)); RetrieveUserPolicy(_));
power_manager_client_ = dbus_thread_manager->mock_power_manager_client();
EXPECT_CALL(provider_, IsInitializationComplete(_)) EXPECT_CALL(provider_, IsInitializationComplete(_))
.WillRepeatedly(Return(true)); .WillRepeatedly(Return(true));
EXPECT_CALL(provider_, RegisterPolicyDomain(_, _)).Times(AnyNumber()); EXPECT_CALL(provider_, RegisterPolicyDomain(_, _)).Times(AnyNumber());
BrowserPolicyConnector::SetPolicyProviderForTesting(&provider_); BrowserPolicyConnector::SetPolicyProviderForTesting(&provider_);
} }
// Verify that setting |user_policy_name| to |user_policy_value| causes the void PowerPolicyBrowserTest::SetUserPolicy(
// updated |power_management_policy| to be sent to the power management backend.
void PowerPolicyBrowserTest::SetUserPolicyAndVerifyPowerManagementPolicy(
const std::string& user_policy_name, const std::string& user_policy_name,
base::Value* user_policy_value, base::Value* user_policy_value) {
const pm::PowerManagementPolicy& power_management_policy) {
// Setting the user policy causes a notification which triggers an update to
// the backend. If other policies had been set before, they will get unset,
// causing additional notifications and triggering duplicate updates to the
// backend. Hence, expect one or more updates.
EXPECT_CALL(*power_manager_client_,
SetPolicy(PowerManagementPolicyMatches(power_management_policy)))
.Times(AtLeast(1));
PolicyMap policy_map; PolicyMap policy_map;
policy_map.Set(user_policy_name, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, policy_map.Set(user_policy_name, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
user_policy_value); user_policy_value);
provider_.UpdateChromePolicy(policy_map); provider_.UpdateChromePolicy(policy_map);
base::RunLoop().RunUntilIdle(); base::RunLoop().RunUntilIdle();
Mock::VerifyAndClearExpectations(power_manager_client_); }
std::string PowerPolicyBrowserTest::GetDebugString(
const pm::PowerManagementPolicy& policy) {
return chromeos::PowerPolicyController::GetPolicyDebugString(policy);
} }
IN_PROC_BROWSER_TEST_F(PowerPolicyBrowserTest, SetPowerPolicy) { IN_PROC_BROWSER_TEST_F(PowerPolicyBrowserTest, SetPowerPolicy) {
pm::PowerManagementPolicy power_management_policy; pm::PowerManagementPolicy original_power_management_policy =
last_power_management_policy_;
pm::PowerManagementPolicy power_management_policy =
original_power_management_policy;
power_management_policy.set_idle_action( power_management_policy.set_idle_action(
pm::PowerManagementPolicy::STOP_SESSION); pm::PowerManagementPolicy::STOP_SESSION);
SetUserPolicyAndVerifyPowerManagementPolicy( SetUserPolicy(
key::kIdleAction, key::kIdleAction,
base::Value::CreateIntegerValue(pm::PowerManagementPolicy::STOP_SESSION), base::Value::CreateIntegerValue(pm::PowerManagementPolicy::STOP_SESSION));
power_management_policy); EXPECT_EQ(GetDebugString(power_management_policy),
GetDebugString(last_power_management_policy_));
power_management_policy.Clear(); power_management_policy = original_power_management_policy;
power_management_policy.set_lid_closed_action( power_management_policy.set_lid_closed_action(
pm::PowerManagementPolicy::STOP_SESSION); pm::PowerManagementPolicy::STOP_SESSION);
SetUserPolicyAndVerifyPowerManagementPolicy( SetUserPolicy(
key::kLidCloseAction, key::kLidCloseAction,
base::Value::CreateIntegerValue(pm::PowerManagementPolicy::STOP_SESSION), base::Value::CreateIntegerValue(pm::PowerManagementPolicy::STOP_SESSION));
power_management_policy); EXPECT_EQ(GetDebugString(power_management_policy),
GetDebugString(last_power_management_policy_));
power_management_policy.Clear();
power_management_policy.mutable_ac_delays()->set_idle_ms(900000); power_management_policy = original_power_management_policy;
SetUserPolicyAndVerifyPowerManagementPolicy( power_management_policy.mutable_ac_delays()->set_idle_ms(9000);
key::kIdleDelayAC, SetUserPolicy(key::kIdleDelayAC, base::Value::CreateIntegerValue(9000));
base::Value::CreateIntegerValue(900000), EXPECT_EQ(GetDebugString(power_management_policy),
power_management_policy); GetDebugString(last_power_management_policy_));
power_management_policy.Clear(); power_management_policy = original_power_management_policy;
power_management_policy.mutable_ac_delays()->set_idle_warning_ms(900000); power_management_policy.mutable_ac_delays()->set_idle_warning_ms(8000);
SetUserPolicyAndVerifyPowerManagementPolicy( SetUserPolicy(key::kIdleWarningDelayAC,
key::kIdleWarningDelayAC, base::Value::CreateIntegerValue(8000));
base::Value::CreateIntegerValue(900000), EXPECT_EQ(GetDebugString(power_management_policy),
power_management_policy); GetDebugString(last_power_management_policy_));
power_management_policy.Clear(); power_management_policy = original_power_management_policy;
power_management_policy.mutable_ac_delays()->set_screen_off_ms(900000); power_management_policy.mutable_ac_delays()->set_screen_off_ms(7000);
SetUserPolicyAndVerifyPowerManagementPolicy( SetUserPolicy(key::kScreenOffDelayAC, base::Value::CreateIntegerValue(7000));
key::kScreenOffDelayAC, EXPECT_EQ(GetDebugString(power_management_policy),
base::Value::CreateIntegerValue(900000), GetDebugString(last_power_management_policy_));
power_management_policy);
power_management_policy = original_power_management_policy;
power_management_policy.Clear(); power_management_policy.mutable_ac_delays()->set_screen_dim_ms(5000);
power_management_policy.mutable_ac_delays()->set_screen_dim_ms(900000); SetUserPolicy(key::kScreenDimDelayAC, base::Value::CreateIntegerValue(5000));
SetUserPolicyAndVerifyPowerManagementPolicy( EXPECT_EQ(GetDebugString(power_management_policy),
key::kScreenDimDelayAC, GetDebugString(last_power_management_policy_));
base::Value::CreateIntegerValue(900000),
power_management_policy); power_management_policy = original_power_management_policy;
power_management_policy.mutable_ac_delays()->set_screen_lock_ms(6000);
power_management_policy.Clear(); SetUserPolicy(key::kScreenLockDelayAC, base::Value::CreateIntegerValue(6000));
power_management_policy.mutable_ac_delays()->set_screen_lock_ms(900000); EXPECT_EQ(GetDebugString(power_management_policy),
SetUserPolicyAndVerifyPowerManagementPolicy( GetDebugString(last_power_management_policy_));
key::kScreenLockDelayAC,
base::Value::CreateIntegerValue(900000), power_management_policy = original_power_management_policy;
power_management_policy); power_management_policy.mutable_battery_delays()->set_idle_ms(5000);
SetUserPolicy(key::kIdleDelayBattery, base::Value::CreateIntegerValue(5000));
power_management_policy.Clear(); EXPECT_EQ(GetDebugString(power_management_policy),
power_management_policy.mutable_battery_delays()->set_idle_ms(900000); GetDebugString(last_power_management_policy_));
SetUserPolicyAndVerifyPowerManagementPolicy(
key::kIdleDelayBattery, power_management_policy = original_power_management_policy;
base::Value::CreateIntegerValue(900000), power_management_policy.mutable_battery_delays()->set_idle_warning_ms(4000);
power_management_policy); SetUserPolicy(key::kIdleWarningDelayBattery,
base::Value::CreateIntegerValue(4000));
power_management_policy.Clear(); EXPECT_EQ(GetDebugString(power_management_policy),
power_management_policy.mutable_battery_delays()->set_idle_warning_ms(900000); GetDebugString(last_power_management_policy_));
SetUserPolicyAndVerifyPowerManagementPolicy(
key::kIdleWarningDelayBattery, power_management_policy = original_power_management_policy;
base::Value::CreateIntegerValue(900000), power_management_policy.mutable_battery_delays()->set_screen_off_ms(3000);
power_management_policy); SetUserPolicy(key::kScreenOffDelayBattery,
base::Value::CreateIntegerValue(3000));
power_management_policy.Clear(); EXPECT_EQ(GetDebugString(power_management_policy),
power_management_policy.mutable_battery_delays()->set_screen_off_ms(900000); GetDebugString(last_power_management_policy_));
SetUserPolicyAndVerifyPowerManagementPolicy(
key::kScreenOffDelayBattery, power_management_policy = original_power_management_policy;
base::Value::CreateIntegerValue(900000), power_management_policy.mutable_battery_delays()->set_screen_dim_ms(1000);
power_management_policy); SetUserPolicy(key::kScreenDimDelayBattery,
base::Value::CreateIntegerValue(1000));
power_management_policy.Clear(); EXPECT_EQ(GetDebugString(power_management_policy),
power_management_policy.mutable_battery_delays()->set_screen_dim_ms(900000); GetDebugString(last_power_management_policy_));
SetUserPolicyAndVerifyPowerManagementPolicy(
key::kScreenDimDelayBattery, power_management_policy = original_power_management_policy;
base::Value::CreateIntegerValue(900000), power_management_policy.mutable_battery_delays()->set_screen_lock_ms(2000);
power_management_policy); SetUserPolicy(key::kScreenLockDelayBattery,
base::Value::CreateIntegerValue(2000));
power_management_policy.Clear(); EXPECT_EQ(GetDebugString(power_management_policy),
power_management_policy.mutable_battery_delays()->set_screen_lock_ms(900000); GetDebugString(last_power_management_policy_));
SetUserPolicyAndVerifyPowerManagementPolicy(
key::kScreenLockDelayBattery, power_management_policy = original_power_management_policy;
base::Value::CreateIntegerValue(900000),
power_management_policy);
power_management_policy.Clear();
power_management_policy.set_use_audio_activity(false); power_management_policy.set_use_audio_activity(false);
SetUserPolicyAndVerifyPowerManagementPolicy( SetUserPolicy(key::kPowerManagementUsesAudioActivity,
key::kPowerManagementUsesAudioActivity, base::Value::CreateBooleanValue(false));
base::Value::CreateBooleanValue(false), EXPECT_EQ(GetDebugString(power_management_policy),
power_management_policy); GetDebugString(last_power_management_policy_));
power_management_policy.Clear(); power_management_policy = original_power_management_policy;
power_management_policy.set_use_video_activity(false); power_management_policy.set_use_video_activity(false);
SetUserPolicyAndVerifyPowerManagementPolicy( SetUserPolicy(key::kPowerManagementUsesVideoActivity,
key::kPowerManagementUsesVideoActivity, base::Value::CreateBooleanValue(false));
base::Value::CreateBooleanValue(false), EXPECT_EQ(GetDebugString(power_management_policy),
power_management_policy); GetDebugString(last_power_management_policy_));
power_management_policy.Clear(); power_management_policy = original_power_management_policy;
power_management_policy.set_presentation_idle_delay_factor(3.0); power_management_policy.set_presentation_idle_delay_factor(3.0);
SetUserPolicyAndVerifyPowerManagementPolicy( SetUserPolicy(key::kPresentationIdleDelayScale,
key::kPresentationIdleDelayScale, base::Value::CreateIntegerValue(300));
base::Value::CreateIntegerValue(300), EXPECT_EQ(GetDebugString(power_management_policy),
power_management_policy); GetDebugString(last_power_management_policy_));
// During teardown, an empty power management policy should be sent to the
// backend.
power_management_policy.Clear();
EXPECT_CALL(*power_manager_client_, SetPolicy(
PowerManagementPolicyMatches(power_management_policy)));
EXPECT_CALL(*power_manager_client_, RemoveObserver(_)).Times(AnyNumber());
} }
} // namespace policy } // namespace policy
chrome/browser/chromeos/preferences.cc
View file @ ac7fe1b3
...@@ -283,13 +283,6 @@ void Preferences::RegisterUserPrefs(PrefRegistrySyncable* registry) { ...@@ -283,13 +283,6 @@ void Preferences::RegisterUserPrefs(PrefRegistrySyncable* registry) {
false, false,
PrefRegistrySyncable::UNSYNCABLE_PREF); 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, registry->RegisterIntegerPref(prefs::kPowerAcScreenDimDelayMs,
420000, 420000,
PrefRegistrySyncable::UNSYNCABLE_PREF); PrefRegistrySyncable::UNSYNCABLE_PREF);
...@@ -297,7 +290,7 @@ void Preferences::RegisterUserPrefs(PrefRegistrySyncable* registry) { ...@@ -297,7 +290,7 @@ void Preferences::RegisterUserPrefs(PrefRegistrySyncable* registry) {
480000, 480000,
PrefRegistrySyncable::UNSYNCABLE_PREF); PrefRegistrySyncable::UNSYNCABLE_PREF);
registry->RegisterIntegerPref(prefs::kPowerAcScreenLockDelayMs, registry->RegisterIntegerPref(prefs::kPowerAcScreenLockDelayMs,
600000, 0,
PrefRegistrySyncable::UNSYNCABLE_PREF); PrefRegistrySyncable::UNSYNCABLE_PREF);
registry->RegisterIntegerPref(prefs::kPowerAcIdleWarningDelayMs, registry->RegisterIntegerPref(prefs::kPowerAcIdleWarningDelayMs,
0, 0,
...@@ -312,7 +305,7 @@ void Preferences::RegisterUserPrefs(PrefRegistrySyncable* registry) { ...@@ -312,7 +305,7 @@ void Preferences::RegisterUserPrefs(PrefRegistrySyncable* registry) {
360000, 360000,
PrefRegistrySyncable::UNSYNCABLE_PREF); PrefRegistrySyncable::UNSYNCABLE_PREF);
registry->RegisterIntegerPref(prefs::kPowerBatteryScreenLockDelayMs, registry->RegisterIntegerPref(prefs::kPowerBatteryScreenLockDelayMs,
600000, 0,
PrefRegistrySyncable::UNSYNCABLE_PREF); PrefRegistrySyncable::UNSYNCABLE_PREF);
registry->RegisterIntegerPref(prefs::kPowerBatteryIdleWarningDelayMs, registry->RegisterIntegerPref(prefs::kPowerBatteryIdleWarningDelayMs,
0, 0,
...@@ -321,10 +314,10 @@ void Preferences::RegisterUserPrefs(PrefRegistrySyncable* registry) { ...@@ -321,10 +314,10 @@ void Preferences::RegisterUserPrefs(PrefRegistrySyncable* registry) {
600000, 600000,
PrefRegistrySyncable::UNSYNCABLE_PREF); PrefRegistrySyncable::UNSYNCABLE_PREF);
registry->RegisterIntegerPref(prefs::kPowerIdleAction, registry->RegisterIntegerPref(prefs::kPowerIdleAction,
chromeos::PowerPolicyController::ACTION_SUSPEND, PowerPolicyController::ACTION_SUSPEND,
PrefRegistrySyncable::UNSYNCABLE_PREF); PrefRegistrySyncable::UNSYNCABLE_PREF);
registry->RegisterIntegerPref(prefs::kPowerLidClosedAction, registry->RegisterIntegerPref(prefs::kPowerLidClosedAction,
chromeos::PowerPolicyController::ACTION_SUSPEND, PowerPolicyController::ACTION_SUSPEND,
PrefRegistrySyncable::UNSYNCABLE_PREF); PrefRegistrySyncable::UNSYNCABLE_PREF);
registry->RegisterBooleanPref(prefs::kPowerUseAudioActivity, registry->RegisterBooleanPref(prefs::kPowerUseAudioActivity,
true, true,
...@@ -789,23 +782,35 @@ void Preferences::NotifyPrefChanged(const std::string* pref_name) { ...@@ -789,23 +782,35 @@ void Preferences::NotifyPrefChanged(const std::string* pref_name) {
*pref_name == prefs::kPowerLidClosedAction || *pref_name == prefs::kPowerLidClosedAction ||
*pref_name == prefs::kPowerUseAudioActivity || *pref_name == prefs::kPowerUseAudioActivity ||
*pref_name == prefs::kPowerUseVideoActivity || *pref_name == prefs::kPowerUseVideoActivity ||
*pref_name == prefs::kPowerPresentationIdleDelayFactor) { *pref_name == prefs::kPowerPresentationIdleDelayFactor ||
DBusThreadManager::Get()->GetPowerPolicyController()->UpdatePolicyFromPrefs( *pref_name == prefs::kEnableScreenLock) {
*prefs_->FindPreference(prefs::kPowerAcScreenDimDelayMs), PowerPolicyController::PrefValues values;
*prefs_->FindPreference(prefs::kPowerAcScreenOffDelayMs), values.ac_screen_dim_delay_ms = power_ac_screen_dim_delay_ms_.GetValue();
*prefs_->FindPreference(prefs::kPowerAcScreenLockDelayMs), values.ac_screen_off_delay_ms = power_ac_screen_off_delay_ms_.GetValue();
*prefs_->FindPreference(prefs::kPowerAcIdleWarningDelayMs), values.ac_screen_lock_delay_ms = power_ac_screen_lock_delay_ms_.GetValue();
*prefs_->FindPreference(prefs::kPowerAcIdleDelayMs), values.ac_idle_warning_delay_ms =
*prefs_->FindPreference(prefs::kPowerBatteryScreenDimDelayMs), power_ac_idle_warning_delay_ms_.GetValue();
*prefs_->FindPreference(prefs::kPowerBatteryScreenOffDelayMs), values.ac_idle_delay_ms = power_ac_idle_delay_ms_.GetValue();
*prefs_->FindPreference(prefs::kPowerBatteryScreenLockDelayMs), values.battery_screen_dim_delay_ms =
*prefs_->FindPreference(prefs::kPowerBatteryIdleWarningDelayMs), power_battery_screen_dim_delay_ms_.GetValue();
*prefs_->FindPreference(prefs::kPowerBatteryIdleDelayMs), values.battery_screen_off_delay_ms =
*prefs_->FindPreference(prefs::kPowerIdleAction), power_battery_screen_off_delay_ms_.GetValue();
*prefs_->FindPreference(prefs::kPowerLidClosedAction), values.battery_screen_lock_delay_ms =
*prefs_->FindPreference(prefs::kPowerUseAudioActivity), power_battery_screen_lock_delay_ms_.GetValue();
*prefs_->FindPreference(prefs::kPowerUseVideoActivity), values.battery_idle_warning_delay_ms =
*prefs_->FindPreference(prefs::kPowerPresentationIdleDelayFactor)); 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
...@@ -4,72 +4,39 @@ ...@@ -4,72 +4,39 @@
#include "chromeos/dbus/power_policy_controller.h" #include "chromeos/dbus/power_policy_controller.h"
#include "base/format_macros.h"
#include "base/logging.h" #include "base/logging.h"
#include "base/values.h" #include "base/string_util.h"
#include "base/stringprintf.h"
#include "chromeos/dbus/dbus_thread_manager.h" #include "chromeos/dbus/dbus_thread_manager.h"
namespace chromeos { namespace chromeos {
namespace { namespace {
// If |pref|, a PrefService::Preference containing an integer, has been // Appends a description of |field|, a field within |delays|, a
// explicitly set to 0 or a positive value, assigns it to |proto_field|, a // power_manager::PowerManagementPolicy::Delays object, to |str|, an
// int32 field in |proto|, a google::protobuf::MessageLite*. If |proto| // std::string, if the field is set. |name| is a char* describing the
// was updated, |got_prefs|, a bool*, is set to true; otherwise it is left // field.
// unchanged. #define APPEND_DELAY(str, delays, field, name) \
#define SET_DELAY_FROM_PREF(pref, proto_field, proto, got_prefs) \
{ \ { \
int value = GetIntPrefValue(pref); \ if (delays.has_##field()) \
if (value >= 0) { \ str += base::StringPrintf(name "=%" PRId64 " ", delays.field()); \
(proto)->set_##proto_field(value); \
*got_prefs = true; \
} \
} }
// Similar to SET_DELAY_FROM_PREF() but sets a // Appends descriptions of all of the set delays in |delays|, a
// power_manager::PowerManagementPolicy_Action field instead. // power_manager::PowerManagementPolicy::Delays object, to |str|, an
#define SET_ACTION_FROM_PREF(pref, proto_field, proto, got_prefs) \ // std::string. |prefix| should be a char* containing either "ac" or
// "battery".
#define APPEND_DELAYS(str, delays, prefix) \
{ \ { \
int value = GetIntPrefValue(pref); \ APPEND_DELAY(str, delays, screen_dim_ms, prefix "_screen_dim_ms"); \
if (value >= 0) { \ APPEND_DELAY(str, delays, screen_off_ms, prefix "_screen_off_ms"); \
(proto)->set_##proto_field( \ APPEND_DELAY(str, delays, screen_lock_ms, prefix "_screen_lock_ms"); \
static_cast<power_manager::PowerManagementPolicy_Action>(value)); \ APPEND_DELAY(str, delays, idle_warning_ms, prefix "_idle_warning_ms"); \
*got_prefs = true; \ APPEND_DELAY(str, delays, idle_ms, prefix "_idle_ms"); \
} \
} }
// If |pref|, a PrefService::Preference containing a bool, has been set,
// assigns it to |proto_field|, a bool field in |proto|, a
// google::protobuf::MessageLite*. If |proto| was updated, |got_prefs|, a
// bool*, is set to true; otherwise it is left unchanged.
#define SET_BOOL_FROM_PREF(pref, proto_field, proto, got_prefs) \
if (!pref.IsDefaultValue()) { \
bool value = false; \
if (pref.GetValue()->GetAsBoolean(&value)) { \
(proto)->set_##proto_field(value); \
*got_prefs = true; \
} else { \
LOG(DFATAL) << pref.name() << " pref has non-boolean value"; \
} \
}
// Returns a zero or positive integer value from |pref|. Returns -1 if the
// pref is unset and logs an error if it's set to a negative value.
int GetIntPrefValue(const PrefService::Preference& pref) {
if (pref.IsDefaultValue())
return -1;
int value = -1;
if (!pref.GetValue()->GetAsInteger(&value)) {
LOG(DFATAL) << pref.name() << " pref has non-integer value";
return -1;
}
if (value < 0)
LOG(WARNING) << pref.name() << " pref has negative value";
return value;
}
// Returns the power_manager::PowerManagementPolicy_Action value // Returns the power_manager::PowerManagementPolicy_Action value
// corresponding to |action|. // corresponding to |action|.
power_manager::PowerManagementPolicy_Action GetProtoAction( power_manager::PowerManagementPolicy_Action GetProtoAction(
...@@ -91,6 +58,55 @@ power_manager::PowerManagementPolicy_Action GetProtoAction( ...@@ -91,6 +58,55 @@ power_manager::PowerManagementPolicy_Action GetProtoAction(
} // namespace } // namespace
// -1 is interpreted as "unset" by powerd, resulting in powerd's default
// delays being used instead. There are no similarly-interpreted values
// for the other fields, unfortunately (but the constructor-assigned values
// will only reach powerd if Chrome messes up and forgets to override them
// with the pref-assigned values).
PowerPolicyController::PrefValues::PrefValues()
: ac_screen_dim_delay_ms(-1),
ac_screen_off_delay_ms(-1),
ac_screen_lock_delay_ms(-1),
ac_idle_warning_delay_ms(-1),
ac_idle_delay_ms(-1),
battery_screen_dim_delay_ms(-1),
battery_screen_off_delay_ms(-1),
battery_screen_lock_delay_ms(-1),
battery_idle_warning_delay_ms(-1),
battery_idle_delay_ms(-1),
idle_action(ACTION_SUSPEND),
lid_closed_action(ACTION_SUSPEND),
use_audio_activity(true),
use_video_activity(true),
enable_screen_lock(false),
presentation_idle_delay_factor(2.0) {}
// static
std::string PowerPolicyController::GetPolicyDebugString(
const power_manager::PowerManagementPolicy& policy) {
std::string str;
if (policy.has_ac_delays())
APPEND_DELAYS(str, policy.ac_delays(), "ac");
if (policy.has_battery_delays())
APPEND_DELAYS(str, policy.battery_delays(), "battery");
if (policy.has_idle_action())
str += base::StringPrintf("idle=%d ", policy.idle_action());
if (policy.has_lid_closed_action())
str += base::StringPrintf("lid_closed=%d ", policy.lid_closed_action());
if (policy.has_use_audio_activity())
str += base::StringPrintf("use_audio=%d ", policy.use_audio_activity());
if (policy.has_use_video_activity())
str += base::StringPrintf("use_video=%d ", policy.use_audio_activity());
if (policy.has_presentation_idle_delay_factor()) {
str += base::StringPrintf("presentation_idle_delay_factor=%f ",
policy.presentation_idle_delay_factor());
}
if (policy.has_reason())
str += base::StringPrintf("reason=\"%s\" ", policy.reason().c_str());
TrimWhitespace(str, TRIM_TRAILING, &str);
return str;
}
PowerPolicyController::PowerPolicyController(DBusThreadManager* manager, PowerPolicyController::PowerPolicyController(DBusThreadManager* manager,
PowerManagerClient* client) PowerManagerClient* client)
: manager_(manager), : manager_(manager),
...@@ -99,7 +115,7 @@ PowerPolicyController::PowerPolicyController(DBusThreadManager* manager, ...@@ -99,7 +115,7 @@ PowerPolicyController::PowerPolicyController(DBusThreadManager* manager,
next_block_id_(1) { next_block_id_(1) {
manager_->AddObserver(this); manager_->AddObserver(this);
client_->AddObserver(this); client_->AddObserver(this);
SendEmptyPolicy(); SendCurrentPolicy();
} }
PowerPolicyController::~PowerPolicyController() { PowerPolicyController::~PowerPolicyController() {
...@@ -113,70 +129,45 @@ PowerPolicyController::~PowerPolicyController() { ...@@ -113,70 +129,45 @@ PowerPolicyController::~PowerPolicyController() {
manager_ = NULL; manager_ = NULL;
} }
void PowerPolicyController::UpdatePolicyFromPrefs( void PowerPolicyController::ApplyPrefs(const PrefValues& values) {
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) {
prefs_policy_.Clear(); prefs_policy_.Clear();
bool got_prefs = false;
power_manager::PowerManagementPolicy::Delays* delays = power_manager::PowerManagementPolicy::Delays* delays =
prefs_policy_.mutable_ac_delays(); prefs_policy_.mutable_ac_delays();
SET_DELAY_FROM_PREF( delays->set_screen_dim_ms(values.ac_screen_dim_delay_ms);
ac_screen_dim_delay_ms_pref, screen_dim_ms, delays, &got_prefs); delays->set_screen_off_ms(values.ac_screen_off_delay_ms);
SET_DELAY_FROM_PREF( delays->set_screen_lock_ms(values.ac_screen_lock_delay_ms);
ac_screen_off_delay_ms_pref, screen_off_ms, delays, &got_prefs); delays->set_idle_warning_ms(values.ac_idle_warning_delay_ms);
SET_DELAY_FROM_PREF( delays->set_idle_ms(values.ac_idle_delay_ms);
ac_screen_lock_delay_ms_pref, screen_lock_ms, delays, &got_prefs);
SET_DELAY_FROM_PREF( // If screen-locking is enabled, ensure that the screen is locked when
ac_idle_warning_delay_ms_pref, idle_warning_ms, delays, &got_prefs); // it's turned off due to user inactivity.
SET_DELAY_FROM_PREF(ac_idle_delay_ms_pref, idle_ms, delays, &got_prefs); if (values.enable_screen_lock && delays->screen_off_ms() > 0 &&
(delays->screen_lock_ms() <= 0 ||
delays->screen_off_ms() < delays->screen_lock_ms())) {
delays->set_screen_lock_ms(delays->screen_off_ms());
}
delays = prefs_policy_.mutable_battery_delays(); delays = prefs_policy_.mutable_battery_delays();
SET_DELAY_FROM_PREF( delays->set_screen_dim_ms(values.battery_screen_dim_delay_ms);
battery_screen_dim_delay_ms_pref, screen_dim_ms, delays, &got_prefs); delays->set_screen_off_ms(values.battery_screen_off_delay_ms);
SET_DELAY_FROM_PREF( delays->set_screen_lock_ms(values.battery_screen_lock_delay_ms);
battery_screen_off_delay_ms_pref, screen_off_ms, delays, &got_prefs); delays->set_idle_warning_ms(values.battery_idle_warning_delay_ms);
SET_DELAY_FROM_PREF( delays->set_idle_ms(values.battery_idle_delay_ms);
battery_screen_lock_delay_ms_pref, screen_lock_ms, delays, &got_prefs); if (values.enable_screen_lock && delays->screen_off_ms() > 0 &&
SET_DELAY_FROM_PREF( (delays->screen_lock_ms() <= 0 ||
battery_idle_warning_delay_ms_pref, idle_warning_ms, delays, &got_prefs); delays->screen_off_ms() < delays->screen_lock_ms())) {
SET_DELAY_FROM_PREF(battery_idle_delay_ms_pref, idle_ms, delays, &got_prefs); delays->set_screen_lock_ms(delays->screen_off_ms());
SET_ACTION_FROM_PREF(
idle_action_pref, idle_action, &prefs_policy_, &got_prefs);
SET_ACTION_FROM_PREF(
lid_closed_action_pref, lid_closed_action, &prefs_policy_, &got_prefs);
SET_BOOL_FROM_PREF(
use_audio_activity_pref, use_audio_activity, &prefs_policy_, &got_prefs);
SET_BOOL_FROM_PREF(
use_video_activity_pref, use_video_activity, &prefs_policy_, &got_prefs);
if (!presentation_idle_delay_factor_pref.IsDefaultValue()) {
double value = 0.0;
if (presentation_idle_delay_factor_pref.GetValue()->GetAsDouble(&value)) {
prefs_policy_.set_presentation_idle_delay_factor(value);
got_prefs = true;
} else {
LOG(DFATAL) << presentation_idle_delay_factor_pref.name()
<< " pref has non-double value";
}
} }
prefs_were_set_ = got_prefs; prefs_policy_.set_idle_action(GetProtoAction(values.idle_action));
prefs_policy_.set_lid_closed_action(GetProtoAction(values.lid_closed_action));
prefs_policy_.set_use_audio_activity(values.use_audio_activity);
prefs_policy_.set_use_video_activity(values.use_video_activity);
prefs_policy_.set_presentation_idle_delay_factor(
values.presentation_idle_delay_factor);
prefs_were_set_ = true;
SendCurrentPolicy(); SendCurrentPolicy();
} }
......
chromeos/dbus/power_policy_controller.h
View file @ ac7fe1b3
...@@ -10,7 +10,6 @@ ...@@ -10,7 +10,6 @@
#include "base/basictypes.h" #include "base/basictypes.h"
#include "base/compiler_specific.h" #include "base/compiler_specific.h"
#include "base/prefs/pref_service.h"
#include "chromeos/chromeos_export.h" #include "chromeos/chromeos_export.h"
#include "chromeos/dbus/dbus_thread_manager_observer.h" #include "chromeos/dbus/dbus_thread_manager_observer.h"
#include "chromeos/dbus/power_manager/policy.pb.h" #include "chromeos/dbus/power_manager/policy.pb.h"
...@@ -34,37 +33,47 @@ class CHROMEOS_EXPORT PowerPolicyController ...@@ -34,37 +33,47 @@ class CHROMEOS_EXPORT PowerPolicyController
ACTION_DO_NOTHING = 3, 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); PowerPolicyController(DBusThreadManager* manager, PowerManagerClient* client);
virtual ~PowerPolicyController(); virtual ~PowerPolicyController();
// Sends an updated policy to the power manager based on the current // Updates |prefs_policy_| with |values| and sends an updated policy.
// values of the passed-in prefs. void ApplyPrefs(const PrefValues& values);
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);
// Registers a request to temporarily prevent the screen from getting // Registers a request to temporarily prevent the screen from getting
// dimmed or turned off or the system from suspending in response to user // dimmed or turned off or the system from suspending in response to user
// inactivity. Returns a unique ID that can be passed to RemoveBlock() // inactivity and sends an updated policy. Returns a unique ID that can
// later. // be passed to RemoveBlock() later.
int AddScreenBlock(const std::string& reason); int AddScreenBlock(const std::string& reason);
int AddSuspendBlock(const std::string& reason); int AddSuspendBlock(const std::string& reason);
// Unregisters a request previously created via AddScreenBlock() or // Unregisters a request previously created via AddScreenBlock() or
// AddSuspendBlock(). // AddSuspendBlock() and sends an updated policy.
void RemoveBlock(int id); void RemoveBlock(int id);
// DBusThreadManagerObserver implementation: // DBusThreadManagerObserver implementation:
...@@ -86,11 +95,10 @@ class CHROMEOS_EXPORT PowerPolicyController ...@@ -86,11 +95,10 @@ class CHROMEOS_EXPORT PowerPolicyController
DBusThreadManager* manager_; // not owned DBusThreadManager* manager_; // not owned
PowerManagerClient* client_; // not owned PowerManagerClient* client_; // not owned
// Policy specified by the prefs that were last passed to // Policy derived from values passed to ApplyPrefs().
// UpdatePolicyFromPrefs().
power_manager::PowerManagementPolicy prefs_policy_; power_manager::PowerManagementPolicy prefs_policy_;
// Are one or more fields set in |prefs_policy_|? // Was ApplyPrefs() called?
bool prefs_were_set_; bool prefs_were_set_;
// Maps from an ID representing a request to prevent the screen from // 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 { ...@@ -26,12 +26,7 @@ class PowerPolicyControllerTest : public testing::Test {
power_client_ = dbus_manager_->mock_power_manager_client(); power_client_ = dbus_manager_->mock_power_manager_client();
EXPECT_CALL(*power_client_, SetPolicy(_)) EXPECT_CALL(*power_client_, SetPolicy(_))
.WillRepeatedly(SaveArg<0>(&last_policy_)); .WillRepeatedly(SaveArg<0>(&last_policy_));
policy_controller_ = dbus_manager_->GetPowerPolicyController(); 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 { virtual void TearDown() OVERRIDE {
...@@ -46,6 +41,76 @@ class PowerPolicyControllerTest : public testing::Test { ...@@ -46,6 +41,76 @@ class PowerPolicyControllerTest : public testing::Test {
power_manager::PowerManagementPolicy last_policy_; 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) { TEST_F(PowerPolicyControllerTest, Blocks) {
const char kSuspendBlockReason[] = "suspend"; const char kSuspendBlockReason[] = "suspend";
const int suspend_id = const int suspend_id =
...@@ -54,8 +119,8 @@ TEST_F(PowerPolicyControllerTest, Blocks) { ...@@ -54,8 +119,8 @@ TEST_F(PowerPolicyControllerTest, Blocks) {
expected_policy.set_idle_action( expected_policy.set_idle_action(
power_manager::PowerManagementPolicy_Action_DO_NOTHING); power_manager::PowerManagementPolicy_Action_DO_NOTHING);
expected_policy.set_reason(kSuspendBlockReason); expected_policy.set_reason(kSuspendBlockReason);
EXPECT_EQ(expected_policy.SerializeAsString(), EXPECT_EQ(PowerPolicyController::GetPolicyDebugString(expected_policy),
last_policy_.SerializeAsString()); PowerPolicyController::GetPolicyDebugString(last_policy_));
const char kScreenBlockReason[] = "screen"; const char kScreenBlockReason[] = "screen";
const int screen_id = policy_controller_->AddScreenBlock(kScreenBlockReason); const int screen_id = policy_controller_->AddScreenBlock(kScreenBlockReason);
...@@ -65,18 +130,18 @@ TEST_F(PowerPolicyControllerTest, Blocks) { ...@@ -65,18 +130,18 @@ TEST_F(PowerPolicyControllerTest, Blocks) {
expected_policy.mutable_battery_delays()->set_screen_off_ms(0); expected_policy.mutable_battery_delays()->set_screen_off_ms(0);
expected_policy.set_reason( expected_policy.set_reason(
std::string(kScreenBlockReason) + ", " + kSuspendBlockReason); std::string(kScreenBlockReason) + ", " + kSuspendBlockReason);
EXPECT_EQ(expected_policy.SerializeAsString(), EXPECT_EQ(PowerPolicyController::GetPolicyDebugString(expected_policy),
last_policy_.SerializeAsString()); PowerPolicyController::GetPolicyDebugString(last_policy_));
policy_controller_->RemoveBlock(suspend_id); policy_controller_->RemoveBlock(suspend_id);
expected_policy.set_reason(kScreenBlockReason); expected_policy.set_reason(kScreenBlockReason);
EXPECT_EQ(expected_policy.SerializeAsString(), EXPECT_EQ(PowerPolicyController::GetPolicyDebugString(expected_policy),
last_policy_.SerializeAsString()); PowerPolicyController::GetPolicyDebugString(last_policy_));
policy_controller_->RemoveBlock(screen_id); policy_controller_->RemoveBlock(screen_id);
expected_policy.Clear(); expected_policy.Clear();
EXPECT_EQ(expected_policy.SerializeAsString(), EXPECT_EQ(PowerPolicyController::GetPolicyDebugString(expected_policy),
last_policy_.SerializeAsString()); PowerPolicyController::GetPolicyDebugString(last_policy_));
} }
} // namespace chromeos } // 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