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/files/file_path.h"
14#include "base/files/file_util.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/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 TearDownOnMainThread() 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  DevicePolicyCrosBrowserTest::SetUpInProcessBrowserTestFixture();
181  power_manager_client_ = new chromeos::FakePowerManagerClient;
182  dbus_setter()->SetPowerManagerClient(
183      scoped_ptr<chromeos::PowerManagerClient>(power_manager_client_));
184
185  // Initialize device policy.
186  InstallOwnerKey();
187  MarkAsEnterpriseOwned();
188}
189
190void PowerPolicyBrowserTestBase::SetUpOnMainThread() {
191  DevicePolicyCrosBrowserTest::SetUpOnMainThread();
192
193  // Initialize user policy.
194  InstallUserKey();
195  user_policy_.policy_data().set_username(chromeos::login::kStubUser);
196}
197
198void PowerPolicyBrowserTestBase::InstallUserKey() {
199  base::FilePath user_keys_dir;
200  ASSERT_TRUE(PathService::Get(chromeos::DIR_USER_POLICY_KEYS, &user_keys_dir));
201  std::string sanitized_username =
202      chromeos::CryptohomeClient::GetStubSanitizedUsername(
203          chromeos::login::kStubUser);
204  base::FilePath user_key_file =
205      user_keys_dir.AppendASCII(sanitized_username)
206                   .AppendASCII("policy.pub");
207  std::vector<uint8> user_key_bits;
208  ASSERT_TRUE(user_policy_.GetSigningKey()->ExportPublicKey(&user_key_bits));
209  ASSERT_TRUE(base::CreateDirectory(user_key_file.DirName()));
210  ASSERT_EQ(base::WriteFile(
211                user_key_file,
212                reinterpret_cast<const char*>(user_key_bits.data()),
213                user_key_bits.size()),
214            static_cast<int>(user_key_bits.size()));
215}
216
217void PowerPolicyBrowserTestBase::StoreAndReloadUserPolicy() {
218  // Install the new user policy blob in session manager client.
219  user_policy_.Build();
220  session_manager_client()->set_user_policy(
221      user_policy_.policy_data().username(),
222      user_policy_.GetBlob());
223
224  // Reload user policy from session manager client and wait for the update to
225  // take effect.
226  RunClosureAndWaitForUserPolicyUpdate(
227      base::Bind(&PowerPolicyBrowserTestBase::ReloadUserPolicy, this,
228                 browser()->profile()),
229      browser()->profile());
230}
231
232void PowerPolicyBrowserTestBase::
233    StoreAndReloadDevicePolicyAndWaitForLoginProfileChange() {
234  Profile* profile = chromeos::ProfileHelper::GetSigninProfile();
235  ASSERT_TRUE(profile);
236
237  // Install the new device policy blob in session manager client, reload device
238  // policy from session manager client and wait for a change in the login
239  // profile's policy to be observed.
240  RunClosureAndWaitForUserPolicyUpdate(
241      base::Bind(&PowerPolicyBrowserTestBase::RefreshDevicePolicy, this),
242      profile);
243}
244
245std::string PowerPolicyBrowserTestBase::GetDebugString(
246    const pm::PowerManagementPolicy& policy) {
247  return chromeos::PowerPolicyController::GetPolicyDebugString(policy);
248}
249
250void PowerPolicyBrowserTestBase::RunClosureAndWaitForUserPolicyUpdate(
251    const base::Closure& closure,
252    Profile* profile) {
253  base::RunLoop run_loop;
254  MockPolicyServiceObserver observer;
255  EXPECT_CALL(observer, OnPolicyUpdated(_, _, _))
256      .WillOnce(InvokeWithoutArgs(&run_loop, &base::RunLoop::Quit));
257  EXPECT_CALL(observer, OnPolicyServiceInitialized(_)).Times(AnyNumber());
258  PolicyService* policy_service =
259      ProfilePolicyConnectorFactory::GetForProfile(profile)->policy_service();
260  ASSERT_TRUE(policy_service);
261  policy_service->AddObserver(POLICY_DOMAIN_CHROME, &observer);
262  closure.Run();
263  run_loop.Run();
264  policy_service->RemoveObserver(POLICY_DOMAIN_CHROME, &observer);
265}
266
267void PowerPolicyBrowserTestBase::ReloadUserPolicy(Profile* profile) {
268  UserCloudPolicyManagerChromeOS* policy_manager =
269      UserCloudPolicyManagerFactoryChromeOS::GetForProfile(profile);
270  ASSERT_TRUE(policy_manager);
271  policy_manager->core()->store()->Load();
272}
273
274PowerPolicyLoginScreenBrowserTest::PowerPolicyLoginScreenBrowserTest() {
275}
276
277void PowerPolicyLoginScreenBrowserTest::SetUpCommandLine(
278    CommandLine* command_line) {
279  PowerPolicyBrowserTestBase::SetUpCommandLine(command_line);
280  command_line->AppendSwitch(chromeos::switches::kLoginManager);
281  command_line->AppendSwitch(chromeos::switches::kForceLoginManagerInTests);
282}
283
284void PowerPolicyLoginScreenBrowserTest::SetUpOnMainThread() {
285  PowerPolicyBrowserTestBase::SetUpOnMainThread();
286
287  // Wait for the login screen to be shown.
288  content::WindowedNotificationObserver(
289      chrome::NOTIFICATION_LOGIN_OR_LOCK_WEBUI_VISIBLE,
290      content::NotificationService::AllSources()).Wait();
291}
292
293void PowerPolicyLoginScreenBrowserTest::TearDownOnMainThread() {
294  base::MessageLoop::current()->PostTask(FROM_HERE,
295                                         base::Bind(&chrome::AttemptExit));
296  base::RunLoop().RunUntilIdle();
297  PowerPolicyBrowserTestBase::TearDownOnMainThread();
298}
299
300PowerPolicyInSessionBrowserTest::PowerPolicyInSessionBrowserTest() {
301}
302
303void PowerPolicyInSessionBrowserTest::SetUpOnMainThread() {
304  PowerPolicyBrowserTestBase::SetUpOnMainThread();
305}
306
307// Verifies that device policy is applied on the login screen.
308IN_PROC_BROWSER_TEST_F(PowerPolicyLoginScreenBrowserTest, SetDevicePolicy) {
309  pm::PowerManagementPolicy power_management_policy =
310      power_manager_client_->policy();
311  power_management_policy.mutable_ac_delays()->set_screen_dim_ms(5000);
312  power_management_policy.mutable_ac_delays()->set_screen_off_ms(7000);
313  power_management_policy.mutable_ac_delays()->set_idle_ms(9000);
314  power_management_policy.mutable_battery_delays()->set_screen_dim_ms(1000);
315  power_management_policy.mutable_battery_delays()->set_screen_off_ms(3000);
316  power_management_policy.mutable_battery_delays()->set_idle_ms(4000);
317  power_management_policy.set_ac_idle_action(
318      pm::PowerManagementPolicy::DO_NOTHING);
319  power_management_policy.set_battery_idle_action(
320      pm::PowerManagementPolicy::DO_NOTHING);
321  power_management_policy.set_lid_closed_action(
322      pm::PowerManagementPolicy::DO_NOTHING);
323  power_management_policy.set_user_activity_screen_dim_delay_factor(3.0);
324
325  em::ChromeDeviceSettingsProto& proto(device_policy()->payload());
326  proto.mutable_login_screen_power_management()->
327      set_login_screen_power_management(kLoginScreenPowerManagementPolicy);
328  StoreAndReloadDevicePolicyAndWaitForLoginProfileChange();
329  EXPECT_EQ(GetDebugString(power_management_policy),
330            GetDebugString(power_manager_client_->policy()));
331}
332
333// Verifies that device policy is ignored during a session.
334IN_PROC_BROWSER_TEST_F(PowerPolicyInSessionBrowserTest, SetDevicePolicy) {
335  pm::PowerManagementPolicy power_management_policy =
336      power_manager_client_->policy();
337
338  em::ChromeDeviceSettingsProto& proto(device_policy()->payload());
339  proto.mutable_login_screen_power_management()->
340      set_login_screen_power_management(kLoginScreenPowerManagementPolicy);
341  StoreAndReloadDevicePolicyAndWaitForLoginProfileChange();
342  EXPECT_EQ(GetDebugString(power_management_policy),
343            GetDebugString(power_manager_client_->policy()));
344}
345
346// Verifies that legacy user policy is applied during a session.
347IN_PROC_BROWSER_TEST_F(PowerPolicyInSessionBrowserTest, SetLegacyUserPolicy) {
348  pm::PowerManagementPolicy power_management_policy =
349      power_manager_client_->policy();
350  power_management_policy.mutable_ac_delays()->set_screen_dim_ms(5000);
351  power_management_policy.mutable_ac_delays()->set_screen_lock_ms(6000);
352  power_management_policy.mutable_ac_delays()->set_screen_off_ms(7000);
353  power_management_policy.mutable_ac_delays()->set_idle_warning_ms(8000);
354  power_management_policy.mutable_ac_delays()->set_idle_ms(9000);
355  power_management_policy.mutable_battery_delays()->set_screen_dim_ms(1000);
356  power_management_policy.mutable_battery_delays()->set_screen_lock_ms(2000);
357  power_management_policy.mutable_battery_delays()->set_screen_off_ms(3000);
358  power_management_policy.mutable_battery_delays()->set_idle_warning_ms(4000);
359  power_management_policy.mutable_battery_delays()->set_idle_ms(5000);
360  power_management_policy.set_use_audio_activity(false);
361  power_management_policy.set_use_video_activity(false);
362  power_management_policy.set_ac_idle_action(
363      pm::PowerManagementPolicy::STOP_SESSION);
364  power_management_policy.set_battery_idle_action(
365      pm::PowerManagementPolicy::STOP_SESSION);
366  power_management_policy.set_lid_closed_action(
367      pm::PowerManagementPolicy::STOP_SESSION);
368  power_management_policy.set_presentation_screen_dim_delay_factor(3.0);
369  power_management_policy.set_user_activity_screen_dim_delay_factor(3.0);
370  power_management_policy.set_wait_for_initial_user_activity(true);
371
372  user_policy_.payload().mutable_screendimdelayac()->set_value(5000);
373  user_policy_.payload().mutable_screenlockdelayac()->set_value(6000);
374  user_policy_.payload().mutable_screenoffdelayac()->set_value(7000);
375  user_policy_.payload().mutable_idlewarningdelayac()->set_value(8000);
376  user_policy_.payload().mutable_idledelayac()->set_value(9000);
377  user_policy_.payload().mutable_screendimdelaybattery()->set_value(1000);
378  user_policy_.payload().mutable_screenlockdelaybattery()->set_value(2000);
379  user_policy_.payload().mutable_screenoffdelaybattery()->set_value(3000);
380  user_policy_.payload().mutable_idlewarningdelaybattery()->set_value(4000);
381  user_policy_.payload().mutable_idledelaybattery()->set_value(5000);
382  user_policy_.payload().mutable_powermanagementusesaudioactivity()->set_value(
383      false);
384  user_policy_.payload().mutable_powermanagementusesvideoactivity()->set_value(
385      false);
386  user_policy_.payload().mutable_idleactionac()->set_value(
387      chromeos::PowerPolicyController::ACTION_STOP_SESSION);
388  user_policy_.payload().mutable_idleactionbattery()->set_value(
389      chromeos::PowerPolicyController::ACTION_STOP_SESSION);
390  user_policy_.payload().mutable_lidcloseaction()->set_value(
391      chromeos::PowerPolicyController::ACTION_STOP_SESSION);
392  user_policy_.payload().mutable_presentationscreendimdelayscale()->set_value(
393      300);
394  user_policy_.payload().mutable_useractivityscreendimdelayscale()->set_value(
395      300);
396  user_policy_.payload().mutable_waitforinitialuseractivity()->set_value(true);
397  StoreAndReloadUserPolicy();
398  EXPECT_EQ(GetDebugString(power_management_policy),
399            GetDebugString(power_manager_client_->policy()));
400}
401
402// Verifies that user policy is applied during a session.
403IN_PROC_BROWSER_TEST_F(PowerPolicyInSessionBrowserTest, SetUserPolicy) {
404  pm::PowerManagementPolicy power_management_policy =
405      power_manager_client_->policy();
406  power_management_policy.mutable_ac_delays()->set_screen_dim_ms(5000);
407  power_management_policy.mutable_ac_delays()->set_screen_lock_ms(6000);
408  power_management_policy.mutable_ac_delays()->set_screen_off_ms(7000);
409  power_management_policy.mutable_ac_delays()->set_idle_warning_ms(8000);
410  power_management_policy.mutable_ac_delays()->set_idle_ms(9000);
411  power_management_policy.mutable_battery_delays()->set_screen_dim_ms(1000);
412  power_management_policy.mutable_battery_delays()->set_screen_lock_ms(2000);
413  power_management_policy.mutable_battery_delays()->set_screen_off_ms(3000);
414  power_management_policy.mutable_battery_delays()->set_idle_warning_ms(4000);
415  power_management_policy.mutable_battery_delays()->set_idle_ms(5000);
416  power_management_policy.set_use_audio_activity(false);
417  power_management_policy.set_use_video_activity(false);
418  power_management_policy.set_ac_idle_action(
419      pm::PowerManagementPolicy::STOP_SESSION);
420  power_management_policy.set_battery_idle_action(
421      pm::PowerManagementPolicy::STOP_SESSION);
422  power_management_policy.set_lid_closed_action(
423      pm::PowerManagementPolicy::STOP_SESSION);
424  power_management_policy.set_presentation_screen_dim_delay_factor(3.0);
425  power_management_policy.set_user_activity_screen_dim_delay_factor(3.0);
426  power_management_policy.set_wait_for_initial_user_activity(true);
427
428  // Set legacy policies which are expected to be ignored.
429  user_policy_.payload().mutable_screendimdelayac()->set_value(5555);
430  user_policy_.payload().mutable_screenlockdelayac()->set_value(6666);
431  user_policy_.payload().mutable_screenoffdelayac()->set_value(7777);
432  user_policy_.payload().mutable_idlewarningdelayac()->set_value(8888);
433  user_policy_.payload().mutable_idledelayac()->set_value(9999);
434  user_policy_.payload().mutable_screendimdelaybattery()->set_value(1111);
435  user_policy_.payload().mutable_screenlockdelaybattery()->set_value(2222);
436  user_policy_.payload().mutable_screenoffdelaybattery()->set_value(3333);
437  user_policy_.payload().mutable_idlewarningdelaybattery()->set_value(4444);
438  user_policy_.payload().mutable_idledelaybattery()->set_value(5555);
439  user_policy_.payload().mutable_idleactionac()->set_value(
440      chromeos::PowerPolicyController::ACTION_SHUT_DOWN);
441  user_policy_.payload().mutable_idleactionbattery()->set_value(
442      chromeos::PowerPolicyController::ACTION_DO_NOTHING);
443
444  // Set current policies which are expected to be honored.
445  user_policy_.payload().mutable_powermanagementusesaudioactivity()->set_value(
446      false);
447  user_policy_.payload().mutable_powermanagementusesvideoactivity()->set_value(
448      false);
449  user_policy_.payload().mutable_lidcloseaction()->set_value(
450      chromeos::PowerPolicyController::ACTION_STOP_SESSION);
451  user_policy_.payload().mutable_presentationscreendimdelayscale()->set_value(
452      300);
453  user_policy_.payload().mutable_useractivityscreendimdelayscale()->set_value(
454      300);
455  user_policy_.payload().mutable_waitforinitialuseractivity()->set_value(true);
456
457  user_policy_.payload().mutable_powermanagementidlesettings()->set_value(
458      kPowerManagementIdleSettingsPolicy);
459  user_policy_.payload().mutable_screenlockdelays()->set_value(
460      kScreenLockDelayPolicy);
461
462  StoreAndReloadUserPolicy();
463  EXPECT_EQ(GetDebugString(power_management_policy),
464            GetDebugString(power_manager_client_->policy()));
465}
466
467// Verifies that screen wake locks can be enabled and disabled by extensions and
468// user policy during a session.
469IN_PROC_BROWSER_TEST_F(PowerPolicyInSessionBrowserTest, AllowScreenWakeLocks) {
470  pm::PowerManagementPolicy baseline_policy =
471      power_manager_client_->policy();
472
473  // Default settings should have delays.
474  pm::PowerManagementPolicy power_management_policy = baseline_policy;
475  EXPECT_NE(0, baseline_policy.ac_delays().screen_dim_ms());
476  EXPECT_NE(0, baseline_policy.ac_delays().screen_off_ms());
477  EXPECT_NE(0, baseline_policy.battery_delays().screen_dim_ms());
478  EXPECT_NE(0, baseline_policy.battery_delays().screen_off_ms());
479
480  // Pretend an extension grabs a screen wake lock.
481  const char kExtensionId[] = "abcdefghijklmnopabcdefghijlkmnop";
482  extensions::PowerApiManager::Get(browser()->profile())->AddRequest(
483      kExtensionId, extensions::core_api::power::LEVEL_DISPLAY);
484  base::RunLoop().RunUntilIdle();
485
486  // Check that the lock is in effect (ignoring ac_idle_action,
487  // battery_idle_action and reason).
488  pm::PowerManagementPolicy policy = baseline_policy;
489  policy.mutable_ac_delays()->set_screen_dim_ms(0);
490  policy.mutable_ac_delays()->set_screen_off_ms(0);
491  policy.mutable_battery_delays()->set_screen_dim_ms(0);
492  policy.mutable_battery_delays()->set_screen_off_ms(0);
493  policy.set_ac_idle_action(
494      power_manager_client_->policy().ac_idle_action());
495  policy.set_battery_idle_action(
496      power_manager_client_->policy().battery_idle_action());
497  policy.set_reason(power_manager_client_->policy().reason());
498  EXPECT_EQ(GetDebugString(policy),
499            GetDebugString(power_manager_client_->policy()));
500
501  // Engage the user policy and verify that the defaults take effect again.
502  user_policy_.payload().mutable_allowscreenwakelocks()->set_value(false);
503  StoreAndReloadUserPolicy();
504  policy = baseline_policy;
505  policy.set_ac_idle_action(power_manager_client_->policy().ac_idle_action());
506  policy.set_battery_idle_action(
507      power_manager_client_->policy().battery_idle_action());
508  policy.set_reason(power_manager_client_->policy().reason());
509  EXPECT_EQ(GetDebugString(policy),
510            GetDebugString(power_manager_client_->policy()));
511}
512
513}  // namespace policy
514