power_prefs_unittest.cc 26 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665
  1. // Copyright 2013 The Chromium Authors. All rights reserved.
  2. // Use of this source code is governed by a BSD-style license that can be
  3. // found in the LICENSE file.
  4. #include "ash/system/power/power_prefs.h"
  5. #include <memory>
  6. #include <string>
  7. #include <utility>
  8. #include <vector>
  9. #include "ash/constants/ash_pref_names.h"
  10. #include "ash/constants/ash_switches.h"
  11. #include "ash/public/cpp/test/shell_test_api.h"
  12. #include "ash/session/session_controller_impl.h"
  13. #include "ash/session/test_session_controller_client.h"
  14. #include "ash/shell.h"
  15. #include "ash/system/human_presence/human_presence_metrics.h"
  16. #include "ash/test/ash_test_base.h"
  17. #include "base/callback_helpers.h"
  18. #include "base/command_line.h"
  19. #include "base/json/json_reader.h"
  20. #include "base/test/metrics/histogram_tester.h"
  21. #include "base/test/scoped_command_line.h"
  22. #include "base/test/scoped_feature_list.h"
  23. #include "base/test/simple_test_tick_clock.h"
  24. #include "chromeos/ash/components/dbus/human_presence/fake_human_presence_dbus_client.h"
  25. #include "chromeos/ash/components/human_presence/human_presence_configuration.h"
  26. #include "chromeos/dbus/power/fake_power_manager_client.h"
  27. #include "chromeos/dbus/power/power_policy_controller.h"
  28. #include "chromeos/dbus/power_manager/idle.pb.h"
  29. #include "chromeos/dbus/power_manager/policy.pb.h"
  30. #include "components/prefs/pref_notifier_impl.h"
  31. #include "components/prefs/pref_registry_simple.h"
  32. #include "components/prefs/pref_service.h"
  33. #include "components/prefs/testing_pref_service.h"
  34. #include "components/prefs/testing_pref_store.h"
  35. using session_manager::SessionState;
  36. namespace qd_metrics = ash::quick_dim_metrics;
  37. namespace ash {
  38. namespace {
  39. // Screen lock state that determines which delays are used by
  40. // GetExpectedPowerPolicyForPrefs().
  41. enum class ScreenLockState {
  42. LOCKED,
  43. UNLOCKED,
  44. };
  45. PrefService* GetSigninScreenPrefService() {
  46. return Shell::Get()->session_controller()->GetSigninScreenPrefService();
  47. }
  48. // Returns prefs for the user identified by |user_email|, or null if the user's
  49. // prefs are unavailable (e.g. because they don't exist).
  50. PrefService* GetUserPrefService(const std::string& user_email) {
  51. return Shell::Get()->session_controller()->GetUserPrefServiceForUser(
  52. AccountId::FromUserEmail(user_email));
  53. }
  54. std::string GetExpectedPowerPolicyForPrefs(PrefService* prefs,
  55. ScreenLockState screen_lock_state) {
  56. const bool is_smart_dim_enabled =
  57. prefs->GetBoolean(prefs::kPowerSmartDimEnabled);
  58. power_manager::PowerManagementPolicy expected_policy;
  59. expected_policy.mutable_ac_delays()->set_screen_dim_ms(
  60. prefs->GetInteger(screen_lock_state == ScreenLockState::LOCKED
  61. ? prefs::kPowerLockScreenDimDelayMs
  62. : prefs::kPowerAcScreenDimDelayMs));
  63. expected_policy.mutable_ac_delays()->set_screen_off_ms(
  64. prefs->GetInteger(screen_lock_state == ScreenLockState::LOCKED
  65. ? prefs::kPowerLockScreenOffDelayMs
  66. : prefs::kPowerAcScreenOffDelayMs));
  67. expected_policy.mutable_ac_delays()->set_screen_lock_ms(
  68. prefs->GetInteger(prefs::kPowerAcScreenLockDelayMs));
  69. expected_policy.mutable_ac_delays()->set_idle_warning_ms(
  70. prefs->GetInteger(prefs::kPowerAcIdleWarningDelayMs));
  71. expected_policy.mutable_ac_delays()->set_idle_ms(
  72. prefs->GetInteger(prefs::kPowerAcIdleDelayMs));
  73. expected_policy.mutable_battery_delays()->set_screen_dim_ms(
  74. prefs->GetInteger(screen_lock_state == ScreenLockState::LOCKED
  75. ? prefs::kPowerLockScreenDimDelayMs
  76. : prefs::kPowerBatteryScreenDimDelayMs));
  77. expected_policy.mutable_battery_delays()->set_screen_off_ms(
  78. prefs->GetInteger(screen_lock_state == ScreenLockState::LOCKED
  79. ? prefs::kPowerLockScreenOffDelayMs
  80. : prefs::kPowerBatteryScreenOffDelayMs));
  81. expected_policy.mutable_battery_delays()->set_screen_lock_ms(
  82. prefs->GetInteger(prefs::kPowerBatteryScreenLockDelayMs));
  83. expected_policy.mutable_battery_delays()->set_idle_warning_ms(
  84. prefs->GetInteger(prefs::kPowerBatteryIdleWarningDelayMs));
  85. expected_policy.mutable_battery_delays()->set_idle_ms(
  86. prefs->GetInteger(prefs::kPowerBatteryIdleDelayMs));
  87. expected_policy.set_ac_idle_action(
  88. static_cast<power_manager::PowerManagementPolicy_Action>(
  89. prefs->GetInteger(prefs::kPowerAcIdleAction)));
  90. expected_policy.set_battery_idle_action(
  91. static_cast<power_manager::PowerManagementPolicy_Action>(
  92. prefs->GetInteger(prefs::kPowerBatteryIdleAction)));
  93. expected_policy.set_lid_closed_action(
  94. static_cast<power_manager::PowerManagementPolicy_Action>(
  95. prefs->GetInteger(prefs::kPowerLidClosedAction)));
  96. expected_policy.set_use_audio_activity(
  97. prefs->GetBoolean(prefs::kPowerUseAudioActivity));
  98. expected_policy.set_use_video_activity(
  99. prefs->GetBoolean(prefs::kPowerUseVideoActivity));
  100. if (is_smart_dim_enabled) {
  101. // Screen-dim scaling factors are disabled by PowerPolicyController when
  102. // smart-dimming is enabled.
  103. expected_policy.set_presentation_screen_dim_delay_factor(1.0);
  104. expected_policy.set_user_activity_screen_dim_delay_factor(1.0);
  105. } else {
  106. expected_policy.set_presentation_screen_dim_delay_factor(
  107. prefs->GetDouble(prefs::kPowerPresentationScreenDimDelayFactor));
  108. expected_policy.set_user_activity_screen_dim_delay_factor(
  109. prefs->GetDouble(prefs::kPowerUserActivityScreenDimDelayFactor));
  110. }
  111. expected_policy.set_wait_for_initial_user_activity(
  112. prefs->GetBoolean(prefs::kPowerWaitForInitialUserActivity));
  113. expected_policy.set_force_nonzero_brightness_for_user_activity(
  114. prefs->GetBoolean(prefs::kPowerForceNonzeroBrightnessForUserActivity));
  115. // Device-level prefs do not exist in the user-level |prefs|.
  116. expected_policy.mutable_battery_charge_mode()->set_mode(
  117. power_manager::PowerManagementPolicy::BatteryChargeMode::ADAPTIVE);
  118. expected_policy.set_boot_on_ac(false);
  119. expected_policy.set_usb_power_share(true);
  120. expected_policy.set_reason("Prefs");
  121. return chromeos::PowerPolicyController::GetPolicyDebugString(expected_policy);
  122. }
  123. bool GetExpectedAllowScreenWakeLocksForPrefs(PrefService* prefs) {
  124. return prefs->GetBoolean(prefs::kPowerAllowScreenWakeLocks);
  125. }
  126. std::string GetExpectedPeakShiftPolicyForPrefs(PrefService* prefs) {
  127. DCHECK(prefs);
  128. std::vector<power_manager::PowerManagementPolicy::PeakShiftDayConfig> configs;
  129. EXPECT_TRUE(chromeos::PowerPolicyController::GetPeakShiftDayConfigs(
  130. prefs->GetValueDict(prefs::kPowerPeakShiftDayConfig), &configs));
  131. power_manager::PowerManagementPolicy expected_policy;
  132. expected_policy.set_peak_shift_battery_percent_threshold(
  133. prefs->GetInteger(prefs::kPowerPeakShiftBatteryThreshold));
  134. *expected_policy.mutable_peak_shift_day_configs() = {configs.begin(),
  135. configs.end()};
  136. return chromeos::PowerPolicyController::GetPeakShiftPolicyDebugString(
  137. expected_policy);
  138. }
  139. std::string GetExpectedAdvancedBatteryChargeModePolicyForPrefs(
  140. PrefService* prefs) {
  141. DCHECK(prefs);
  142. std::vector<
  143. power_manager::PowerManagementPolicy::AdvancedBatteryChargeModeDayConfig>
  144. configs;
  145. EXPECT_TRUE(
  146. chromeos::PowerPolicyController::GetAdvancedBatteryChargeModeDayConfigs(
  147. prefs->GetValueDict(prefs::kAdvancedBatteryChargeModeDayConfig),
  148. &configs));
  149. power_manager::PowerManagementPolicy expected_policy;
  150. *expected_policy.mutable_advanced_battery_charge_mode_day_configs() = {
  151. configs.begin(), configs.end()};
  152. return chromeos::PowerPolicyController::
  153. GetAdvancedBatteryChargeModePolicyDebugString(expected_policy);
  154. }
  155. void DecodeJsonStringAndNormalize(const std::string& json_string,
  156. base::Value* value) {
  157. auto parsed_json = base::JSONReader::ReadAndReturnValueWithError(
  158. json_string, base::JSON_ALLOW_TRAILING_COMMAS);
  159. ASSERT_TRUE(parsed_json.has_value()) << parsed_json.error().message;
  160. *value = std::move(*parsed_json);
  161. }
  162. void SetQuickDimPreference(bool enabled) {
  163. PrefService* prefs =
  164. Shell::Get()->session_controller()->GetActivePrefService();
  165. if (!prefs)
  166. return;
  167. prefs->SetBoolean(prefs::kPowerQuickDimEnabled, enabled);
  168. }
  169. void SetAdaptiveChargingPreference(bool enabled) {
  170. PrefService* prefs =
  171. Shell::Get()->session_controller()->GetActivePrefService();
  172. if (!prefs)
  173. return;
  174. prefs->SetBoolean(prefs::kPowerAdaptiveChargingEnabled, enabled);
  175. }
  176. } // namespace
  177. class PowerPrefsTest : public NoSessionAshTestBase {
  178. public:
  179. PowerPrefsTest(const PowerPrefsTest&) = delete;
  180. PowerPrefsTest& operator=(const PowerPrefsTest&) = delete;
  181. protected:
  182. PowerPrefsTest() = default;
  183. ~PowerPrefsTest() override = default;
  184. // NoSessionAshTestBase:
  185. void SetUp() override {
  186. feature_list_.InitWithFeatures(
  187. {features::kQuickDim, features::kAdaptiveCharging}, {});
  188. base::CommandLine::ForCurrentProcess()->AppendSwitch(switches::kHasHps);
  189. HumanPresenceDBusClient::InitializeFake();
  190. FakeHumanPresenceDBusClient::Get()->Reset();
  191. FakeHumanPresenceDBusClient::Get()->set_hps_service_is_available(true);
  192. NoSessionAshTestBase::SetUp();
  193. power_policy_controller_ = chromeos::PowerPolicyController::Get();
  194. power_prefs_ = ShellTestApi().power_prefs();
  195. // Advance the clock an arbitrary amount of time so it won't report zero.
  196. tick_clock_.Advance(base::Seconds(1));
  197. power_prefs_->set_tick_clock_for_test(&tick_clock_);
  198. // Get to Login screen.
  199. GetSessionControllerClient()->SetSessionState(SessionState::LOGIN_PRIMARY);
  200. SetUpLocalState();
  201. }
  202. void TearDown() override {
  203. power_prefs_->local_state_ = nullptr;
  204. NoSessionAshTestBase::TearDown();
  205. }
  206. void SetUpLocalState() {
  207. auto pref_notifier = std::make_unique<PrefNotifierImpl>();
  208. auto pref_value_store = std::make_unique<PrefValueStore>(
  209. managed_pref_store_.get() /* managed_prefs */,
  210. nullptr /* supervised_user_prefs */, nullptr /* extension_prefs */,
  211. nullptr /* standalone_browser_prefs */,
  212. nullptr /* command_line_prefs */, user_pref_store_.get(),
  213. nullptr /* recommended_prefs */, pref_registry_->defaults().get(),
  214. pref_notifier.get());
  215. local_state_ = std::make_unique<PrefService>(
  216. std::move(pref_notifier), std::move(pref_value_store), user_pref_store_,
  217. nullptr, pref_registry_, base::DoNothing(), false);
  218. PowerPrefs::RegisterLocalStatePrefs(pref_registry_.get());
  219. power_prefs_->local_state_ = local_state_.get();
  220. power_prefs_->ObserveLocalStatePrefs(power_prefs_->local_state_);
  221. }
  222. std::string GetCurrentPowerPolicy() const {
  223. return chromeos::PowerPolicyController::GetPolicyDebugString(
  224. power_manager_client()->policy());
  225. }
  226. bool GetCurrentAllowScreenWakeLocks() const {
  227. return power_policy_controller_->honor_screen_wake_locks_for_test();
  228. }
  229. std::vector<power_manager::PowerManagementPolicy_Action>
  230. GetCurrentPowerPolicyActions() const {
  231. return {power_manager_client()->policy().ac_idle_action(),
  232. power_manager_client()->policy().battery_idle_action(),
  233. power_manager_client()->policy().lid_closed_action()};
  234. }
  235. void SetLockedState(ScreenLockState lock_state) {
  236. GetSessionControllerClient()->SetSessionState(
  237. lock_state == ScreenLockState::LOCKED ? SessionState::LOCKED
  238. : SessionState::ACTIVE);
  239. }
  240. void NotifyScreenIdleOffChanged(bool off) {
  241. power_manager::ScreenIdleState proto;
  242. proto.set_off(off);
  243. power_manager_client()->SendScreenIdleStateChanged(proto);
  244. }
  245. PrefService* local_state() { return local_state_.get(); }
  246. // Start counting histogram updates before we load our first pref service.
  247. base::HistogramTester histogram_tester_;
  248. chromeos::PowerPolicyController* power_policy_controller_ =
  249. nullptr; // Not owned.
  250. PowerPrefs* power_prefs_ = nullptr; // Not owned.
  251. base::SimpleTestTickClock tick_clock_;
  252. scoped_refptr<TestingPrefStore> user_pref_store_ =
  253. base::MakeRefCounted<TestingPrefStore>();
  254. scoped_refptr<TestingPrefStore> managed_pref_store_ =
  255. base::MakeRefCounted<TestingPrefStore>();
  256. scoped_refptr<PrefRegistrySimple> pref_registry_ =
  257. base::MakeRefCounted<PrefRegistrySimple>();
  258. std::unique_ptr<PrefService> local_state_;
  259. base::test::ScopedFeatureList feature_list_;
  260. base::test::ScopedCommandLine scoped_command_line_;
  261. };
  262. TEST_F(PowerPrefsTest, LoginScreen) {
  263. PrefService* prefs =
  264. Shell::Get()->session_controller()->GetActivePrefService();
  265. EXPECT_EQ(GetSigninScreenPrefService(), prefs);
  266. EXPECT_EQ(GetExpectedPowerPolicyForPrefs(prefs, ScreenLockState::UNLOCKED),
  267. GetCurrentPowerPolicy());
  268. EXPECT_EQ(GetExpectedAllowScreenWakeLocksForPrefs(prefs),
  269. GetCurrentAllowScreenWakeLocks());
  270. // Lock the screen and check that the expected delays are used.
  271. SetLockedState(ScreenLockState::LOCKED);
  272. EXPECT_EQ(GetExpectedPowerPolicyForPrefs(prefs, ScreenLockState::LOCKED),
  273. GetCurrentPowerPolicy());
  274. // Unlock the screen.
  275. SetLockedState(ScreenLockState::UNLOCKED);
  276. EXPECT_EQ(GetExpectedPowerPolicyForPrefs(prefs, ScreenLockState::UNLOCKED),
  277. GetCurrentPowerPolicy());
  278. }
  279. TEST_F(PowerPrefsTest, UserSession) {
  280. const char kUserEmail[] = "user@example.net";
  281. SimulateUserLogin(kUserEmail);
  282. PrefService* prefs = GetUserPrefService(kUserEmail);
  283. ASSERT_TRUE(prefs);
  284. EXPECT_EQ(GetExpectedPowerPolicyForPrefs(prefs, ScreenLockState::UNLOCKED),
  285. GetCurrentPowerPolicy());
  286. EXPECT_EQ(GetExpectedAllowScreenWakeLocksForPrefs(prefs),
  287. GetCurrentAllowScreenWakeLocks());
  288. }
  289. TEST_F(PowerPrefsTest, PrimaryUserPrefs) {
  290. // Add a user with restrictive prefs.
  291. const char kFirstUserEmail[] = "user1@example.net";
  292. SimulateUserLogin(kFirstUserEmail);
  293. PrefService* first_prefs = GetUserPrefService(kFirstUserEmail);
  294. ASSERT_TRUE(first_prefs);
  295. first_prefs->SetBoolean(prefs::kPowerAllowScreenWakeLocks, false);
  296. first_prefs->SetInteger(prefs::kPowerLidClosedAction,
  297. chromeos::PowerPolicyController::ACTION_SHUT_DOWN);
  298. // Add a second user with lenient prefs.
  299. const char kSecondUserEmail[] = "user2@example.net";
  300. SimulateUserLogin(kSecondUserEmail);
  301. PrefService* second_prefs = GetUserPrefService(kSecondUserEmail);
  302. ASSERT_TRUE(second_prefs);
  303. second_prefs->SetBoolean(prefs::kPowerAllowScreenWakeLocks, true);
  304. second_prefs->SetInteger(prefs::kPowerLidClosedAction,
  305. chromeos::PowerPolicyController::ACTION_DO_NOTHING);
  306. // Even though the second user is active, the first (primary) user's prefs
  307. // should still be used.
  308. ASSERT_EQ(second_prefs,
  309. Shell::Get()->session_controller()->GetActivePrefService());
  310. EXPECT_EQ(
  311. GetExpectedPowerPolicyForPrefs(first_prefs, ScreenLockState::UNLOCKED),
  312. GetCurrentPowerPolicy());
  313. }
  314. TEST_F(PowerPrefsTest, AvoidLockDelaysAfterInactivity) {
  315. const char kUserEmail[] = "user@example.net";
  316. SimulateUserLogin(kUserEmail);
  317. PrefService* prefs = GetUserPrefService(kUserEmail);
  318. ASSERT_TRUE(prefs);
  319. EXPECT_EQ(GetExpectedPowerPolicyForPrefs(prefs, ScreenLockState::UNLOCKED),
  320. GetCurrentPowerPolicy());
  321. // If the screen was already off due to inactivity when it was locked, we
  322. // should continue using the unlocked delays.
  323. NotifyScreenIdleOffChanged(true);
  324. tick_clock_.Advance(base::Seconds(5));
  325. SetLockedState(ScreenLockState::LOCKED);
  326. EXPECT_EQ(GetExpectedPowerPolicyForPrefs(prefs, ScreenLockState::UNLOCKED),
  327. GetCurrentPowerPolicy());
  328. // If the screen turns on while still locked, we should switch to the locked
  329. // delays.
  330. tick_clock_.Advance(base::Seconds(5));
  331. NotifyScreenIdleOffChanged(false);
  332. EXPECT_EQ(GetExpectedPowerPolicyForPrefs(prefs, ScreenLockState::LOCKED),
  333. GetCurrentPowerPolicy());
  334. tick_clock_.Advance(base::Seconds(5));
  335. SetLockedState(ScreenLockState::UNLOCKED);
  336. EXPECT_EQ(GetExpectedPowerPolicyForPrefs(prefs, ScreenLockState::UNLOCKED),
  337. GetCurrentPowerPolicy());
  338. }
  339. TEST_F(PowerPrefsTest, DisabledLockScreen) {
  340. const char kUserEmail[] = "user@example.net";
  341. SimulateUserLogin(kUserEmail);
  342. PrefService* prefs = GetUserPrefService(kUserEmail);
  343. ASSERT_TRUE(prefs);
  344. // Verify that the power policy actions are set to default values initially.
  345. EXPECT_EQ(std::vector<power_manager::PowerManagementPolicy_Action>(
  346. 3, power_manager::PowerManagementPolicy_Action_SUSPEND),
  347. GetCurrentPowerPolicyActions());
  348. // The automatic screen locking is enabled, but, as the lock screen is
  349. // allowed, the power policy actions still have the default values.
  350. prefs->SetBoolean(prefs::kEnableAutoScreenLock, true);
  351. EXPECT_EQ(std::vector<power_manager::PowerManagementPolicy_Action>(
  352. 3, power_manager::PowerManagementPolicy_Action_SUSPEND),
  353. GetCurrentPowerPolicyActions());
  354. // The lock screen is disabled, but, as automatic screen locking is not
  355. // enabled, the power policy actions still have the default values.
  356. prefs->ClearPref(prefs::kEnableAutoScreenLock);
  357. prefs->SetBoolean(prefs::kAllowScreenLock, false);
  358. EXPECT_EQ(std::vector<power_manager::PowerManagementPolicy_Action>(
  359. 3, power_manager::PowerManagementPolicy_Action_SUSPEND),
  360. GetCurrentPowerPolicyActions());
  361. // The automatic screen locking is enabled and the lock screen is disabled, so
  362. // the power policy actions are set now to stop the user session.
  363. prefs->SetBoolean(prefs::kEnableAutoScreenLock, true);
  364. EXPECT_EQ(std::vector<power_manager::PowerManagementPolicy_Action>(
  365. 3, power_manager::PowerManagementPolicy_Action_STOP_SESSION),
  366. GetCurrentPowerPolicyActions());
  367. }
  368. TEST_F(PowerPrefsTest, SmartDimEnabled) {
  369. PrefService* prefs =
  370. Shell::Get()->session_controller()->GetActivePrefService();
  371. EXPECT_TRUE(prefs->GetBoolean(prefs::kPowerSmartDimEnabled));
  372. }
  373. TEST_F(PowerPrefsTest, PeakShift) {
  374. constexpr char kDayConfigsJson[] =
  375. R"({
  376. "entries": [
  377. {
  378. "charge_start_time": {
  379. "hour": 20,
  380. "minute": 0
  381. },
  382. "day": "MONDAY",
  383. "end_time": {
  384. "hour": 10,
  385. "minute": 15
  386. },
  387. "start_time": {
  388. "hour": 7,
  389. "minute": 30
  390. }
  391. },
  392. {
  393. "charge_start_time": {
  394. "hour": 22,
  395. "minute": 30
  396. },
  397. "day": "FRIDAY",
  398. "end_time": {
  399. "hour": 9,
  400. "minute": 45
  401. },
  402. "start_time": {
  403. "hour": 4,
  404. "minute": 0
  405. }
  406. }
  407. ]
  408. })";
  409. base::Value day_configs;
  410. DecodeJsonStringAndNormalize(kDayConfigsJson, &day_configs);
  411. managed_pref_store_->SetBoolean(prefs::kPowerPeakShiftEnabled, true);
  412. managed_pref_store_->SetInteger(prefs::kPowerPeakShiftBatteryThreshold, 50);
  413. managed_pref_store_->SetValue(
  414. prefs::kPowerPeakShiftDayConfig,
  415. std::make_unique<base::Value>(std::move(day_configs)), 0);
  416. EXPECT_EQ(chromeos::PowerPolicyController::GetPeakShiftPolicyDebugString(
  417. power_manager_client()->policy()),
  418. GetExpectedPeakShiftPolicyForPrefs(local_state()));
  419. }
  420. TEST_F(PowerPrefsTest, AdvancedBatteryChargeMode) {
  421. constexpr char kDayConfigsJson[] =
  422. R"({
  423. "entries": [
  424. {
  425. "charge_start_time": {
  426. "hour": 15,
  427. "minute": 15
  428. },
  429. "charge_end_time": {
  430. "hour": 21,
  431. "minute": 45
  432. },
  433. "day": "TUESDAY"
  434. },
  435. {
  436. "charge_start_time": {
  437. "hour": 10,
  438. "minute": 30
  439. },
  440. "charge_end_time": {
  441. "hour": 23,
  442. "minute": 0
  443. },
  444. "day": "SUNDAY"
  445. }
  446. ]
  447. })";
  448. base::Value day_configs;
  449. DecodeJsonStringAndNormalize(kDayConfigsJson, &day_configs);
  450. managed_pref_store_->SetBoolean(prefs::kAdvancedBatteryChargeModeEnabled,
  451. true);
  452. managed_pref_store_->SetValue(
  453. prefs::kAdvancedBatteryChargeModeDayConfig,
  454. std::make_unique<base::Value>(std::move(day_configs)), 0);
  455. EXPECT_EQ(chromeos::PowerPolicyController::
  456. GetAdvancedBatteryChargeModePolicyDebugString(
  457. power_manager_client()->policy()),
  458. GetExpectedAdvancedBatteryChargeModePolicyForPrefs(local_state()));
  459. }
  460. TEST_F(PowerPrefsTest, BatteryChargeMode) {
  461. const auto& battery_charge_mode =
  462. power_manager_client()->policy().battery_charge_mode();
  463. managed_pref_store_->SetInteger(prefs::kBatteryChargeMode, 2);
  464. EXPECT_EQ(
  465. battery_charge_mode.mode(),
  466. power_manager::PowerManagementPolicy::BatteryChargeMode::EXPRESS_CHARGE);
  467. managed_pref_store_->SetInteger(prefs::kBatteryChargeMode, 5);
  468. managed_pref_store_->SetInteger(prefs::kBatteryChargeCustomStartCharging, 55);
  469. managed_pref_store_->SetInteger(prefs::kBatteryChargeCustomStopCharging, 87);
  470. EXPECT_EQ(battery_charge_mode.mode(),
  471. power_manager::PowerManagementPolicy::BatteryChargeMode::CUSTOM);
  472. EXPECT_EQ(battery_charge_mode.custom_charge_start(), 55);
  473. EXPECT_EQ(battery_charge_mode.custom_charge_stop(), 87);
  474. }
  475. TEST_F(PowerPrefsTest, BootOnAc) {
  476. managed_pref_store_->SetBoolean(prefs::kBootOnAcEnabled, true);
  477. EXPECT_TRUE(power_manager_client()->policy().boot_on_ac());
  478. managed_pref_store_->SetBoolean(prefs::kBootOnAcEnabled, false);
  479. EXPECT_FALSE(power_manager_client()->policy().boot_on_ac());
  480. }
  481. TEST_F(PowerPrefsTest, UsbPowerShare) {
  482. managed_pref_store_->SetBoolean(prefs::kUsbPowerShareEnabled, true);
  483. EXPECT_TRUE(power_manager_client()->policy().usb_power_share());
  484. managed_pref_store_->SetBoolean(prefs::kUsbPowerShareEnabled, false);
  485. EXPECT_FALSE(power_manager_client()->policy().usb_power_share());
  486. }
  487. TEST_F(PowerPrefsTest, AlsLoggingEnabled) {
  488. PrefService* prefs =
  489. Shell::Get()->session_controller()->GetActivePrefService();
  490. EXPECT_FALSE(prefs->GetBoolean(prefs::kPowerAlsLoggingEnabled));
  491. }
  492. TEST_F(PowerPrefsTest, SetQuickDimParams) {
  493. // Check that DisableHpsSense is called on initialization.
  494. base::RunLoop().RunUntilIdle();
  495. EXPECT_EQ(FakeHumanPresenceDBusClient::Get()->disable_hps_sense_count(), 1);
  496. EXPECT_EQ(FakeHumanPresenceDBusClient::Get()->enable_hps_sense_count(), 0);
  497. // This will trigger UpdatePowerPolicyFromPrefs and set correct parameters.
  498. SetQuickDimPreference(true);
  499. const auto policy = power_manager_client()->policy();
  500. EXPECT_EQ(policy.ac_delays().quick_dim_ms(),
  501. hps::GetQuickDimDelay().InMilliseconds());
  502. EXPECT_EQ(policy.battery_delays().quick_dim_ms(),
  503. hps::GetQuickDimDelay().InMilliseconds());
  504. EXPECT_EQ(policy.ac_delays().quick_lock_ms(),
  505. hps::GetQuickLockDelay().InMilliseconds());
  506. EXPECT_EQ(policy.battery_delays().quick_lock_ms(),
  507. hps::GetQuickLockDelay().InMilliseconds());
  508. EXPECT_EQ(policy.send_feedback_if_undimmed(),
  509. hps::GetQuickDimFeedbackEnabled());
  510. // EnableHpsSense should be called when kPowerQuickDimEnabled becomes true.
  511. base::RunLoop().RunUntilIdle();
  512. EXPECT_EQ(FakeHumanPresenceDBusClient::Get()->enable_hps_sense_count(), 1);
  513. // DisableHpsSense should be called when kPowerQuickDimEnabled becomes false.
  514. SetQuickDimPreference(false);
  515. base::RunLoop().RunUntilIdle();
  516. EXPECT_EQ(FakeHumanPresenceDBusClient::Get()->disable_hps_sense_count(), 2);
  517. }
  518. TEST_F(PowerPrefsTest, QuickDimMetrics) {
  519. const char kUserEmail[] = "user@example.net";
  520. // Initial pref loading shouldn't be logged as manual pref change.
  521. EXPECT_TRUE(histogram_tester_.GetAllSamples(qd_metrics::kEnabledHistogramName)
  522. .empty());
  523. // Initial pref value is false, so manually updating it to true should be
  524. // logged.
  525. SetQuickDimPreference(true);
  526. const std::vector<base::Bucket> login_screen_buckets = {
  527. base::Bucket(true, 1)};
  528. EXPECT_EQ(histogram_tester_.GetAllSamples(qd_metrics::kEnabledHistogramName),
  529. login_screen_buckets);
  530. // Loading a new pref service isn't a manual update, so shouldn't be logged.
  531. SimulateUserLogin(kUserEmail);
  532. EXPECT_EQ(histogram_tester_.GetAllSamples(qd_metrics::kEnabledHistogramName),
  533. login_screen_buckets);
  534. // We now re-enable the feature, which *is* a manual toggle (because the
  535. // newly-loaded user pref service defaults to having it disabled).
  536. SetQuickDimPreference(true);
  537. // Login screen and user have both enabled the feature.
  538. const std::vector<base::Bucket> user_enable_buckets = {base::Bucket(true, 2)};
  539. EXPECT_EQ(histogram_tester_.GetAllSamples(qd_metrics::kEnabledHistogramName),
  540. user_enable_buckets);
  541. // Manual disable should also be logged.
  542. SetQuickDimPreference(false);
  543. const std::vector<base::Bucket> user_disable_buckets = {
  544. base::Bucket(false, 1), base::Bucket(true, 2)};
  545. EXPECT_EQ(histogram_tester_.GetAllSamples(qd_metrics::kEnabledHistogramName),
  546. user_disable_buckets);
  547. // Redundant pref change shouldn't be logged.
  548. SetQuickDimPreference(false);
  549. EXPECT_EQ(histogram_tester_.GetAllSamples(qd_metrics::kEnabledHistogramName),
  550. user_disable_buckets);
  551. }
  552. TEST_F(PowerPrefsTest, SetAdaptiveChargingParams) {
  553. // Should be enabled by default.
  554. EXPECT_TRUE(power_manager_client()->policy().adaptive_charging_enabled());
  555. // Should be disabled after changing the prefs to false.
  556. SetAdaptiveChargingPreference(false);
  557. EXPECT_FALSE(power_manager_client()->policy().adaptive_charging_enabled());
  558. // Should be enabled after setting the prefs to true.
  559. SetAdaptiveChargingPreference(true);
  560. EXPECT_TRUE(power_manager_client()->policy().adaptive_charging_enabled());
  561. }
  562. } // namespace ash