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