1 // Copyright 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 7 #include "ash/magnifier/magnifier_constants.h" 8 #include "base/basictypes.h" 9 #include "base/bind.h" 10 #include "base/bind_helpers.h" 11 #include "base/command_line.h" 12 #include "base/compiler_specific.h" 13 #include "base/location.h" 14 #include "base/message_loop/message_loop.h" 15 #include "base/prefs/pref_change_registrar.h" 16 #include "base/prefs/pref_service.h" 17 #include "base/run_loop.h" 18 #include "base/values.h" 19 #include "chrome/browser/chromeos/accessibility/accessibility_manager.h" 20 #include "chrome/browser/chromeos/accessibility/magnification_manager.h" 21 #include "chrome/browser/chromeos/policy/device_policy_builder.h" 22 #include "chrome/browser/chromeos/policy/device_policy_cros_browser_test.h" 23 #include "chrome/browser/chromeos/profiles/profile_helper.h" 24 #include "chrome/browser/chromeos/settings/device_settings_service.h" 25 #include "chrome/browser/lifetime/application_lifetime.h" 26 #include "chrome/browser/policy/proto/chromeos/chrome_device_policy.pb.h" 27 #include "chrome/browser/profiles/profile.h" 28 #include "chrome/browser/profiles/profile_manager.h" 29 #include "chrome/common/pref_names.h" 30 #include "chromeos/chromeos_switches.h" 31 #include "testing/gtest/include/gtest/gtest.h" 32 33 namespace em = enterprise_management; 34 35 namespace policy { 36 37 namespace { 38 39 const em::AccessibilitySettingsProto_ScreenMagnifierType kFullScreenMagnifier = 40 em::AccessibilitySettingsProto_ScreenMagnifierType_SCREEN_MAGNIFIER_TYPE_FULL; 41 42 // Spins the loop until a notification is received from |prefs| that the value 43 // of |pref_name| has changed. If the notification is received before Wait() 44 // has been called, Wait() returns immediately and no loop is spun. 45 class PrefChangeWatcher { 46 public: 47 PrefChangeWatcher(const char* pref_name, PrefService* prefs); 48 49 void Wait(); 50 51 void OnPrefChange(); 52 53 private: 54 bool pref_changed_; 55 56 base::RunLoop run_loop_; 57 PrefChangeRegistrar registrar_; 58 59 DISALLOW_COPY_AND_ASSIGN(PrefChangeWatcher); 60 }; 61 62 PrefChangeWatcher::PrefChangeWatcher(const char* pref_name, 63 PrefService* prefs) 64 : pref_changed_(false) { 65 registrar_.Init(prefs); 66 registrar_.Add(pref_name, base::Bind(&PrefChangeWatcher::OnPrefChange, 67 base::Unretained(this))); 68 } 69 70 void PrefChangeWatcher::Wait() { 71 if (!pref_changed_) 72 run_loop_.Run(); 73 } 74 75 void PrefChangeWatcher::OnPrefChange() { 76 pref_changed_ = true; 77 run_loop_.Quit(); 78 } 79 80 } // namespace 81 82 class LoginScreenDefaultPolicyBrowsertestBase 83 : public DevicePolicyCrosBrowserTest { 84 protected: 85 LoginScreenDefaultPolicyBrowsertestBase(); 86 virtual ~LoginScreenDefaultPolicyBrowsertestBase(); 87 88 // DevicePolicyCrosBrowserTest: 89 virtual void SetUpInProcessBrowserTestFixture() OVERRIDE; 90 virtual void SetUpOnMainThread() OVERRIDE; 91 92 void RefreshDevicePolicyAndWaitForPrefChange(const char* pref_name); 93 94 Profile* login_profile_; 95 96 private: 97 DISALLOW_COPY_AND_ASSIGN(LoginScreenDefaultPolicyBrowsertestBase); 98 }; 99 100 class LoginScreenDefaultPolicyLoginScreenBrowsertest 101 : public LoginScreenDefaultPolicyBrowsertestBase { 102 protected: 103 LoginScreenDefaultPolicyLoginScreenBrowsertest(); 104 virtual ~LoginScreenDefaultPolicyLoginScreenBrowsertest(); 105 106 // LoginScreenDefaultPolicyBrowsertestBase: 107 virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE; 108 virtual void SetUpOnMainThread() OVERRIDE; 109 virtual void CleanUpOnMainThread() OVERRIDE; 110 111 void VerifyPrefFollowsRecommendation(const char* pref_name, 112 const base::Value& recommended_value); 113 114 private: 115 DISALLOW_COPY_AND_ASSIGN(LoginScreenDefaultPolicyLoginScreenBrowsertest); 116 }; 117 118 class LoginScreenDefaultPolicyInSessionBrowsertest 119 : public LoginScreenDefaultPolicyBrowsertestBase { 120 protected: 121 LoginScreenDefaultPolicyInSessionBrowsertest(); 122 virtual ~LoginScreenDefaultPolicyInSessionBrowsertest(); 123 124 // LoginScreenDefaultPolicyBrowsertestBase: 125 virtual void SetUpOnMainThread() OVERRIDE; 126 127 void VerifyPrefFollowsDefault(const char* pref_name); 128 129 private: 130 DISALLOW_COPY_AND_ASSIGN(LoginScreenDefaultPolicyInSessionBrowsertest); 131 }; 132 133 LoginScreenDefaultPolicyBrowsertestBase:: 134 LoginScreenDefaultPolicyBrowsertestBase() : login_profile_(NULL) { 135 } 136 137 LoginScreenDefaultPolicyBrowsertestBase:: 138 ~LoginScreenDefaultPolicyBrowsertestBase() { 139 } 140 141 void LoginScreenDefaultPolicyBrowsertestBase:: 142 SetUpInProcessBrowserTestFixture() { 143 InstallOwnerKey(); 144 MarkAsEnterpriseOwned(); 145 DevicePolicyCrosBrowserTest::SetUpInProcessBrowserTestFixture(); 146 } 147 148 void LoginScreenDefaultPolicyBrowsertestBase::SetUpOnMainThread() { 149 DevicePolicyCrosBrowserTest::SetUpOnMainThread(); 150 login_profile_ = chromeos::ProfileHelper::GetSigninProfile(); 151 ASSERT_TRUE(login_profile_); 152 } 153 154 void LoginScreenDefaultPolicyBrowsertestBase:: 155 RefreshDevicePolicyAndWaitForPrefChange(const char* pref_name) { 156 PrefChangeWatcher watcher(pref_name, login_profile_->GetPrefs()); 157 RefreshDevicePolicy(); 158 watcher.Wait(); 159 } 160 161 LoginScreenDefaultPolicyLoginScreenBrowsertest:: 162 LoginScreenDefaultPolicyLoginScreenBrowsertest() { 163 } 164 165 LoginScreenDefaultPolicyLoginScreenBrowsertest:: 166 ~LoginScreenDefaultPolicyLoginScreenBrowsertest() { 167 } 168 169 void LoginScreenDefaultPolicyLoginScreenBrowsertest::SetUpCommandLine( 170 CommandLine* command_line) { 171 LoginScreenDefaultPolicyBrowsertestBase::SetUpCommandLine(command_line); 172 command_line->AppendSwitch(chromeos::switches::kLoginManager); 173 command_line->AppendSwitch(chromeos::switches::kForceLoginManagerInTests); 174 } 175 176 void LoginScreenDefaultPolicyLoginScreenBrowsertest::SetUpOnMainThread() { 177 LoginScreenDefaultPolicyBrowsertestBase::SetUpOnMainThread(); 178 179 // Set the login screen profile. 180 chromeos::AccessibilityManager* accessibility_manager = 181 chromeos::AccessibilityManager::Get(); 182 ASSERT_TRUE(accessibility_manager); 183 accessibility_manager->SetProfileForTest( 184 chromeos::ProfileHelper::GetSigninProfile()); 185 186 chromeos::MagnificationManager* magnification_manager = 187 chromeos::MagnificationManager::Get(); 188 ASSERT_TRUE(magnification_manager); 189 magnification_manager->SetProfileForTest( 190 chromeos::ProfileHelper::GetSigninProfile()); 191 } 192 193 void LoginScreenDefaultPolicyLoginScreenBrowsertest::CleanUpOnMainThread() { 194 base::MessageLoop::current()->PostTask(FROM_HERE, 195 base::Bind(&chrome::AttemptExit)); 196 base::RunLoop().RunUntilIdle(); 197 LoginScreenDefaultPolicyBrowsertestBase::CleanUpOnMainThread(); 198 } 199 200 void LoginScreenDefaultPolicyLoginScreenBrowsertest:: 201 VerifyPrefFollowsRecommendation(const char* pref_name, 202 const base::Value& recommended_value) { 203 const PrefService::Preference* pref = 204 login_profile_->GetPrefs()->FindPreference(pref_name); 205 ASSERT_TRUE(pref); 206 EXPECT_FALSE(pref->IsManaged()); 207 EXPECT_FALSE(pref->IsDefaultValue()); 208 EXPECT_TRUE(base::Value::Equals(&recommended_value, pref->GetValue())); 209 EXPECT_TRUE(base::Value::Equals(&recommended_value, 210 pref->GetRecommendedValue())); 211 } 212 213 LoginScreenDefaultPolicyInSessionBrowsertest:: 214 LoginScreenDefaultPolicyInSessionBrowsertest() { 215 } 216 217 LoginScreenDefaultPolicyInSessionBrowsertest:: 218 ~LoginScreenDefaultPolicyInSessionBrowsertest() { 219 } 220 221 void LoginScreenDefaultPolicyInSessionBrowsertest::SetUpOnMainThread() { 222 LoginScreenDefaultPolicyBrowsertestBase::SetUpOnMainThread(); 223 224 // Tell the DeviceSettingsService that there is no local owner. 225 chromeos::DeviceSettingsService::Get()->SetUsername(std::string()); 226 } 227 228 void LoginScreenDefaultPolicyInSessionBrowsertest::VerifyPrefFollowsDefault( 229 const char* pref_name) { 230 Profile* profile = ProfileManager::GetDefaultProfile(); 231 ASSERT_TRUE(profile); 232 const PrefService::Preference* pref = 233 profile->GetPrefs()->FindPreference(pref_name); 234 ASSERT_TRUE(pref); 235 EXPECT_FALSE(pref->IsManaged()); 236 EXPECT_TRUE(pref->IsDefaultValue()); 237 EXPECT_FALSE(pref->GetRecommendedValue()); 238 } 239 240 IN_PROC_BROWSER_TEST_F(LoginScreenDefaultPolicyLoginScreenBrowsertest, 241 DeviceLoginScreenDefaultLargeCursorEnabled) { 242 // Verifies that the default state of the large cursor accessibility feature 243 // on the login screen can be controlled through device policy. 244 245 // Enable the large cursor through device policy and wait for the change to 246 // take effect. 247 em::ChromeDeviceSettingsProto& proto(device_policy()->payload()); 248 proto.mutable_accessibility_settings()-> 249 set_login_screen_default_large_cursor_enabled(true); 250 RefreshDevicePolicyAndWaitForPrefChange(prefs::kLargeCursorEnabled); 251 252 // Verify that the pref which controls the large cursor in the login profile 253 // has changed to the policy-supplied default. 254 VerifyPrefFollowsRecommendation(prefs::kLargeCursorEnabled, 255 base::FundamentalValue(true)); 256 257 // Verify that the large cursor is enabled. 258 chromeos::AccessibilityManager* accessibility_manager = 259 chromeos::AccessibilityManager::Get(); 260 ASSERT_TRUE(accessibility_manager); 261 EXPECT_TRUE(accessibility_manager->IsLargeCursorEnabled()); 262 } 263 264 IN_PROC_BROWSER_TEST_F(LoginScreenDefaultPolicyLoginScreenBrowsertest, 265 DeviceLoginScreenDefaultSpokenFeedbackEnabled) { 266 // Verifies that the default state of the spoken feedback accessibility 267 // feature on the login screen can be controlled through device policy. 268 269 // Enable spoken feedback through device policy and wait for the change to 270 // take effect. 271 em::ChromeDeviceSettingsProto& proto(device_policy()->payload()); 272 proto.mutable_accessibility_settings()-> 273 set_login_screen_default_spoken_feedback_enabled(true); 274 RefreshDevicePolicyAndWaitForPrefChange(prefs::kSpokenFeedbackEnabled); 275 276 // Verify that the pref which controls spoken feedback in the login profile 277 // has changed to the policy-supplied default. 278 VerifyPrefFollowsRecommendation(prefs::kSpokenFeedbackEnabled, 279 base::FundamentalValue(true)); 280 281 // Verify that spoken feedback is enabled. 282 chromeos::AccessibilityManager* accessibility_manager = 283 chromeos::AccessibilityManager::Get(); 284 ASSERT_TRUE(accessibility_manager); 285 EXPECT_TRUE(accessibility_manager->IsSpokenFeedbackEnabled()); 286 } 287 288 IN_PROC_BROWSER_TEST_F(LoginScreenDefaultPolicyLoginScreenBrowsertest, 289 DeviceLoginScreenDefaultHighContrastEnabled) { 290 // Verifies that the default state of the high contrast mode accessibility 291 // feature on the login screen can be controlled through device policy. 292 293 // Enable high contrast mode through device policy and wait for the change to 294 // take effect. 295 em::ChromeDeviceSettingsProto& proto(device_policy()->payload()); 296 proto.mutable_accessibility_settings()-> 297 set_login_screen_default_high_contrast_enabled(true); 298 RefreshDevicePolicyAndWaitForPrefChange(prefs::kHighContrastEnabled); 299 300 // Verify that the pref which controls high contrast mode in the login profile 301 // has changed to the policy-supplied default. 302 VerifyPrefFollowsRecommendation(prefs::kHighContrastEnabled, 303 base::FundamentalValue(true)); 304 305 // Verify that high contrast mode is enabled. 306 chromeos::AccessibilityManager* accessibility_manager = 307 chromeos::AccessibilityManager::Get(); 308 ASSERT_TRUE(accessibility_manager); 309 EXPECT_TRUE(accessibility_manager->IsHighContrastEnabled()); 310 } 311 312 IN_PROC_BROWSER_TEST_F(LoginScreenDefaultPolicyLoginScreenBrowsertest, 313 DeviceLoginScreenDefaultScreenMagnifierType) { 314 // Verifies that the default screen magnifier type enabled on the login screen 315 // can be controlled through device policy. 316 317 // Set the screen magnifier type through device policy and wait for the change 318 // to take effect. 319 em::ChromeDeviceSettingsProto& proto(device_policy()->payload()); 320 proto.mutable_accessibility_settings()-> 321 set_login_screen_default_screen_magnifier_type(kFullScreenMagnifier); 322 RefreshDevicePolicyAndWaitForPrefChange(prefs::kScreenMagnifierType); 323 324 // Verify that the prefs which control the screen magnifier type have changed 325 // to the policy-supplied default. 326 VerifyPrefFollowsRecommendation(prefs::kScreenMagnifierEnabled, 327 base::FundamentalValue(true)); 328 VerifyPrefFollowsRecommendation(prefs::kScreenMagnifierType, 329 base::FundamentalValue(ash::MAGNIFIER_FULL)); 330 331 // Verify that the full-screen magnifier is enabled. 332 chromeos::MagnificationManager* magnification_manager = 333 chromeos::MagnificationManager::Get(); 334 ASSERT_TRUE(magnification_manager); 335 EXPECT_TRUE(magnification_manager->IsMagnifierEnabled()); 336 EXPECT_EQ(ash::MAGNIFIER_FULL, magnification_manager->GetMagnifierType()); 337 } 338 339 IN_PROC_BROWSER_TEST_F(LoginScreenDefaultPolicyInSessionBrowsertest, 340 DeviceLoginScreenDefaultLargeCursorEnabled) { 341 // Verifies that changing the default state of the large cursor accessibility 342 // feature on the login screen through policy does not affect its state in a 343 // session. 344 345 // Enable the large cursor through device policy and wait for the change to 346 // take effect. 347 em::ChromeDeviceSettingsProto& proto(device_policy()->payload()); 348 proto.mutable_accessibility_settings()-> 349 set_login_screen_default_large_cursor_enabled(true); 350 RefreshDevicePolicyAndWaitForPrefChange(prefs::kLargeCursorEnabled); 351 352 // Verify that the pref which controls the large cursor in the session is 353 // unchanged. 354 VerifyPrefFollowsDefault(prefs::kLargeCursorEnabled); 355 356 // Verify that the large cursor is disabled. 357 chromeos::AccessibilityManager* accessibility_manager = 358 chromeos::AccessibilityManager::Get(); 359 ASSERT_TRUE(accessibility_manager); 360 EXPECT_FALSE(accessibility_manager->IsLargeCursorEnabled()); 361 } 362 363 IN_PROC_BROWSER_TEST_F(LoginScreenDefaultPolicyInSessionBrowsertest, 364 DeviceLoginScreenDefaultSpokenFeedbackEnabled) { 365 // Verifies that changing the default state of the spoken feedback 366 // accessibility feature on the login screen through policy does not affect 367 // its state in a session. 368 369 // Enable spoken feedback through device policy and wait for the change to 370 // take effect. 371 em::ChromeDeviceSettingsProto& proto(device_policy()->payload()); 372 proto.mutable_accessibility_settings()-> 373 set_login_screen_default_spoken_feedback_enabled(true); 374 RefreshDevicePolicyAndWaitForPrefChange(prefs::kSpokenFeedbackEnabled); 375 376 // Verify that the pref which controls the spoken feedback in the session is 377 // unchanged. 378 VerifyPrefFollowsDefault(prefs::kSpokenFeedbackEnabled); 379 380 // Verify that spoken feedback is disabled. 381 chromeos::AccessibilityManager* accessibility_manager = 382 chromeos::AccessibilityManager::Get(); 383 ASSERT_TRUE(accessibility_manager); 384 EXPECT_FALSE(accessibility_manager->IsSpokenFeedbackEnabled()); 385 } 386 387 IN_PROC_BROWSER_TEST_F(LoginScreenDefaultPolicyInSessionBrowsertest, 388 DeviceLoginScreenDefaultHighContrastEnabled) { 389 // Verifies that changing the default state of the high contrast mode 390 // accessibility feature on the login screen through policy does not affect 391 // its state in a session. 392 393 // Enable high contrast mode through device policy and wait for the change to 394 // take effect. 395 em::ChromeDeviceSettingsProto& proto(device_policy()->payload()); 396 proto.mutable_accessibility_settings()-> 397 set_login_screen_default_high_contrast_enabled(true); 398 RefreshDevicePolicyAndWaitForPrefChange(prefs::kHighContrastEnabled); 399 400 // Verify that the pref which controls high contrast mode in the session is 401 // unchanged. 402 VerifyPrefFollowsDefault(prefs::kHighContrastEnabled); 403 404 // Verify that high contrast mode is disabled. 405 chromeos::AccessibilityManager* accessibility_manager = 406 chromeos::AccessibilityManager::Get(); 407 ASSERT_TRUE(accessibility_manager); 408 EXPECT_FALSE(accessibility_manager->IsHighContrastEnabled()); 409 } 410 411 IN_PROC_BROWSER_TEST_F(LoginScreenDefaultPolicyInSessionBrowsertest, 412 DeviceLoginScreenDefaultScreenMagnifierType) { 413 // Verifies that changing the default screen magnifier type enabled on the 414 // login screen through policy does not affect its state in a session. 415 416 // Set the screen magnifier type through device policy and wait for the change 417 // to take effect. 418 em::ChromeDeviceSettingsProto& proto(device_policy()->payload()); 419 proto.mutable_accessibility_settings()-> 420 set_login_screen_default_screen_magnifier_type(kFullScreenMagnifier); 421 RefreshDevicePolicyAndWaitForPrefChange(prefs::kScreenMagnifierType); 422 423 // Verify that the prefs which control the screen magnifier in the session are 424 // unchanged. 425 VerifyPrefFollowsDefault(prefs::kScreenMagnifierEnabled); 426 VerifyPrefFollowsDefault(prefs::kScreenMagnifierType); 427 428 // Verify that the screen magnifier is disabled. 429 chromeos::MagnificationManager* magnification_manager = 430 chromeos::MagnificationManager::Get(); 431 ASSERT_TRUE(magnification_manager); 432 EXPECT_FALSE(magnification_manager->IsMagnifierEnabled()); 433 EXPECT_EQ(ash::kDefaultMagnifierType, 434 magnification_manager->GetMagnifierType()); 435 } 436 437 } // namespace policy 438