power_policy_browsertest.cc revision 116680a4aac90f2aa7413d9095a592090648e557 
1// Copyright (c) 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
5#include <string>
6#include <vector>
7
8#include "base/basictypes.h"
9#include "base/bind.h"
10#include "base/callback.h"
11#include "base/command_line.h"
12#include "base/compiler_specific.h"
13#include "base/file_util.h"
14#include "base/files/file_path.h"
15#include "base/location.h"
16#include "base/message_loop/message_loop.h"
17#include "base/path_service.h"
18#include "base/run_loop.h"
19#include "chrome/browser/chrome_notification_types.h"
20#include "chrome/browser/chromeos/policy/device_policy_builder.h"
21#include "chrome/browser/chromeos/policy/device_policy_cros_browser_test.h"
22#include "chrome/browser/chromeos/policy/proto/chrome_device_policy.pb.h"
23#include "chrome/browser/chromeos/policy/user_cloud_policy_manager_chromeos.h"
24#include "chrome/browser/chromeos/policy/user_cloud_policy_manager_factory_chromeos.h"
25#include "chrome/browser/chromeos/profiles/profile_helper.h"
26#include "chrome/browser/lifetime/application_lifetime.h"
27#include "chrome/browser/policy/profile_policy_connector.h"
28#include "chrome/browser/policy/profile_policy_connector_factory.h"
29#include "chrome/browser/profiles/profile.h"
30#include "chrome/browser/profiles/profile_manager.h"
31#include "chrome/browser/ui/browser.h"
32#include "chrome/test/base/testing_profile.h"
33#include "chromeos/chromeos_paths.h"
34#include "chromeos/chromeos_switches.h"
35#include "chromeos/dbus/cryptohome_client.h"
36#include "chromeos/dbus/fake_dbus_thread_manager.h"
37#include "chromeos/dbus/fake_power_manager_client.h"
38#include "chromeos/dbus/fake_session_manager_client.h"
39#include "chromeos/dbus/power_manager/policy.pb.h"
40#include "chromeos/dbus/power_policy_controller.h"
41#include "chromeos/login/user_names.h"
42#include "components/policy/core/common/cloud/cloud_policy_core.h"
43#include "components/policy/core/common/cloud/cloud_policy_store.h"
44#include "components/policy/core/common/cloud/policy_builder.h"
45#include "components/policy/core/common/external_data_fetcher.h"
46#include "components/policy/core/common/mock_policy_service.h"
47#include "components/policy/core/common/policy_service.h"
48#include "content/public/browser/notification_details.h"
49#include "content/public/browser/notification_service.h"
50#include "content/public/browser/notification_source.h"
51#include "content/public/test/test_utils.h"
52#include "extensions/browser/api/power/power_api_manager.h"
53#include "extensions/common/api/power.h"
54#include "policy/proto/device_management_backend.pb.h"
55#include "testing/gmock/include/gmock/gmock.h"
56#include "testing/gtest/include/gtest/gtest.h"
57
58namespace em = enterprise_management;
59namespace pm = power_manager;
60
61using ::testing::AnyNumber;
62using ::testing::InvokeWithoutArgs;
63using ::testing::_;
64
65namespace policy {
66
67namespace {
68
69const char kLoginScreenPowerManagementPolicy[] =
70    "{"
71    "  \"AC\": {"
72    "    \"Delays\": {"
73    "      \"ScreenDim\": 5000,"
74    "      \"ScreenOff\": 7000,"
75    "      \"Idle\": 9000"
76    "    },"
77    "    \"IdleAction\": \"DoNothing\""
78    "  },"
79    "  \"Battery\": {"
80    "    \"Delays\": {"
81    "      \"ScreenDim\": 1000,"
82    "      \"ScreenOff\": 3000,"
83    "      \"Idle\": 4000"
84    "    },"
85    "    \"IdleAction\": \"DoNothing\""
86    "  },"
87    "  \"LidCloseAction\": \"DoNothing\","
88    "  \"UserActivityScreenDimDelayScale\": 300"
89    "}";
90
91const char kPowerManagementIdleSettingsPolicy[] =
92    "{"
93    "  \"AC\": {"
94    "    \"Delays\": {"
95    "      \"ScreenDim\": 5000,"
96    "      \"ScreenOff\": 7000,"
97    "      \"IdleWarning\": 8000,"
98    "      \"Idle\": 9000"
99    "    },"
100    "    \"IdleAction\": \"Logout\""
101    "  },"
102    "  \"Battery\": {"
103    "    \"Delays\": {"
104    "      \"ScreenDim\": 1000,"
105    "      \"ScreenOff\": 3000,"
106    "      \"IdleWarning\": 4000,"
107    "      \"Idle\": 5000"
108    "    },"
109    "    \"IdleAction\": \"Logout\""
110    "  }"
111    "}";
112
113const char kScreenLockDelayPolicy[] =
114    "{"
115    "  \"AC\": 6000,"
116    "  \"Battery\": 2000"
117    "}";
118
119}  // namespace
120
121class PowerPolicyBrowserTestBase : public DevicePolicyCrosBrowserTest {
122 protected:
123  PowerPolicyBrowserTestBase();
124
125  // DevicePolicyCrosBrowserTest:
126  virtual void SetUpInProcessBrowserTestFixture() OVERRIDE;
127  virtual void SetUpOnMainThread() OVERRIDE;
128
129  void InstallUserKey();
130  void StoreAndReloadUserPolicy();
131
132  void StoreAndReloadDevicePolicyAndWaitForLoginProfileChange();
133
134  // Returns a string describing |policy|.
135  std::string GetDebugString(const pm::PowerManagementPolicy& policy);
136
137  UserPolicyBuilder user_policy_;
138
139  chromeos::FakePowerManagerClient* power_manager_client_;
140
141 private:
142  // Runs |closure| and waits for |profile|'s user policy to be updated as a
143  // result.
144  void RunClosureAndWaitForUserPolicyUpdate(const base::Closure& closure,
145                                            Profile* profile);
146
147  // Reloads user policy for |profile| from session manager client.
148  void ReloadUserPolicy(Profile* profile);
149
150  DISALLOW_COPY_AND_ASSIGN(PowerPolicyBrowserTestBase);
151};
152
153class PowerPolicyLoginScreenBrowserTest : public PowerPolicyBrowserTestBase {
154 protected:
155  PowerPolicyLoginScreenBrowserTest();
156
157  // PowerPolicyBrowserTestBase:
158  virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE;
159  virtual void SetUpOnMainThread() OVERRIDE;
160  virtual void CleanUpOnMainThread() OVERRIDE;
161
162  DISALLOW_COPY_AND_ASSIGN(PowerPolicyLoginScreenBrowserTest);
163};
164
165class PowerPolicyInSessionBrowserTest : public PowerPolicyBrowserTestBase {
166 protected:
167  PowerPolicyInSessionBrowserTest();
168
169  // PowerPolicyBrowserTestBase:
170  virtual void SetUpOnMainThread() OVERRIDE;
171
172  DISALLOW_COPY_AND_ASSIGN(PowerPolicyInSessionBrowserTest);
173};
174
175PowerPolicyBrowserTestBase::PowerPolicyBrowserTestBase()
176    : power_manager_client_(NULL) {
177}
178
179void PowerPolicyBrowserTestBase::SetUpInProcessBrowserTestFixture() {
180  power_manager_client_ = new chromeos::FakePowerManagerClient;
181  fake_dbus_thread_manager()->SetPowerManagerClient(
182      scoped_ptr<chromeos::PowerManagerClient>(power_manager_client_));
183
184  DevicePolicyCrosBrowserTest::SetUpInProcessBrowserTestFixture();
185
186  // Initialize device policy.
187  InstallOwnerKey();
188  MarkAsEnterpriseOwned();
189}
190
191void PowerPolicyBrowserTestBase::SetUpOnMainThread() {
192  DevicePolicyCrosBrowserTest::SetUpOnMainThread();
193
194  // Initialize user policy.
195  InstallUserKey();
196  user_policy_.policy_data().set_username(chromeos::login::kStubUser);
197}
198
199void PowerPolicyBrowserTestBase::InstallUserKey() {
200  base::FilePath user_keys_dir;
201  ASSERT_TRUE(PathService::Get(chromeos::DIR_USER_POLICY_KEYS, &user_keys_dir));
202  std::string sanitized_username =
203      chromeos::CryptohomeClient::GetStubSanitizedUsername(
204          chromeos::login::kStubUser);
205  base::FilePath user_key_file =
206      user_keys_dir.AppendASCII(sanitized_username)
207                   .AppendASCII("policy.pub");
208  std::vector<uint8> user_key_bits;
209  ASSERT_TRUE(user_policy_.GetSigningKey()->ExportPublicKey(&user_key_bits));
210  ASSERT_TRUE(base::CreateDirectory(user_key_file.DirName()));
211  ASSERT_EQ(base::WriteFile(
212                user_key_file,
213                reinterpret_cast<const char*>(user_key_bits.data()),
214                user_key_bits.size()),
215            static_cast<int>(user_key_bits.size()));
216}
217
218void PowerPolicyBrowserTestBase::StoreAndReloadUserPolicy() {
219  // Install the new user policy blob in session manager client.
220  user_policy_.Build();
221  session_manager_client()->set_user_policy(
222      user_policy_.policy_data().username(),
223      user_policy_.GetBlob());
224
225  // Reload user policy from session manager client and wait for the update to
226  // take effect.
227  RunClosureAndWaitForUserPolicyUpdate(
228      base::Bind(&PowerPolicyBrowserTestBase::ReloadUserPolicy, this,
229                 browser()->profile()),
230      browser()->profile());
231}
232
233void PowerPolicyBrowserTestBase::
234    StoreAndReloadDevicePolicyAndWaitForLoginProfileChange() {
235  Profile* profile = chromeos::ProfileHelper::GetSigninProfile();
236  ASSERT_TRUE(profile);
237
238  // Install the new device policy blob in session manager client, reload device
239  // policy from session manager client and wait for a change in the login
240  // profile's policy to be observed.
241  RunClosureAndWaitForUserPolicyUpdate(
242      base::Bind(&PowerPolicyBrowserTestBase::RefreshDevicePolicy, this),
243      profile);
244}
245
246std::string PowerPolicyBrowserTestBase::GetDebugString(
247    const pm::PowerManagementPolicy& policy) {
248  return chromeos::PowerPolicyController::GetPolicyDebugString(policy);
249}
250
251void PowerPolicyBrowserTestBase::RunClosureAndWaitForUserPolicyUpdate(
252    const base::Closure& closure,
253    Profile* profile) {
254  base::RunLoop run_loop;
255  MockPolicyServiceObserver observer;
256  EXPECT_CALL(observer, OnPolicyUpdated(_, _, _))
257      .WillOnce(InvokeWithoutArgs(&run_loop, &base::RunLoop::Quit));
258  EXPECT_CALL(observer, OnPolicyServiceInitialized(_)).Times(AnyNumber());
259  PolicyService* policy_service =
260      ProfilePolicyConnectorFactory::GetForProfile(profile)->policy_service();
261  ASSERT_TRUE(policy_service);
262  policy_service->AddObserver(POLICY_DOMAIN_CHROME, &observer);
263  closure.Run();
264  run_loop.Run();
265  policy_service->RemoveObserver(POLICY_DOMAIN_CHROME, &observer);
266}
267
268void PowerPolicyBrowserTestBase::ReloadUserPolicy(Profile* profile) {
269  UserCloudPolicyManagerChromeOS* policy_manager =
270      UserCloudPolicyManagerFactoryChromeOS::GetForProfile(profile);
271  ASSERT_TRUE(policy_manager);
272  policy_manager->core()->store()->Load();
273}
274
275PowerPolicyLoginScreenBrowserTest::PowerPolicyLoginScreenBrowserTest() {
276}
277
278void PowerPolicyLoginScreenBrowserTest::SetUpCommandLine(
279    CommandLine* command_line) {
280  PowerPolicyBrowserTestBase::SetUpCommandLine(command_line);
281  command_line->AppendSwitch(chromeos::switches::kLoginManager);
282  command_line->AppendSwitch(chromeos::switches::kForceLoginManagerInTests);
283}
284
285void PowerPolicyLoginScreenBrowserTest::SetUpOnMainThread() {
286  PowerPolicyBrowserTestBase::SetUpOnMainThread();
287
288  // Wait for the login screen to be shown.
289  content::WindowedNotificationObserver(
290      chrome::NOTIFICATION_LOGIN_OR_LOCK_WEBUI_VISIBLE,
291      content::NotificationService::AllSources()).Wait();
292}
293
294void PowerPolicyLoginScreenBrowserTest::CleanUpOnMainThread() {
295  base::MessageLoop::current()->PostTask(FROM_HERE,
296                                         base::Bind(&chrome::AttemptExit));
297  base::RunLoop().RunUntilIdle();
298  PowerPolicyBrowserTestBase::CleanUpOnMainThread();
299}
300
301PowerPolicyInSessionBrowserTest::PowerPolicyInSessionBrowserTest() {
302}
303
304void PowerPolicyInSessionBrowserTest::SetUpOnMainThread() {
305  PowerPolicyBrowserTestBase::SetUpOnMainThread();
306}
307
308// Verifies that device policy is applied on the login screen.
309IN_PROC_BROWSER_TEST_F(PowerPolicyLoginScreenBrowserTest, SetDevicePolicy) {
310  pm::PowerManagementPolicy power_management_policy =
311      power_manager_client_->policy();
312  power_management_policy.mutable_ac_delays()->set_screen_dim_ms(5000);
313  power_management_policy.mutable_ac_delays()->set_screen_off_ms(7000);
314  power_management_policy.mutable_ac_delays()->set_idle_ms(9000);
315  power_management_policy.mutable_battery_delays()->set_screen_dim_ms(1000);
316  power_management_policy.mutable_battery_delays()->set_screen_off_ms(3000);
317  power_management_policy.mutable_battery_delays()->set_idle_ms(4000);
318  power_management_policy.set_ac_idle_action(
319      pm::PowerManagementPolicy::DO_NOTHING);
320  power_management_policy.set_battery_idle_action(
321      pm::PowerManagementPolicy::DO_NOTHING);
322  power_management_policy.set_lid_closed_action(
323      pm::PowerManagementPolicy::DO_NOTHING);
324  power_management_policy.set_user_activity_screen_dim_delay_factor(3.0);
325
326  em::ChromeDeviceSettingsProto& proto(device_policy()->payload());
327  proto.mutable_login_screen_power_management()->
328      set_login_screen_power_management(kLoginScreenPowerManagementPolicy);
329  StoreAndReloadDevicePolicyAndWaitForLoginProfileChange();
330  EXPECT_EQ(GetDebugString(power_management_policy),
331            GetDebugString(power_manager_client_->policy()));
332}
333
334// Verifies that device policy is ignored during a session.
335IN_PROC_BROWSER_TEST_F(PowerPolicyInSessionBrowserTest, SetDevicePolicy) {
336  pm::PowerManagementPolicy power_management_policy =
337      power_manager_client_->policy();
338
339  em::ChromeDeviceSettingsProto& proto(device_policy()->payload());
340  proto.mutable_login_screen_power_management()->
341      set_login_screen_power_management(kLoginScreenPowerManagementPolicy);
342  StoreAndReloadDevicePolicyAndWaitForLoginProfileChange();
343  EXPECT_EQ(GetDebugString(power_management_policy),
344            GetDebugString(power_manager_client_->policy()));
345}
346
347// Verifies that legacy user policy is applied during a session.
348IN_PROC_BROWSER_TEST_F(PowerPolicyInSessionBrowserTest, SetLegacyUserPolicy) {
349  pm::PowerManagementPolicy power_management_policy =
350      power_manager_client_->policy();
351  power_management_policy.mutable_ac_delays()->set_screen_dim_ms(5000);
352  power_management_policy.mutable_ac_delays()->set_screen_lock_ms(6000);
353  power_management_policy.mutable_ac_delays()->set_screen_off_ms(7000);
354  power_management_policy.mutable_ac_delays()->set_idle_warning_ms(8000);
355  power_management_policy.mutable_ac_delays()->set_idle_ms(9000);
356  power_management_policy.mutable_battery_delays()->set_screen_dim_ms(1000);
357  power_management_policy.mutable_battery_delays()->set_screen_lock_ms(2000);
358  power_management_policy.mutable_battery_delays()->set_screen_off_ms(3000);
359  power_management_policy.mutable_battery_delays()->set_idle_warning_ms(4000);
360  power_management_policy.mutable_battery_delays()->set_idle_ms(5000);
361  power_management_policy.set_use_audio_activity(false);
362  power_management_policy.set_use_video_activity(false);
363  power_management_policy.set_ac_idle_action(
364      pm::PowerManagementPolicy::STOP_SESSION);
365  power_management_policy.set_battery_idle_action(
366      pm::PowerManagementPolicy::STOP_SESSION);
367  power_management_policy.set_lid_closed_action(
368      pm::PowerManagementPolicy::STOP_SESSION);
369  power_management_policy.set_presentation_screen_dim_delay_factor(3.0);
370  power_management_policy.set_user_activity_screen_dim_delay_factor(3.0);
371  power_management_policy.set_wait_for_initial_user_activity(true);
372
373  user_policy_.payload().mutable_screendimdelayac()->set_value(5000);
374  user_policy_.payload().mutable_screenlockdelayac()->set_value(6000);
375  user_policy_.payload().mutable_screenoffdelayac()->set_value(7000);
376  user_policy_.payload().mutable_idlewarningdelayac()->set_value(8000);
377  user_policy_.payload().mutable_idledelayac()->set_value(9000);
378  user_policy_.payload().mutable_screendimdelaybattery()->set_value(1000);
379  user_policy_.payload().mutable_screenlockdelaybattery()->set_value(2000);
380  user_policy_.payload().mutable_screenoffdelaybattery()->set_value(3000);
381  user_policy_.payload().mutable_idlewarningdelaybattery()->set_value(4000);
382  user_policy_.payload().mutable_idledelaybattery()->set_value(5000);
383  user_policy_.payload().mutable_powermanagementusesaudioactivity()->set_value(
384      false);
385  user_policy_.payload().mutable_powermanagementusesvideoactivity()->set_value(
386      false);
387  user_policy_.payload().mutable_idleactionac()->set_value(
388      chromeos::PowerPolicyController::ACTION_STOP_SESSION);
389  user_policy_.payload().mutable_idleactionbattery()->set_value(
390      chromeos::PowerPolicyController::ACTION_STOP_SESSION);
391  user_policy_.payload().mutable_lidcloseaction()->set_value(
392      chromeos::PowerPolicyController::ACTION_STOP_SESSION);
393  user_policy_.payload().mutable_presentationscreendimdelayscale()->set_value(
394      300);
395  user_policy_.payload().mutable_useractivityscreendimdelayscale()->set_value(
396      300);
397  user_policy_.payload().mutable_waitforinitialuseractivity()->set_value(true);
398  StoreAndReloadUserPolicy();
399  EXPECT_EQ(GetDebugString(power_management_policy),
400            GetDebugString(power_manager_client_->policy()));
401}
402
403// Verifies that user policy is applied during a session.
404IN_PROC_BROWSER_TEST_F(PowerPolicyInSessionBrowserTest, SetUserPolicy) {
405  pm::PowerManagementPolicy power_management_policy =
406      power_manager_client_->policy();
407  power_management_policy.mutable_ac_delays()->set_screen_dim_ms(5000);
408  power_management_policy.mutable_ac_delays()->set_screen_lock_ms(6000);
409  power_management_policy.mutable_ac_delays()->set_screen_off_ms(7000);
410  power_management_policy.mutable_ac_delays()->set_idle_warning_ms(8000);
411  power_management_policy.mutable_ac_delays()->set_idle_ms(9000);
412  power_management_policy.mutable_battery_delays()->set_screen_dim_ms(1000);
413  power_management_policy.mutable_battery_delays()->set_screen_lock_ms(2000);
414  power_management_policy.mutable_battery_delays()->set_screen_off_ms(3000);
415  power_management_policy.mutable_battery_delays()->set_idle_warning_ms(4000);
416  power_management_policy.mutable_battery_delays()->set_idle_ms(5000);
417  power_management_policy.set_use_audio_activity(false);
418  power_management_policy.set_use_video_activity(false);
419  power_management_policy.set_ac_idle_action(
420      pm::PowerManagementPolicy::STOP_SESSION);
421  power_management_policy.set_battery_idle_action(
422      pm::PowerManagementPolicy::STOP_SESSION);
423  power_management_policy.set_lid_closed_action(
424      pm::PowerManagementPolicy::STOP_SESSION);
425  power_management_policy.set_presentation_screen_dim_delay_factor(3.0);
426  power_management_policy.set_user_activity_screen_dim_delay_factor(3.0);
427  power_management_policy.set_wait_for_initial_user_activity(true);
428
429  // Set legacy policies which are expected to be ignored.
430  user_policy_.payload().mutable_screendimdelayac()->set_value(5555);
431  user_policy_.payload().mutable_screenlockdelayac()->set_value(6666);
432  user_policy_.payload().mutable_screenoffdelayac()->set_value(7777);
433  user_policy_.payload().mutable_idlewarningdelayac()->set_value(8888);
434  user_policy_.payload().mutable_idledelayac()->set_value(9999);
435  user_policy_.payload().mutable_screendimdelaybattery()->set_value(1111);
436  user_policy_.payload().mutable_screenlockdelaybattery()->set_value(2222);
437  user_policy_.payload().mutable_screenoffdelaybattery()->set_value(3333);
438  user_policy_.payload().mutable_idlewarningdelaybattery()->set_value(4444);
439  user_policy_.payload().mutable_idledelaybattery()->set_value(5555);
440  user_policy_.payload().mutable_idleactionac()->set_value(
441      chromeos::PowerPolicyController::ACTION_SHUT_DOWN);
442  user_policy_.payload().mutable_idleactionbattery()->set_value(
443      chromeos::PowerPolicyController::ACTION_DO_NOTHING);
444
445  // Set current policies which are expected to be honored.
446  user_policy_.payload().mutable_powermanagementusesaudioactivity()->set_value(
447      false);
448  user_policy_.payload().mutable_powermanagementusesvideoactivity()->set_value(
449      false);
450  user_policy_.payload().mutable_lidcloseaction()->set_value(
451      chromeos::PowerPolicyController::ACTION_STOP_SESSION);
452  user_policy_.payload().mutable_presentationscreendimdelayscale()->set_value(
453      300);
454  user_policy_.payload().mutable_useractivityscreendimdelayscale()->set_value(
455      300);
456  user_policy_.payload().mutable_waitforinitialuseractivity()->set_value(true);
457
458  user_policy_.payload().mutable_powermanagementidlesettings()->set_value(
459      kPowerManagementIdleSettingsPolicy);
460  user_policy_.payload().mutable_screenlockdelays()->set_value(
461      kScreenLockDelayPolicy);
462
463  StoreAndReloadUserPolicy();
464  EXPECT_EQ(GetDebugString(power_management_policy),
465            GetDebugString(power_manager_client_->policy()));
466}
467
468// Verifies that screen wake locks can be enabled and disabled by extensions and
469// user policy during a session.
470IN_PROC_BROWSER_TEST_F(PowerPolicyInSessionBrowserTest, AllowScreenWakeLocks) {
471  pm::PowerManagementPolicy baseline_policy =
472      power_manager_client_->policy();
473
474  // Default settings should have delays.
475  pm::PowerManagementPolicy power_management_policy = baseline_policy;
476  EXPECT_NE(0, baseline_policy.ac_delays().screen_dim_ms());
477  EXPECT_NE(0, baseline_policy.ac_delays().screen_off_ms());
478  EXPECT_NE(0, baseline_policy.battery_delays().screen_dim_ms());
479  EXPECT_NE(0, baseline_policy.battery_delays().screen_off_ms());
480
481  // Pretend an extension grabs a screen wake lock.
482  const char kExtensionId[] = "abcdefghijklmnopabcdefghijlkmnop";
483  extensions::PowerApiManager::Get(browser()->profile())->AddRequest(
484      kExtensionId, extensions::core_api::power::LEVEL_DISPLAY);
485  base::RunLoop().RunUntilIdle();
486
487  // Check that the lock is in effect (ignoring ac_idle_action,
488  // battery_idle_action and reason).
489  pm::PowerManagementPolicy policy = baseline_policy;
490  policy.mutable_ac_delays()->set_screen_dim_ms(0);
491  policy.mutable_ac_delays()->set_screen_off_ms(0);
492  policy.mutable_battery_delays()->set_screen_dim_ms(0);
493  policy.mutable_battery_delays()->set_screen_off_ms(0);
494  policy.set_ac_idle_action(
495      power_manager_client_->policy().ac_idle_action());
496  policy.set_battery_idle_action(
497      power_manager_client_->policy().battery_idle_action());
498  policy.set_reason(power_manager_client_->policy().reason());
499  EXPECT_EQ(GetDebugString(policy),
500            GetDebugString(power_manager_client_->policy()));
501
502  // Engage the user policy and verify that the defaults take effect again.
503  user_policy_.payload().mutable_allowscreenwakelocks()->set_value(false);
504  StoreAndReloadUserPolicy();
505  policy = baseline_policy;
506  policy.set_ac_idle_action(power_manager_client_->policy().ac_idle_action());
507  policy.set_battery_idle_action(
508      power_manager_client_->policy().battery_idle_action());
509  policy.set_reason(power_manager_client_->policy().reason());
510  EXPECT_EQ(GetDebugString(policy),
511            GetDebugString(power_manager_client_->policy()));
512}
513
514}  // namespace policy
515