Add policies to control power management on the Chrome OS login screen

chrome/browser/chromeos/policy/power_policy_browsertest.cc

 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <string>
-
+#include <vector>
+
+#include "base/basictypes.h"
+#include "base/bind.h"
+#include "base/command_line.h"
 #include "base/compiler_specific.h"
+#include "base/file_util.h"
+#include "base/files/file_path.h"
+#include "base/location.h"
+#include "base/message_loop/message_loop.h"
+#include "base/path_service.h"
 #include "base/run_loop.h"
-#include "base/values.h"
+#include "chrome/browser/browser_process.h"
+#include "chrome/browser/chromeos/login/user_manager.h"
+#include "chrome/browser/chromeos/policy/device_policy_builder.h"
+#include "chrome/browser/chromeos/policy/device_policy_cros_browser_test.h"
+#include "chrome/browser/chromeos/policy/user_cloud_policy_manager_chromeos.h"
+#include "chrome/browser/chromeos/policy/user_cloud_policy_manager_factory_chromeos.h"
+#include "chrome/browser/chromeos/profiles/profile_helper.h"
+#include "chrome/browser/chromeos/settings/device_settings_service.h"
 #include "chrome/browser/extensions/api/power/power_api_manager.h"
-#include "chrome/browser/policy/browser_policy_connector.h"
-#include "chrome/browser/policy/mock_configuration_policy_provider.h"
+#include "chrome/browser/lifetime/application_lifetime.h"
+#include "chrome/browser/policy/cloud/cloud_policy_core.h"
+#include "chrome/browser/policy/cloud/cloud_policy_store.h"
+#include "chrome/browser/policy/cloud/policy_builder.h"
 #include "chrome/browser/policy/policy_map.h"
-#include "chrome/browser/policy/policy_types.h"
+#include "chrome/browser/policy/policy_service.h"
+#include "chrome/browser/policy/profile_policy_connector.h"
+#include "chrome/browser/policy/profile_policy_connector_factory.h"
+#include "chrome/browser/policy/proto/chromeos/chrome_device_policy.pb.h"
+#include "chrome/browser/policy/proto/cloud/device_management_backend.pb.h"
+#include "chrome/browser/profiles/profile.h"
+#include "chrome/browser/profiles/profile_manager.h"
+#include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/extensions/api/power.h"
-#include "chrome/test/base/in_process_browser_test.h"
-#include "chromeos/dbus/dbus_thread_manager.h"
+#include "chrome/test/base/testing_profile.h"
+#include "chromeos/chromeos_paths.h"
+#include "chromeos/chromeos_switches.h"
 #include "chromeos/dbus/fake_power_manager_client.h"
+#include "chromeos/dbus/fake_session_manager_client.h"
 #include "chromeos/dbus/mock_dbus_thread_manager_without_gmock.h"
 #include "chromeos/dbus/power_manager/policy.pb.h"
 #include "chromeos/dbus/power_policy_controller.h"
-#include "policy/policy_constants.h"
+#include "content/public/browser/notification_details.h"
+#include "content/public/browser/notification_service.h"
+#include "content/public/browser/notification_source.h"
+#include "content/public/test/test_utils.h"
+#include "crypto/rsa_private_key.h"
 #include "testing/gmock/include/gmock/gmock.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace em = enterprise_management;
+namespace pm = power_manager;
+
+using ::testing::AnyNumber;
+using ::testing::InvokeWithoutArgs;
+using ::testing::_;
 
 namespace policy {
 
-namespace {
-
-using ::testing::AnyNumber;
-using ::testing::Return;
-using ::testing::_;
-
-namespace pm = power_manager;
-
-}  // namespace
-
-class PowerPolicyBrowserTest : public InProcessBrowserTest {
+class MockPolicyServiceObserver : public PolicyService::Observer {

[Mattias Nissler (ping if slow), 2013/07/03 16:52:18]

There's a copy of this in policy_service_impl_unittest.cc already, care to break
it out?

[bartfab (slow), 2013/07/03 19:11:04]

Done.

+ public:
+  MockPolicyServiceObserver();
+  virtual ~MockPolicyServiceObserver();
+
+  MOCK_METHOD3(OnPolicyUpdated, void(const PolicyNamespace&,
+                                     const PolicyMap& previous,
+                                     const PolicyMap& current));
+  MOCK_METHOD1(OnPolicyServiceInitialized, void(PolicyDomain));
+};
+
+class PowerPolicyBrowserTestBase : public DevicePolicyCrosBrowserTest {
  protected:
-  // InProcessBrowserTest:
+  PowerPolicyBrowserTestBase();
+
+  // DevicePolicyCrosBrowserTest:
   virtual void SetUpInProcessBrowserTestFixture() OVERRIDE;
-
-  // Sets |user_policy_name| to |user_policy_value|.
-  void SetUserPolicy(const std::string& user_policy_name,
-                     base::Value* user_policy_value);
+  virtual void SetUpOnMainThread() OVERRIDE;
+
+  void InstallUserKey();
+  void RefreshUserPolicy();
+
+  void RefreshDevicePolicyAndWaitForLoginProfileChanges();
 
   // Returns a string describing |policy|.
   std::string GetDebugString(const pm::PowerManagementPolicy& policy);
 
+  UserPolicyBuilder user_policy_;
+
   chromeos::FakePowerManagerClient* power_manager_client_;
 
- private:
-  MockConfigurationPolicyProvider provider_;
+  DISALLOW_COPY_AND_ASSIGN(PowerPolicyBrowserTestBase);
 };
 
-void PowerPolicyBrowserTest::SetUpInProcessBrowserTestFixture() {
-  chromeos::MockDBusThreadManagerWithoutGMock* dbus_thread_manager =
-      new chromeos::MockDBusThreadManagerWithoutGMock;
-  power_manager_client_ = dbus_thread_manager->fake_power_manager_client();
-  chromeos::DBusThreadManager::InitializeForTesting(dbus_thread_manager);
-  EXPECT_CALL(provider_, IsInitializationComplete(_))
-      .WillRepeatedly(Return(true));
-  EXPECT_CALL(provider_, RegisterPolicyDomain(_)).Times(AnyNumber());
-  BrowserPolicyConnector::SetPolicyProviderForTesting(&provider_);
-}
-
-void PowerPolicyBrowserTest::SetUserPolicy(
-    const std::string& user_policy_name,
-    base::Value* user_policy_value) {
-  PolicyMap policy_map;
-  policy_map.Set(user_policy_name, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
-                 user_policy_value);
-  provider_.UpdateChromePolicy(policy_map);
+class PowerPolicyLoginScreenBrowserTest : public PowerPolicyBrowserTestBase {
+ protected:
+  PowerPolicyLoginScreenBrowserTest();
+
+  // PowerPolicyBrowserTestBase:
+  virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE;
+  virtual void SetUpOnMainThread() OVERRIDE;
+  virtual void CleanUpOnMainThread() OVERRIDE;
+
+  DISALLOW_COPY_AND_ASSIGN(PowerPolicyLoginScreenBrowserTest);
+};
+
+class PowerPolicyInSessionBrowserTest : public PowerPolicyBrowserTestBase {
+ protected:
+  PowerPolicyInSessionBrowserTest();
+
+  // PowerPolicyBrowserTestBase:
+  virtual void SetUpOnMainThread() OVERRIDE;
+
+  DISALLOW_COPY_AND_ASSIGN(PowerPolicyInSessionBrowserTest);
+};
+
+MockPolicyServiceObserver::MockPolicyServiceObserver() {
+}
+
+MockPolicyServiceObserver::~MockPolicyServiceObserver() {
+}
+
+PowerPolicyBrowserTestBase::PowerPolicyBrowserTestBase()
+    : power_manager_client_(NULL) {
+}
+
+void PowerPolicyBrowserTestBase::SetUpInProcessBrowserTestFixture() {
+  DevicePolicyCrosBrowserTest::SetUpInProcessBrowserTestFixture();
+
+  // Initialize device policy.
+  InstallOwnerKey();
+  MarkAsEnterpriseOwned();
+
+  power_manager_client_ =
+      mock_dbus_thread_manager()->fake_power_manager_client();
+}
+
+void PowerPolicyBrowserTestBase::SetUpOnMainThread() {
+  DevicePolicyCrosBrowserTest::SetUpOnMainThread();
+
+  // Initialize user policy.
+  InstallUserKey();
+  user_policy_.policy_data().set_username(chromeos::UserManager::kStubUser);
+}
+
+void PowerPolicyBrowserTestBase::InstallUserKey() {
+  base::FilePath user_keys_dir;
+  ASSERT_TRUE(PathService::Get(chromeos::DIR_USER_POLICY_KEYS, &user_keys_dir));
+  base::FilePath user_key_file =
+      user_keys_dir.AppendASCII(chromeos::UserManager::kStubUser)
+                   .AppendASCII("policy.pub");
+  std::vector<uint8> user_key_bits;
+  ASSERT_TRUE(user_policy_.signing_key()->ExportPublicKey(&user_key_bits));
+  ASSERT_TRUE(file_util::CreateDirectory(user_key_file.DirName()));
+  ASSERT_EQ(file_util::WriteFile(
+                user_key_file,
+                reinterpret_cast<const char*>(user_key_bits.data()),
+                user_key_bits.size()),
+            static_cast<int>(user_key_bits.size()));
+}
+
+void PowerPolicyBrowserTestBase::RefreshUserPolicy() {
+  ProfileManager* profile_manager = g_browser_process->profile_manager();
+  Profile* profile = profile_manager->GetProfileByPath(
+      profile_manager->user_data_dir().Append(
+          TestingProfile::kTestUserProfileDir));
+  ASSERT_TRUE(profile);
+
+  // Install the new user policy blob in session manager client.
+  user_policy_.Build();
+  session_manager_client()->set_user_policy(
+      user_policy_.policy_data().username(),
+      user_policy_.GetBlob());
+
+  // Reload user policy from session manager client.
+  base::RunLoop run_loop;
+  MockPolicyServiceObserver observer;

[Mattias Nissler (ping if slow), 2013/07/03 16:52:18]

Why do we need this observer? The callbacks are certainly not what we're testing
here. Is this code copied from somewhere?

[bartfab (slow), 2013/07/03 19:11:04]

We call policy_manager->core()->store()->Load() and then have to wait for the
policy to be loaded, verified and applied (which happens in the asynchronously
in the blocking pool). I followed the approach I saw in another test: Set up an
observer that will call base::RunLoop::Quit() when the policy arrives, then
simply base::RunLoop()::Run().

[Mattias Nissler (ping if slow), 2013/07/04 11:53:04]

Ah, I had missed the waiting part. I guess a better way of doing this would be
to call PolicyService::RefreshPolicies(), which takes a completion callback
parameter (for which you can pass run_loop.QuitClosure()). 

[bartfab (slow), 2013/07/05 13:52:57]

As discussed offline, I kept this implementation to avoid the need to fake
registration against DMServer but I refactored things to factor out common
boilerplate code.

+  EXPECT_CALL(observer, OnPolicyUpdated(_, _, _))
+      .WillOnce(InvokeWithoutArgs(&run_loop, &base::RunLoop::Quit));
+  EXPECT_CALL(observer, OnPolicyServiceInitialized(_)).Times(AnyNumber());
+  PolicyService* policy_service =
+      ProfilePolicyConnectorFactory::GetForProfile(profile)->policy_service();
+  ASSERT_TRUE(policy_service);
+  policy_service->AddObserver(POLICY_DOMAIN_CHROME, &observer);
+  UserCloudPolicyManagerChromeOS* policy_manager =
+      UserCloudPolicyManagerFactoryChromeOS::GetForProfile(profile);
+  ASSERT_TRUE(policy_manager);
+  policy_manager->core()->store()->Load();
+  run_loop.Run();
+  policy_service->RemoveObserver(POLICY_DOMAIN_CHROME, &observer);
+}
+
+void PowerPolicyBrowserTestBase::
+    RefreshDevicePolicyAndWaitForLoginProfileChanges() {
+  Profile* profile = chromeos::ProfileHelper::GetSigninProfile();
+  ASSERT_TRUE(profile);
+
+  // Install the new device policy blob in session manager client, reload device
+  // policy from session manager client and wait for a change in the login
+  // profile's policy to be observed.
+  base::RunLoop run_loop;
+  MockPolicyServiceObserver observer;

[Mattias Nissler (ping if slow), 2013/07/03 16:52:18]

Same thing here: Why would we need this observer?

[bartfab (slow), 2013/07/03 19:11:04]

As above.

+  EXPECT_CALL(observer, OnPolicyUpdated(_, _, _))
+      .WillOnce(InvokeWithoutArgs(&run_loop, &base::RunLoop::Quit));
+  EXPECT_CALL(observer, OnPolicyServiceInitialized(_)).Times(AnyNumber());
+  PolicyService* policy_service =
+      ProfilePolicyConnectorFactory::GetForProfile(profile)->policy_service();
+  ASSERT_TRUE(policy_service);
+  policy_service->AddObserver(POLICY_DOMAIN_CHROME, &observer);
+  RefreshDevicePolicy();
+  run_loop.Run();
+  policy_service->RemoveObserver(POLICY_DOMAIN_CHROME, &observer);
+
+  // Spin the loop until idle because more changes to the login profile's policy
+  // may be pending.
   base::RunLoop().RunUntilIdle();
 }
 
-std::string PowerPolicyBrowserTest::GetDebugString(
+std::string PowerPolicyBrowserTestBase::GetDebugString(
     const pm::PowerManagementPolicy& policy) {
   return chromeos::PowerPolicyController::GetPolicyDebugString(policy);
 }
 
-IN_PROC_BROWSER_TEST_F(PowerPolicyBrowserTest, SetPowerPolicy) {
-  pm::PowerManagementPolicy original_power_management_policy =
+PowerPolicyLoginScreenBrowserTest::PowerPolicyLoginScreenBrowserTest() {
+}
+
+void PowerPolicyLoginScreenBrowserTest::SetUpCommandLine(
+    CommandLine* command_line) {
+  PowerPolicyBrowserTestBase::SetUpCommandLine(command_line);
+  command_line->AppendSwitch(chromeos::switches::kLoginManager);
+  command_line->AppendSwitch(chromeos::switches::kForceLoginManagerInTests);
+}
+
+void PowerPolicyLoginScreenBrowserTest::SetUpOnMainThread() {
+  PowerPolicyBrowserTestBase::SetUpOnMainThread();
+
+  // Wait for the login screen to be shown.
+  content::WindowedNotificationObserver(
+      chrome::NOTIFICATION_LOGIN_WEBUI_VISIBLE,
+      content::NotificationService::AllSources()).Wait();
+}
+
+void PowerPolicyLoginScreenBrowserTest::CleanUpOnMainThread() {
+  base::MessageLoop::current()->PostTask(FROM_HERE,
+                                         base::Bind(&chrome::AttemptExit));
+  base::RunLoop().RunUntilIdle();
+  PowerPolicyBrowserTestBase::CleanUpOnMainThread();
+}
+
+PowerPolicyInSessionBrowserTest::PowerPolicyInSessionBrowserTest() {
+}
+
+void PowerPolicyInSessionBrowserTest::SetUpOnMainThread() {
+  PowerPolicyBrowserTestBase::SetUpOnMainThread();
+
+  // Tell the DeviceSettingsService that there is no local owner.
+  chromeos::DeviceSettingsService::Get()->SetUsername(std::string());
+}
+
+// Verifies that device policy is applied on the login screen.
+IN_PROC_BROWSER_TEST_F(PowerPolicyLoginScreenBrowserTest, SetDevicePolicy) {
+  pm::PowerManagementPolicy power_management_policy =
       power_manager_client_->get_policy();
-
+  em::ChromeDeviceSettingsProto& proto(device_policy()->payload());
+
+  power_management_policy.mutable_ac_delays()->set_screen_dim_ms(5000);
+  proto.mutable_power_management()->set_login_screen_screen_dim_delay_ac(5000);
+  RefreshDevicePolicyAndWaitForLoginProfileChanges();
+  EXPECT_EQ(GetDebugString(power_management_policy),
+            GetDebugString(power_manager_client_->get_policy()));

[Mattias Nissler (ping if slow), 2013/07/03 16:52:18]

Hm, maybe it's simpler to just change all values at once and compare the
strings? Granted, we lose some test coverage (probably nothing critical though),
but the test would be easier to read.

[bartfab (slow), 2013/07/03 19:11:04]

Done.

+
+  power_management_policy.mutable_ac_delays()->set_screen_off_ms(7000);
+  proto.mutable_power_management()->set_login_screen_screen_off_delay_ac(7000);
+  RefreshDevicePolicyAndWaitForLoginProfileChanges();
+  EXPECT_EQ(GetDebugString(power_management_policy),
+            GetDebugString(power_manager_client_->get_policy()));
+
+  power_management_policy.mutable_ac_delays()->set_idle_ms(9000);
+  proto.mutable_power_management()->set_login_screen_idle_delay_ac(9000);
+  RefreshDevicePolicyAndWaitForLoginProfileChanges();
+  EXPECT_EQ(GetDebugString(power_management_policy),
+            GetDebugString(power_manager_client_->get_policy()));
+
+  power_management_policy.mutable_battery_delays()->set_screen_dim_ms(1000);
+  proto.mutable_power_management()->set_login_screen_screen_dim_delay_battery(
+      1000);
+  RefreshDevicePolicyAndWaitForLoginProfileChanges();
+  EXPECT_EQ(GetDebugString(power_management_policy),
+            GetDebugString(power_manager_client_->get_policy()));
+
+  power_management_policy.mutable_battery_delays()->set_screen_off_ms(3000);
+  proto.mutable_power_management()->set_login_screen_screen_off_delay_battery(
+      3000);
+  RefreshDevicePolicyAndWaitForLoginProfileChanges();
+  EXPECT_EQ(GetDebugString(power_management_policy),
+            GetDebugString(power_manager_client_->get_policy()));
+
+  power_management_policy.mutable_battery_delays()->set_idle_ms(4000);
+  proto.mutable_power_management()->set_login_screen_idle_delay_battery(
+      4000);
+  RefreshDevicePolicyAndWaitForLoginProfileChanges();
+  EXPECT_EQ(GetDebugString(power_management_policy),
+            GetDebugString(power_manager_client_->get_policy()));
+
+  power_management_policy.set_ac_idle_action(
+      pm::PowerManagementPolicy::DO_NOTHING);
+  proto.mutable_power_management()->set_login_screen_idle_action_ac(
+      em::PowerManagementProto_PowerManagementAction_ACTION_DO_NOTHING);
+  RefreshDevicePolicyAndWaitForLoginProfileChanges();
+  EXPECT_EQ(GetDebugString(power_management_policy),
+            GetDebugString(power_manager_client_->get_policy()));
+
+  power_management_policy.set_battery_idle_action(
+      pm::PowerManagementPolicy::DO_NOTHING);
+  proto.mutable_power_management()->set_login_screen_idle_action_battery(
+      em::PowerManagementProto_PowerManagementAction_ACTION_DO_NOTHING);
+  RefreshDevicePolicyAndWaitForLoginProfileChanges();
+  EXPECT_EQ(GetDebugString(power_management_policy),
+            GetDebugString(power_manager_client_->get_policy()));
+
+  power_management_policy.set_lid_closed_action(
+      pm::PowerManagementPolicy::DO_NOTHING);
+  proto.mutable_power_management()->set_login_screen_lid_close_action(
+      em::PowerManagementProto_PowerManagementAction_ACTION_DO_NOTHING);
+  RefreshDevicePolicyAndWaitForLoginProfileChanges();
+  EXPECT_EQ(GetDebugString(power_management_policy),
+            GetDebugString(power_manager_client_->get_policy()));
+
+  power_management_policy.set_user_activity_screen_dim_delay_factor(3.0);
+  proto.mutable_power_management()->
+      set_login_screen_user_activity_screen_dim_delay_scale(300);
+  RefreshDevicePolicyAndWaitForLoginProfileChanges();
+  EXPECT_EQ(GetDebugString(power_management_policy),
+            GetDebugString(power_manager_client_->get_policy()));
+}
+
+// Verifies that device policy is ignored during a session.
+IN_PROC_BROWSER_TEST_F(PowerPolicyInSessionBrowserTest, SetDevicePolicy) {
   pm::PowerManagementPolicy power_management_policy =
-      original_power_management_policy;
+      power_manager_client_->get_policy();
+  em::ChromeDeviceSettingsProto& proto(device_policy()->payload());
+
+  proto.mutable_power_management()->set_login_screen_screen_dim_delay_ac(5000);
+  proto.mutable_power_management()->set_login_screen_screen_off_delay_ac(7000);
+  proto.mutable_power_management()->set_login_screen_idle_delay_ac(9000);
+  proto.mutable_power_management()->set_login_screen_screen_dim_delay_battery(
+      1000);
+  proto.mutable_power_management()->set_login_screen_screen_off_delay_battery(
+      3000);
+  proto.mutable_power_management()->set_login_screen_idle_delay_battery(
+      4000);
+  proto.mutable_power_management()->set_login_screen_idle_action_ac(
+      em::PowerManagementProto_PowerManagementAction_ACTION_DO_NOTHING);
+  proto.mutable_power_management()->set_login_screen_idle_action_battery(
+      em::PowerManagementProto_PowerManagementAction_ACTION_DO_NOTHING);
+  proto.mutable_power_management()->set_login_screen_lid_close_action(
+      em::PowerManagementProto_PowerManagementAction_ACTION_DO_NOTHING);
+  proto.mutable_power_management()->
+      set_login_screen_user_activity_screen_dim_delay_scale(300);
+  RefreshDevicePolicyAndWaitForLoginProfileChanges();
+  EXPECT_EQ(GetDebugString(power_management_policy),
+            GetDebugString(power_manager_client_->get_policy()));
+}
+
+// Verifies that user policy is applied during a session.
+IN_PROC_BROWSER_TEST_F(PowerPolicyInSessionBrowserTest, SetUserPolicy) {
+  pm::PowerManagementPolicy power_management_policy =
+      power_manager_client_->get_policy();
+
   power_management_policy.set_ac_idle_action(
       pm::PowerManagementPolicy::STOP_SESSION);
-  SetUserPolicy(
-      key::kIdleActionAC,
-      base::Value::CreateIntegerValue(pm::PowerManagementPolicy::STOP_SESSION));
-  EXPECT_EQ(GetDebugString(power_management_policy),
-            GetDebugString(power_manager_client_->get_policy()));
-
-  power_management_policy = original_power_management_policy;
+  user_policy_.payload().mutable_idleactionac()->set_value(
+      chromeos::PowerPolicyController::ACTION_STOP_SESSION);
+  RefreshUserPolicy();
+  EXPECT_EQ(GetDebugString(power_management_policy),
+            GetDebugString(power_manager_client_->get_policy()));

[Mattias Nissler (ping if slow), 2013/07/03 16:52:18]

Ditto regarding just doing this once and not all policies individually.

[bartfab (slow), 2013/07/03 19:11:04]

Done.

+
   power_management_policy.set_battery_idle_action(
       pm::PowerManagementPolicy::STOP_SESSION);
-  SetUserPolicy(
-      key::kIdleActionBattery,
-      base::Value::CreateIntegerValue(pm::PowerManagementPolicy::STOP_SESSION));
-  EXPECT_EQ(GetDebugString(power_management_policy),
-            GetDebugString(power_manager_client_->get_policy()));
-
-  power_management_policy = original_power_management_policy;
+  user_policy_.payload().mutable_idleactionbattery()->set_value(
+      chromeos::PowerPolicyController::ACTION_STOP_SESSION);
+  RefreshUserPolicy();
+  EXPECT_EQ(GetDebugString(power_management_policy),
+            GetDebugString(power_manager_client_->get_policy()));
+
   power_management_policy.set_lid_closed_action(
       pm::PowerManagementPolicy::STOP_SESSION);
-  SetUserPolicy(
-      key::kLidCloseAction,
-      base::Value::CreateIntegerValue(pm::PowerManagementPolicy::STOP_SESSION));
-  EXPECT_EQ(GetDebugString(power_management_policy),
-            GetDebugString(power_manager_client_->get_policy()));
-
-  power_management_policy = original_power_management_policy;
+  user_policy_.payload().mutable_lidcloseaction()->set_value(
+      chromeos::PowerPolicyController::ACTION_STOP_SESSION);
+  RefreshUserPolicy();
+  EXPECT_EQ(GetDebugString(power_management_policy),
+            GetDebugString(power_manager_client_->get_policy()));
+
   power_management_policy.mutable_ac_delays()->set_idle_ms(9000);
-  SetUserPolicy(key::kIdleDelayAC, base::Value::CreateIntegerValue(9000));
-  EXPECT_EQ(GetDebugString(power_management_policy),
-            GetDebugString(power_manager_client_->get_policy()));
-
-  power_management_policy = original_power_management_policy;
+  user_policy_.payload().mutable_idledelayac()->set_value(9000);
+  RefreshUserPolicy();
+  EXPECT_EQ(GetDebugString(power_management_policy),
+            GetDebugString(power_manager_client_->get_policy()));
+
   power_management_policy.mutable_ac_delays()->set_idle_warning_ms(8000);
-  SetUserPolicy(key::kIdleWarningDelayAC,
-                base::Value::CreateIntegerValue(8000));
-  EXPECT_EQ(GetDebugString(power_management_policy),
-            GetDebugString(power_manager_client_->get_policy()));
-
-  power_management_policy = original_power_management_policy;
+  user_policy_.payload().mutable_idlewarningdelayac()->set_value(8000);
+  RefreshUserPolicy();
+  EXPECT_EQ(GetDebugString(power_management_policy),
+            GetDebugString(power_manager_client_->get_policy()));
+
   power_management_policy.mutable_ac_delays()->set_screen_off_ms(7000);
-  SetUserPolicy(key::kScreenOffDelayAC, base::Value::CreateIntegerValue(7000));
-  EXPECT_EQ(GetDebugString(power_management_policy),
-            GetDebugString(power_manager_client_->get_policy()));
-
-  power_management_policy = original_power_management_policy;
+  user_policy_.payload().mutable_screenoffdelayac()->set_value(7000);
+  RefreshUserPolicy();
+  EXPECT_EQ(GetDebugString(power_management_policy),
+            GetDebugString(power_manager_client_->get_policy()));
+
   power_management_policy.mutable_ac_delays()->set_screen_dim_ms(5000);
-  SetUserPolicy(key::kScreenDimDelayAC, base::Value::CreateIntegerValue(5000));
-  EXPECT_EQ(GetDebugString(power_management_policy),
-            GetDebugString(power_manager_client_->get_policy()));
-
-  power_management_policy = original_power_management_policy;
+  user_policy_.payload().mutable_screendimdelayac()->set_value(5000);
+  RefreshUserPolicy();
+  EXPECT_EQ(GetDebugString(power_management_policy),
+            GetDebugString(power_manager_client_->get_policy()));
+
   power_management_policy.mutable_ac_delays()->set_screen_lock_ms(6000);
-  SetUserPolicy(key::kScreenLockDelayAC, base::Value::CreateIntegerValue(6000));
-  EXPECT_EQ(GetDebugString(power_management_policy),
-            GetDebugString(power_manager_client_->get_policy()));
-
-  power_management_policy = original_power_management_policy;
+  user_policy_.payload().mutable_screenlockdelayac()->set_value(6000);
+  RefreshUserPolicy();
+  EXPECT_EQ(GetDebugString(power_management_policy),
+            GetDebugString(power_manager_client_->get_policy()));
+
   power_management_policy.mutable_battery_delays()->set_idle_ms(5000);
-  SetUserPolicy(key::kIdleDelayBattery, base::Value::CreateIntegerValue(5000));
-  EXPECT_EQ(GetDebugString(power_management_policy),
-            GetDebugString(power_manager_client_->get_policy()));
-
-  power_management_policy = original_power_management_policy;
+  user_policy_.payload().mutable_idledelaybattery()->set_value(5000);
+  RefreshUserPolicy();
+  EXPECT_EQ(GetDebugString(power_management_policy),
+            GetDebugString(power_manager_client_->get_policy()));
+
   power_management_policy.mutable_battery_delays()->set_idle_warning_ms(4000);
-  SetUserPolicy(key::kIdleWarningDelayBattery,
-                base::Value::CreateIntegerValue(4000));
-  EXPECT_EQ(GetDebugString(power_management_policy),
-            GetDebugString(power_manager_client_->get_policy()));
-
-  power_management_policy = original_power_management_policy;
+  user_policy_.payload().mutable_idlewarningdelaybattery()->set_value(4000);
+  RefreshUserPolicy();
+  EXPECT_EQ(GetDebugString(power_management_policy),
+            GetDebugString(power_manager_client_->get_policy()));
+
   power_management_policy.mutable_battery_delays()->set_screen_off_ms(3000);
-  SetUserPolicy(key::kScreenOffDelayBattery,
-                base::Value::CreateIntegerValue(3000));
-  EXPECT_EQ(GetDebugString(power_management_policy),
-            GetDebugString(power_manager_client_->get_policy()));
-
-  power_management_policy = original_power_management_policy;
+  user_policy_.payload().mutable_screenoffdelaybattery()->set_value(3000);
+  RefreshUserPolicy();
+  EXPECT_EQ(GetDebugString(power_management_policy),
+            GetDebugString(power_manager_client_->get_policy()));
+
   power_management_policy.mutable_battery_delays()->set_screen_dim_ms(1000);
-  SetUserPolicy(key::kScreenDimDelayBattery,
-                base::Value::CreateIntegerValue(1000));
-  EXPECT_EQ(GetDebugString(power_management_policy),
-            GetDebugString(power_manager_client_->get_policy()));
-
-  power_management_policy = original_power_management_policy;
+  user_policy_.payload().mutable_screendimdelaybattery()->set_value(1000);
+  RefreshUserPolicy();
+  EXPECT_EQ(GetDebugString(power_management_policy),
+            GetDebugString(power_manager_client_->get_policy()));
+
   power_management_policy.mutable_battery_delays()->set_screen_lock_ms(2000);
-  SetUserPolicy(key::kScreenLockDelayBattery,
-                base::Value::CreateIntegerValue(2000));
-  EXPECT_EQ(GetDebugString(power_management_policy),
-            GetDebugString(power_manager_client_->get_policy()));
-
-  power_management_policy = original_power_management_policy;
+  user_policy_.payload().mutable_screenlockdelaybattery()->set_value(2000);
+  RefreshUserPolicy();
+  EXPECT_EQ(GetDebugString(power_management_policy),
+            GetDebugString(power_manager_client_->get_policy()));
+
   power_management_policy.set_use_audio_activity(false);
-  SetUserPolicy(key::kPowerManagementUsesAudioActivity,
-                base::Value::CreateBooleanValue(false));
-  EXPECT_EQ(GetDebugString(power_management_policy),
-            GetDebugString(power_manager_client_->get_policy()));
-
-  power_management_policy = original_power_management_policy;
+  user_policy_.payload().mutable_powermanagementusesaudioactivity()->set_value(
+      false);
+  RefreshUserPolicy();
+  EXPECT_EQ(GetDebugString(power_management_policy),
+            GetDebugString(power_manager_client_->get_policy()));
+
   power_management_policy.set_use_video_activity(false);
-  SetUserPolicy(key::kPowerManagementUsesVideoActivity,
-                base::Value::CreateBooleanValue(false));
-  EXPECT_EQ(GetDebugString(power_management_policy),
-            GetDebugString(power_manager_client_->get_policy()));
-
-  power_management_policy = original_power_management_policy;
+  user_policy_.payload().mutable_powermanagementusesvideoactivity()->set_value(
+      false);
+  RefreshUserPolicy();
+  EXPECT_EQ(GetDebugString(power_management_policy),
+            GetDebugString(power_manager_client_->get_policy()));
+
   power_management_policy.set_presentation_screen_dim_delay_factor(3.0);
-  SetUserPolicy(key::kPresentationScreenDimDelayScale,
-                base::Value::CreateIntegerValue(300));
-  EXPECT_EQ(GetDebugString(power_management_policy),
-            GetDebugString(power_manager_client_->get_policy()));
-}
-
-IN_PROC_BROWSER_TEST_F(PowerPolicyBrowserTest, AllowScreenWakeLocks) {
+  user_policy_.payload().mutable_presentationscreendimdelayscale()->set_value(
+      300);
+  RefreshUserPolicy();
+  EXPECT_EQ(GetDebugString(power_management_policy),
+            GetDebugString(power_manager_client_->get_policy()));
+
+  power_management_policy.set_user_activity_screen_dim_delay_factor(3.0);
+  user_policy_.payload().mutable_useractivityscreendimdelayscale()->set_value(
+      300);
+  RefreshUserPolicy();
+  EXPECT_EQ(GetDebugString(power_management_policy),
+            GetDebugString(power_manager_client_->get_policy()));
+}
+
+// Verifies that screen wake locks can be enabled and disabled by extensions and
+// user policy during a session.
+IN_PROC_BROWSER_TEST_F(PowerPolicyInSessionBrowserTest, AllowScreenWakeLocks) {
   pm::PowerManagementPolicy baseline_policy =
       power_manager_client_->get_policy();
 
   // Default settings should have delays.
   pm::PowerManagementPolicy power_management_policy = baseline_policy;
   EXPECT_NE(0, baseline_policy.ac_delays().screen_dim_ms());
   EXPECT_NE(0, baseline_policy.ac_delays().screen_off_ms());
   EXPECT_NE(0, baseline_policy.battery_delays().screen_dim_ms());
   EXPECT_NE(0, baseline_policy.battery_delays().screen_off_ms());
 
   // Pretend an extension grabs a screen wake lock.
   const char kExtensionId[] = "abcdefghijklmnopabcdefghijlkmnop";
   extensions::PowerApiManager::GetInstance()->AddRequest(
       kExtensionId, extensions::api::power::LEVEL_DISPLAY);
   base::RunLoop().RunUntilIdle();
 
-  // Check that the lock is in effect (ignoring idle_action and reason).
+  // Check that the lock is in effect (ignoring ac_idle_action,
+  // battery_idle_action and reason).
   pm::PowerManagementPolicy policy = baseline_policy;
   policy.mutable_ac_delays()->set_screen_dim_ms(0);
   policy.mutable_ac_delays()->set_screen_off_ms(0);
   policy.mutable_battery_delays()->set_screen_dim_ms(0);
   policy.mutable_battery_delays()->set_screen_off_ms(0);
   policy.set_ac_idle_action(
       power_manager_client_->get_policy().ac_idle_action());
   policy.set_battery_idle_action(
       power_manager_client_->get_policy().battery_idle_action());
   policy.set_reason(power_manager_client_->get_policy().reason());
   EXPECT_EQ(GetDebugString(policy),
             GetDebugString(power_manager_client_->get_policy()));
 
-  // Engage the policy and verify that the defaults take effect again.
-  SetUserPolicy(key::kAllowScreenWakeLocks,
-                base::Value::CreateBooleanValue(false));
+  // Engage the user policy and verify that the defaults take effect again.
+  user_policy_.payload().mutable_allowscreenwakelocks()->set_value(false);
+  RefreshUserPolicy();
   policy = baseline_policy;
   policy.set_ac_idle_action(
       power_manager_client_->get_policy().ac_idle_action());
   policy.set_battery_idle_action(
       power_manager_client_->get_policy().battery_idle_action());
   policy.set_reason(power_manager_client_->get_policy().reason());
   EXPECT_EQ(GetDebugString(policy),
             GetDebugString(power_manager_client_->get_policy()));
 }
 
 }  // namespace policy