src/chrome/browser/chromeos/policy/power_policy_browsertest.cc

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