chrome/browser/chromeos/policy/recommendation_restorer_unittest.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 "chrome/browser/chromeos/policy/recommendation_restorer.h"
   6
   7 #include "ash/magnifier/magnifier_constants.h"
   8 #include "base/memory/scoped_ptr.h"
   9 #include "base/prefs/pref_notifier_impl.h"
  10 #include "base/prefs/testing_pref_store.h"
  11 #include "base/strings/utf_string_conversions.h"
  12 #include "base/test/test_simple_task_runner.h"
  13 #include "base/thread_task_runner_handle.h"
  14 #include "base/time/time.h"
  15 #include "base/values.h"
  16 #include "chrome/browser/chrome_notification_types.h"
  17 #include "chrome/browser/chromeos/policy/recommendation_restorer_factory.h"
  18 #include "chrome/browser/prefs/browser_prefs.h"
  19 #include "chrome/browser/prefs/pref_service_syncable.h"
  20 #include "chrome/common/chrome_constants.h"
  21 #include "chrome/common/pref_names.h"
  22 #include "chrome/test/base/testing_browser_process.h"
  23 #include "chrome/test/base/testing_pref_service_syncable.h"
  24 #include "chrome/test/base/testing_profile.h"
  25 #include "chrome/test/base/testing_profile_manager.h"
  26 #include "components/user_prefs/pref_registry_syncable.h"
  27 #include "content/public/browser/notification_details.h"
  28 #include "content/public/browser/notification_service.h"
  29 #include "content/public/browser/notification_source.h"
  30 #include "testing/gtest/include/gtest/gtest.h"
  31
  32 namespace policy {
  33
  34 namespace {
  35   // The amount of idle time after which recommended values are restored.
  36   const int kRestoreDelayInMs = 60 * 1000;  // 1 minute.
  37 }  // namespace
  38
  39 class RecommendationRestorerTest : public testing::Test {
  40  protected:
  41   RecommendationRestorerTest();
  42
  43   // testing::Test:
  44   virtual void SetUp() OVERRIDE;
  45
  46   void RegisterUserProfilePrefs();
  47   void RegisterLoginProfilePrefs();
  48
  49   void SetRecommendedValues();
  50   void SetUserSettings();
  51
  52   void CreateLoginProfile();
  53   void CreateUserProfile();
  54
  55   void NotifyOfSessionStart();
  56   void NotifyOfUserActivity();
  57
  58   void VerifyPrefFollowsUser(const char* pref_name,
  59                              const base::Value& expected_value) const;
  60   void VerifyPrefsFollowUser() const;
  61   void VerifyPrefFollowsRecommendation(const char* pref_name,
  62                                        const base::Value& expected_value) const;
  63   void VerifyPrefsFollowRecommendations() const;
  64
  65   void VerifyNotListeningForNotifications() const;
  66   void VerifyTimerIsStopped() const;
  67   void VerifyTimerIsRunning() const;
  68
  69   TestingPrefStore* recommended_prefs_;  // Not owned.
  70   TestingPrefServiceSyncable* prefs_;    // Not owned.
  71   RecommendationRestorer* restorer_;     // Not owned.
  72
  73   scoped_refptr<base::TestSimpleTaskRunner> runner_;
  74   base::ThreadTaskRunnerHandle runner_handler_;
  75
  76  private:
  77   scoped_ptr<PrefServiceSyncable> prefs_owner_;
  78
  79   TestingProfileManager profile_manager_;
  80
  81   DISALLOW_COPY_AND_ASSIGN(RecommendationRestorerTest);
  82 };
  83
  84 RecommendationRestorerTest::RecommendationRestorerTest()
  85     : recommended_prefs_(new TestingPrefStore),
  86       prefs_(new TestingPrefServiceSyncable(
  87           new TestingPrefStore,
  88           new TestingPrefStore,
  89           recommended_prefs_,
  90           new user_prefs::PrefRegistrySyncable,
  91           new PrefNotifierImpl)),
  92       restorer_(NULL),
  93       runner_(new base::TestSimpleTaskRunner),
  94       runner_handler_(runner_),
  95       prefs_owner_(prefs_),
  96       profile_manager_(TestingBrowserProcess::GetGlobal()) {
  97 }
  98
  99 void RecommendationRestorerTest::SetUp() {
 100   testing::Test::SetUp();
 101   ASSERT_TRUE(profile_manager_.SetUp());
 102 }
 103
 104 void RecommendationRestorerTest::RegisterUserProfilePrefs() {
 105   chrome::RegisterUserProfilePrefs(prefs_->registry());
 106 }
 107
 108 void RecommendationRestorerTest::RegisterLoginProfilePrefs() {
 109   chrome::RegisterLoginProfilePrefs(prefs_->registry());
 110 }
 111
 112 void RecommendationRestorerTest::SetRecommendedValues() {
 113   recommended_prefs_->SetBoolean(prefs::kLargeCursorEnabled, false);
 114   recommended_prefs_->SetBoolean(prefs::kSpokenFeedbackEnabled, false);
 115   recommended_prefs_->SetBoolean(prefs::kHighContrastEnabled, false);
 116   recommended_prefs_->SetBoolean(prefs::kScreenMagnifierEnabled, false);
 117   recommended_prefs_->SetInteger(prefs::kScreenMagnifierType, 0);
 118   recommended_prefs_->SetBoolean(prefs::kVirtualKeyboardEnabled, false);
 119 }
 120
 121 void RecommendationRestorerTest::SetUserSettings() {
 122   prefs_->SetBoolean(prefs::kLargeCursorEnabled, true);
 123   prefs_->SetBoolean(prefs::kSpokenFeedbackEnabled, true);
 124   prefs_->SetBoolean(prefs::kHighContrastEnabled, true);
 125   prefs_->SetBoolean(prefs::kScreenMagnifierEnabled, true);
 126   prefs_->SetInteger(prefs::kScreenMagnifierType, ash::MAGNIFIER_FULL);
 127   prefs_->SetBoolean(prefs::kVirtualKeyboardEnabled, true);
 128 }
 129
 130 void RecommendationRestorerTest::CreateLoginProfile() {
 131   ASSERT_FALSE(restorer_);
 132   TestingProfile* profile = profile_manager_.CreateTestingProfile(
 133       chrome::kInitialProfile, prefs_owner_.Pass(),
 134       base::UTF8ToUTF16(chrome::kInitialProfile), 0, std::string(),
 135       TestingProfile::TestingFactories());
 136   restorer_ = RecommendationRestorerFactory::GetForProfile(profile);
 137   EXPECT_TRUE(restorer_);
 138 }
 139
 140 void RecommendationRestorerTest::CreateUserProfile() {
 141   ASSERT_FALSE(restorer_);
 142   TestingProfile* profile = profile_manager_.CreateTestingProfile(
 143       "user", prefs_owner_.Pass(), base::UTF8ToUTF16("user"), 0, std::string(),
 144       TestingProfile::TestingFactories());
 145   restorer_ = RecommendationRestorerFactory::GetForProfile(profile);
 146   EXPECT_TRUE(restorer_);
 147 }
 148
 149 void RecommendationRestorerTest::NotifyOfSessionStart() {
 150   ASSERT_TRUE(restorer_);
 151   restorer_->Observe(chrome::NOTIFICATION_LOGIN_USER_CHANGED,
 152                      content::Source<RecommendationRestorerTest>(this),
 153                      content::NotificationService::NoDetails());
 154 }
 155
 156 void RecommendationRestorerTest::NotifyOfUserActivity() {
 157   ASSERT_TRUE(restorer_);
 158   restorer_->OnUserActivity(NULL);
 159 }
 160
 161 void RecommendationRestorerTest::VerifyPrefFollowsUser(
 162     const char* pref_name,
 163     const base::Value& expected_value) const {
 164   const PrefServiceSyncable::Preference* pref =
 165       prefs_->FindPreference(pref_name);
 166   ASSERT_TRUE(pref);
 167   EXPECT_TRUE(pref->HasUserSetting());
 168   const base::Value* value = pref->GetValue();
 169   ASSERT_TRUE(value);
 170   EXPECT_TRUE(expected_value.Equals(value));
 171 }
 172
 173 void RecommendationRestorerTest::VerifyPrefsFollowUser() const {
 174   VerifyPrefFollowsUser(prefs::kLargeCursorEnabled,
 175                         base::FundamentalValue(true));
 176   VerifyPrefFollowsUser(prefs::kSpokenFeedbackEnabled,
 177                         base::FundamentalValue(true));
 178   VerifyPrefFollowsUser(prefs::kHighContrastEnabled,
 179                         base::FundamentalValue(true));
 180   VerifyPrefFollowsUser(prefs::kScreenMagnifierEnabled,
 181                         base::FundamentalValue(true));
 182   VerifyPrefFollowsUser(prefs::kScreenMagnifierType,
 183                         base::FundamentalValue(ash::MAGNIFIER_FULL));
 184   VerifyPrefFollowsUser(prefs::kVirtualKeyboardEnabled,
 185                         base::FundamentalValue(true));
 186 }
 187
 188 void RecommendationRestorerTest::VerifyPrefFollowsRecommendation(
 189     const char* pref_name,
 190     const base::Value& expected_value) const {
 191   const PrefServiceSyncable::Preference* pref =
 192       prefs_->FindPreference(pref_name);
 193   ASSERT_TRUE(pref);
 194   EXPECT_TRUE(pref->IsRecommended());
 195   EXPECT_FALSE(pref->HasUserSetting());
 196   const base::Value* value = pref->GetValue();
 197   ASSERT_TRUE(value);
 198   EXPECT_TRUE(expected_value.Equals(value));
 199 }
 200
 201 void RecommendationRestorerTest::VerifyPrefsFollowRecommendations() const {
 202   VerifyPrefFollowsRecommendation(prefs::kLargeCursorEnabled,
 203                                   base::FundamentalValue(false));
 204   VerifyPrefFollowsRecommendation(prefs::kSpokenFeedbackEnabled,
 205                                   base::FundamentalValue(false));
 206   VerifyPrefFollowsRecommendation(prefs::kHighContrastEnabled,
 207                                   base::FundamentalValue(false));
 208   VerifyPrefFollowsRecommendation(prefs::kScreenMagnifierEnabled,
 209                                   base::FundamentalValue(false));
 210   VerifyPrefFollowsRecommendation(prefs::kScreenMagnifierType,
 211                                   base::FundamentalValue(0));
 212   VerifyPrefFollowsRecommendation(prefs::kVirtualKeyboardEnabled,
 213                                   base::FundamentalValue(false));
 214 }
 215
 216 void RecommendationRestorerTest::VerifyNotListeningForNotifications() const {
 217   ASSERT_TRUE(restorer_);
 218   EXPECT_TRUE(restorer_->pref_change_registrar_.IsEmpty());
 219   EXPECT_TRUE(restorer_->notification_registrar_.IsEmpty());
 220 }
 221
 222 void RecommendationRestorerTest::VerifyTimerIsStopped() const {
 223   ASSERT_TRUE(restorer_);
 224   EXPECT_FALSE(restorer_->restore_timer_.IsRunning());
 225 }
 226
 227 void RecommendationRestorerTest::VerifyTimerIsRunning() const {
 228   ASSERT_TRUE(restorer_);
 229   EXPECT_TRUE(restorer_->restore_timer_.IsRunning());
 230   EXPECT_EQ(base::TimeDelta::FromMilliseconds(kRestoreDelayInMs),
 231             restorer_->restore_timer_.GetCurrentDelay());
 232 }
 233
 234 TEST_F(RecommendationRestorerTest, CreateForUserProfile) {
 235   // Verifies that when a RecommendationRestorer is created for a user profile,
 236   // it does not start listening for any notifications, does not clear user
 237   // settings on initialization and does not start a timer that will clear user
 238   // settings eventually.
 239   RegisterUserProfilePrefs();
 240   SetRecommendedValues();
 241   SetUserSettings();
 242
 243   CreateUserProfile();
 244   VerifyNotListeningForNotifications();
 245   VerifyPrefsFollowUser();
 246   VerifyTimerIsStopped();
 247 }
 248
 249 TEST_F(RecommendationRestorerTest, NoRecommendations) {
 250   // Verifies that when no recommended values have been set and a
 251   // RecommendationRestorer is created for the login profile, it does not clear
 252   // user settings on initialization and does not start a timer that will clear
 253   // user settings eventually.
 254   RegisterLoginProfilePrefs();
 255   SetUserSettings();
 256
 257   CreateLoginProfile();
 258   VerifyPrefsFollowUser();
 259   VerifyTimerIsStopped();
 260 }
 261
 262 TEST_F(RecommendationRestorerTest, RestoreOnStartup) {
 263   // Verifies that when recommended values have been set and a
 264   // RecommendationRestorer is created for the login profile, it clears user
 265   // settings on initialization.
 266   RegisterLoginProfilePrefs();
 267   SetRecommendedValues();
 268   SetUserSettings();
 269
 270   CreateLoginProfile();
 271   VerifyPrefsFollowRecommendations();
 272   VerifyTimerIsStopped();
 273 }
 274
 275 TEST_F(RecommendationRestorerTest, RestoreOnRecommendationChangeOnLoginScreen) {
 276   // Verifies that if recommended values change while the login screen is being
 277   // shown, a timer is started that will clear user settings eventually.
 278   RegisterLoginProfilePrefs();
 279   SetUserSettings();
 280
 281   CreateLoginProfile();
 282
 283   VerifyTimerIsStopped();
 284   recommended_prefs_->SetBoolean(prefs::kLargeCursorEnabled, false);
 285   VerifyPrefFollowsUser(prefs::kLargeCursorEnabled,
 286                         base::FundamentalValue(true));
 287   VerifyTimerIsRunning();
 288   runner_->RunUntilIdle();
 289   VerifyPrefFollowsRecommendation(prefs::kLargeCursorEnabled,
 290                                   base::FundamentalValue(false));
 291
 292   VerifyTimerIsStopped();
 293   recommended_prefs_->SetBoolean(prefs::kSpokenFeedbackEnabled, false);
 294   VerifyPrefFollowsUser(prefs::kSpokenFeedbackEnabled,
 295                         base::FundamentalValue(true));
 296   VerifyTimerIsRunning();
 297   runner_->RunUntilIdle();
 298   VerifyPrefFollowsRecommendation(prefs::kSpokenFeedbackEnabled,
 299                                   base::FundamentalValue(false));
 300
 301   VerifyTimerIsStopped();
 302   recommended_prefs_->SetBoolean(prefs::kHighContrastEnabled, false);
 303   VerifyPrefFollowsUser(prefs::kHighContrastEnabled,
 304                         base::FundamentalValue(true));
 305   VerifyTimerIsRunning();
 306   runner_->RunUntilIdle();
 307   VerifyPrefFollowsRecommendation(prefs::kHighContrastEnabled,
 308                                   base::FundamentalValue(false));
 309
 310   VerifyTimerIsStopped();
 311   recommended_prefs_->SetBoolean(prefs::kScreenMagnifierEnabled, false);
 312   recommended_prefs_->SetInteger(prefs::kScreenMagnifierType, 0);
 313   VerifyPrefFollowsUser(prefs::kScreenMagnifierEnabled,
 314                         base::FundamentalValue(true));
 315   VerifyPrefFollowsUser(prefs::kScreenMagnifierType,
 316                         base::FundamentalValue(ash::MAGNIFIER_FULL));
 317   VerifyTimerIsRunning();
 318   runner_->RunUntilIdle();
 319   VerifyPrefFollowsRecommendation(prefs::kScreenMagnifierEnabled,
 320                                   base::FundamentalValue(false));
 321   VerifyPrefFollowsRecommendation(prefs::kScreenMagnifierType,
 322                                   base::FundamentalValue(0));
 323   VerifyTimerIsStopped();
 324   recommended_prefs_->SetBoolean(prefs::kVirtualKeyboardEnabled, false);
 325   VerifyPrefFollowsUser(prefs::kVirtualKeyboardEnabled,
 326                         base::FundamentalValue(true));
 327   VerifyTimerIsRunning();
 328   runner_->RunUntilIdle();
 329   VerifyPrefFollowsRecommendation(prefs::kVirtualKeyboardEnabled,
 330                                   base::FundamentalValue(false));
 331   VerifyTimerIsStopped();
 332 }
 333
 334 TEST_F(RecommendationRestorerTest, RestoreOnRecommendationChangeInUserSession) {
 335   // Verifies that if recommended values change while a user session is in
 336   // progress, user settings are cleared immediately.
 337   RegisterLoginProfilePrefs();
 338   SetUserSettings();
 339
 340   CreateLoginProfile();
 341   NotifyOfSessionStart();
 342
 343   VerifyPrefFollowsUser(prefs::kLargeCursorEnabled,
 344                         base::FundamentalValue(true));
 345   recommended_prefs_->SetBoolean(prefs::kLargeCursorEnabled, false);
 346   VerifyTimerIsStopped();
 347   VerifyPrefFollowsRecommendation(prefs::kLargeCursorEnabled,
 348                                   base::FundamentalValue(false));
 349
 350   VerifyPrefFollowsUser(prefs::kSpokenFeedbackEnabled,
 351                         base::FundamentalValue(true));
 352   recommended_prefs_->SetBoolean(prefs::kSpokenFeedbackEnabled, false);
 353   VerifyTimerIsStopped();
 354   VerifyPrefFollowsRecommendation(prefs::kSpokenFeedbackEnabled,
 355                                   base::FundamentalValue(false));
 356
 357   VerifyPrefFollowsUser(prefs::kHighContrastEnabled,
 358                         base::FundamentalValue(true));
 359   recommended_prefs_->SetBoolean(prefs::kHighContrastEnabled, false);
 360   VerifyTimerIsStopped();
 361   VerifyPrefFollowsRecommendation(prefs::kHighContrastEnabled,
 362                                   base::FundamentalValue(false));
 363
 364   VerifyPrefFollowsUser(prefs::kScreenMagnifierEnabled,
 365                         base::FundamentalValue(true));
 366   VerifyPrefFollowsUser(prefs::kScreenMagnifierType,
 367                         base::FundamentalValue(ash::MAGNIFIER_FULL));
 368   recommended_prefs_->SetBoolean(prefs::kScreenMagnifierEnabled, false);
 369   recommended_prefs_->SetInteger(prefs::kScreenMagnifierType, 0);
 370   VerifyTimerIsStopped();
 371   VerifyPrefFollowsRecommendation(prefs::kScreenMagnifierEnabled,
 372                                   base::FundamentalValue(false));
 373   VerifyPrefFollowsRecommendation(prefs::kScreenMagnifierType,
 374                                   base::FundamentalValue(0));
 375
 376   VerifyPrefFollowsUser(prefs::kVirtualKeyboardEnabled,
 377                         base::FundamentalValue(true));
 378   recommended_prefs_->SetBoolean(prefs::kVirtualKeyboardEnabled, false);
 379   VerifyTimerIsStopped();
 380   VerifyPrefFollowsRecommendation(prefs::kVirtualKeyboardEnabled,
 381                                   base::FundamentalValue(false));
 382 }
 383
 384 TEST_F(RecommendationRestorerTest, DoNothingOnUserChange) {
 385   // Verifies that if no recommended values have been set and user settings
 386   // change, the user settings are not cleared immediately and no timer is
 387   // started that will clear the user settings eventually.
 388   RegisterLoginProfilePrefs();
 389   CreateLoginProfile();
 390
 391   prefs_->SetBoolean(prefs::kLargeCursorEnabled, true);
 392   VerifyPrefFollowsUser(prefs::kLargeCursorEnabled,
 393                         base::FundamentalValue(true));
 394   VerifyTimerIsStopped();
 395
 396   prefs_->SetBoolean(prefs::kSpokenFeedbackEnabled, true);
 397   VerifyPrefFollowsUser(prefs::kSpokenFeedbackEnabled,
 398                         base::FundamentalValue(true));
 399   VerifyTimerIsStopped();
 400
 401   prefs_->SetBoolean(prefs::kHighContrastEnabled, true);
 402   VerifyPrefFollowsUser(prefs::kHighContrastEnabled,
 403                         base::FundamentalValue(true));
 404   VerifyTimerIsStopped();
 405
 406   prefs_->SetBoolean(prefs::kScreenMagnifierEnabled, true);
 407   VerifyPrefFollowsUser(prefs::kScreenMagnifierEnabled,
 408                         base::FundamentalValue(true));
 409   VerifyTimerIsStopped();
 410
 411   prefs_->SetBoolean(prefs::kScreenMagnifierEnabled, true);
 412   prefs_->SetInteger(prefs::kScreenMagnifierType, ash::MAGNIFIER_FULL);
 413   VerifyPrefFollowsUser(prefs::kScreenMagnifierEnabled,
 414                         base::FundamentalValue(true));
 415   VerifyPrefFollowsUser(prefs::kScreenMagnifierType,
 416                         base::FundamentalValue(ash::MAGNIFIER_FULL));
 417   VerifyTimerIsStopped();
 418
 419   prefs_->SetBoolean(prefs::kVirtualKeyboardEnabled, true);
 420   VerifyPrefFollowsUser(prefs::kVirtualKeyboardEnabled,
 421                         base::FundamentalValue(true));
 422   VerifyTimerIsStopped();
 423 }
 424
 425 TEST_F(RecommendationRestorerTest, RestoreOnUserChange) {
 426   // Verifies that if recommended values have been set and user settings change
 427   // while the login screen is being shown, a timer is started that will clear
 428   // the user settings eventually.
 429   RegisterLoginProfilePrefs();
 430   SetRecommendedValues();
 431
 432   CreateLoginProfile();
 433
 434   VerifyTimerIsStopped();
 435   prefs_->SetBoolean(prefs::kLargeCursorEnabled, true);
 436   VerifyPrefFollowsUser(prefs::kLargeCursorEnabled,
 437                         base::FundamentalValue(true));
 438   VerifyTimerIsRunning();
 439   runner_->RunUntilIdle();
 440   VerifyPrefFollowsRecommendation(prefs::kLargeCursorEnabled,
 441                                   base::FundamentalValue(false));
 442
 443   VerifyTimerIsStopped();
 444   prefs_->SetBoolean(prefs::kSpokenFeedbackEnabled, true);
 445   VerifyPrefFollowsUser(prefs::kSpokenFeedbackEnabled,
 446                         base::FundamentalValue(true));
 447   VerifyTimerIsRunning();
 448   runner_->RunUntilIdle();
 449   VerifyPrefFollowsRecommendation(prefs::kSpokenFeedbackEnabled,
 450                                   base::FundamentalValue(false));
 451
 452   VerifyTimerIsStopped();
 453   prefs_->SetBoolean(prefs::kHighContrastEnabled, true);
 454   VerifyPrefFollowsUser(prefs::kHighContrastEnabled,
 455                         base::FundamentalValue(true));
 456   VerifyTimerIsRunning();
 457   runner_->RunUntilIdle();
 458   VerifyPrefFollowsRecommendation(prefs::kHighContrastEnabled,
 459                                   base::FundamentalValue(false));
 460
 461   VerifyTimerIsStopped();
 462   prefs_->SetBoolean(prefs::kScreenMagnifierEnabled, true);
 463   prefs_->SetInteger(prefs::kScreenMagnifierType, ash::MAGNIFIER_FULL);
 464   VerifyPrefFollowsUser(prefs::kScreenMagnifierEnabled,
 465                         base::FundamentalValue(true));
 466   VerifyPrefFollowsUser(prefs::kScreenMagnifierType,
 467                         base::FundamentalValue(ash::MAGNIFIER_FULL));
 468   VerifyTimerIsRunning();
 469   runner_->RunUntilIdle();
 470   VerifyPrefFollowsRecommendation(prefs::kScreenMagnifierEnabled,
 471                                   base::FundamentalValue(false));
 472   VerifyPrefFollowsRecommendation(prefs::kScreenMagnifierType,
 473                                   base::FundamentalValue(0));
 474
 475   VerifyTimerIsStopped();
 476   prefs_->SetBoolean(prefs::kVirtualKeyboardEnabled, true);
 477   VerifyPrefFollowsUser(prefs::kVirtualKeyboardEnabled,
 478                         base::FundamentalValue(true));
 479   VerifyTimerIsRunning();
 480   runner_->RunUntilIdle();
 481   VerifyPrefFollowsRecommendation(prefs::kVirtualKeyboardEnabled,
 482                                   base::FundamentalValue(false));
 483
 484   VerifyTimerIsStopped();
 485 }
 486
 487 TEST_F(RecommendationRestorerTest, RestoreOnSessionStart) {
 488   // Verifies that if recommended values have been set, user settings have
 489   // changed and a session is then started, the user settings are cleared
 490   // immediately and the timer that would have cleared them eventually on the
 491   // login screen is stopped.
 492   RegisterLoginProfilePrefs();
 493   SetRecommendedValues();
 494
 495   CreateLoginProfile();
 496   SetUserSettings();
 497
 498   NotifyOfSessionStart();
 499   VerifyPrefsFollowRecommendations();
 500   VerifyTimerIsStopped();
 501 }
 502
 503 TEST_F(RecommendationRestorerTest, DoNothingOnSessionStart) {
 504   // Verifies that if recommended values have not been set, user settings have
 505   // changed and a session is then started, the user settings are not cleared
 506   // immediately.
 507   RegisterLoginProfilePrefs();
 508   CreateLoginProfile();
 509   SetUserSettings();
 510
 511   NotifyOfSessionStart();
 512   VerifyPrefsFollowUser();
 513   VerifyTimerIsStopped();
 514 }
 515
 516 TEST_F(RecommendationRestorerTest, UserActivityResetsTimer) {
 517   // Verifies that user activity resets the timer which clears user settings.
 518   RegisterLoginProfilePrefs();
 519
 520   recommended_prefs_->SetBoolean(prefs::kLargeCursorEnabled, false);
 521
 522   CreateLoginProfile();
 523
 524   prefs_->SetBoolean(prefs::kLargeCursorEnabled, true);
 525   VerifyTimerIsRunning();
 526
 527   // Notify that there is user activity, then fast forward until the originally
 528   // set timer fires.
 529   NotifyOfUserActivity();
 530   runner_->RunPendingTasks();
 531   VerifyPrefFollowsUser(prefs::kLargeCursorEnabled,
 532                         base::FundamentalValue(true));
 533
 534   // Fast forward until the reset timer fires.
 535   VerifyTimerIsRunning();
 536   runner_->RunUntilIdle();
 537   VerifyPrefFollowsRecommendation(prefs::kLargeCursorEnabled,
 538                                   base::FundamentalValue(false));
 539   VerifyTimerIsStopped();
 540 }
 541
 542 }  // namespace policy