chrome/browser/chromeos/policy/login_screen_default_policy_browsertest.cc

   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.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