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