Add device policies to control accessibility settings on the login screen

chrome/browser/chromeos/policy/recommendation_restorer_unittest.cc

Index: chrome/browser/chromeos/policy/recommendation_restorer_unittest.cc
diff --git a/chrome/browser/chromeos/policy/recommendation_restorer_unittest.cc b/chrome/browser/chromeos/policy/recommendation_restorer_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..102d730ab51f4c5629b26c144e7cf26cff56e3eb
--- /dev/null
+++ b/chrome/browser/chromeos/policy/recommendation_restorer_unittest.cc
@@ -0,0 +1,647 @@
+// Copyright (c) 2013 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "chrome/browser/chromeos/policy/recommendation_restorer.h"
+
+#include <deque>
+
+#include "ash/magnifier/magnifier_constants.h"
+#include "base/command_line.h"
+#include "base/prefs/pref_notifier_impl.h"
+#include "base/prefs/testing_pref_store.h"
+#include "base/strings/utf_string_conversions.h"
+#include "base/test/test_pending_task.h"
+#include "base/test/test_simple_task_runner.h"
+#include "base/thread_task_runner_handle.h"
+#include "base/time.h"
+#include "base/values.h"
+#include "chrome/browser/chromeos/policy/recommendation_restorer_factory.h"
+#include "chrome/browser/prefs/browser_prefs.h"
+#include "chrome/browser/prefs/pref_service_syncable.h"
+#include "chrome/common/chrome_constants.h"
+#include "chrome/common/chrome_notification_types.h"
+#include "chrome/common/pref_names.h"
+#include "chrome/test/base/testing_browser_process.h"
+#include "chrome/test/base/testing_pref_service_syncable.h"
+#include "chrome/test/base/testing_profile.h"
+#include "chrome/test/base/testing_profile_manager.h"
+#include "chromeos/chromeos_switches.h"
+#include "components/user_prefs/pref_registry_syncable.h"
+#include "content/public/browser/notification_details.h"
+#include "content/public/browser/notification_service.h"
+#include "content/public/browser/notification_source.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace policy {
+
+namespace {
+  // The amount of idle time after which recommended values are restored.
+  const int kRestoreDelayInMs = 60 * 1000;  // 1 minute.
+}  // namespace
+
+class RecommendationRestorerTest : public testing::Test {
+ protected:
+  RecommendationRestorerTest();
+
+  // testing::Test:
+  virtual void SetUp() OVERRIDE;
+  virtual void TearDown() OVERRIDE;
+
+  void CreateLoginProfile();
+  void CreateUserProfile();
+
+  void NotifyOfUserActivity();
+
+  bool DoesRestorerInternalExist() const;
+  bool IsTimerStopped() const;
+  void VerifyTimerIsRunning(bool allow_partial_delay) const;
+
+  TestingPrefStore* recommended_prefs_;  // Not owned.
+  TestingPrefServiceSyncable* prefs_;    // Not owned.
+  RecommendationRestorer* restorer_;     // Not owned.
+
+  scoped_refptr<base::TestSimpleTaskRunner> runner_;
+  base::ThreadTaskRunnerHandle runner_handler_;
+
+ private:
+  scoped_ptr<PrefServiceSyncable> prefs_owner_;
+
+  TestingProfileManager* profile_manager_;  // Not owned.
+
+  DISALLOW_COPY_AND_ASSIGN(RecommendationRestorerTest);
+};
+
+RecommendationRestorerTest::RecommendationRestorerTest()
+    : recommended_prefs_(new TestingPrefStore),
+      prefs_(new TestingPrefServiceSyncable(
+          new TestingPrefStore,
+          new TestingPrefStore,
+          recommended_prefs_,
+          new user_prefs::PrefRegistrySyncable,
+          new PrefNotifierImpl)),
+      restorer_(NULL),
+      runner_(new base::TestSimpleTaskRunner),
+      runner_handler_(runner_),
+      prefs_owner_(prefs_),
+      profile_manager_(NULL) {
+  chrome::RegisterUserPrefs(prefs_->registry());
+}
+
+void RecommendationRestorerTest::SetUp() {
+  testing::Test::SetUp();
+  profile_manager_ =
+      new TestingProfileManager(TestingBrowserProcess::GetGlobal());
+  ASSERT_TRUE(profile_manager_->SetUp());
+}
+
+void RecommendationRestorerTest::TearDown() {
+  TestingBrowserProcess::GetGlobal()->SetLocalState(NULL);
+  testing::Test::TearDown();
+}
+
+void RecommendationRestorerTest::CreateLoginProfile() {
+  ASSERT_FALSE(restorer_);
+  TestingProfile* profile = profile_manager_->CreateTestingProfile(
+      chrome::kInitialProfile, prefs_owner_.Pass(),
+      UTF8ToUTF16(chrome::kInitialProfile), 0);
+  restorer_ = RecommendationRestorerFactory::GetForProfile(profile);
+}
+
+void RecommendationRestorerTest::CreateUserProfile() {
+  ASSERT_FALSE(restorer_);
+  TestingProfile* profile = profile_manager_->CreateTestingProfile(
+      "user", prefs_owner_.Pass(), UTF8ToUTF16("user"), 0);
+  restorer_ = RecommendationRestorerFactory::GetForProfile(profile);
+}
+
+void RecommendationRestorerTest::NotifyOfUserActivity() {
+  ASSERT_TRUE(restorer_);
+  ASSERT_TRUE(restorer_->recommendation_restorer_internal_);
+  restorer_->recommendation_restorer_internal_->OnUserActivity();
+}
+
+bool RecommendationRestorerTest::DoesRestorerInternalExist() const {
+  return restorer_ && restorer_->recommendation_restorer_internal_;
+}
+
+bool RecommendationRestorerTest::IsTimerStopped() const {
+  return runner_->GetPendingTasks().empty();
+}
+
+void RecommendationRestorerTest::VerifyTimerIsRunning(
+    bool allow_partial_delay) const {
+  const std::deque<base::TestPendingTask>& tasks = runner_->GetPendingTasks();
+  ASSERT_EQ(1u, tasks.size());
+  if (allow_partial_delay) {
+    EXPECT_GE(base::TimeDelta::FromMilliseconds(kRestoreDelayInMs),
+              tasks.front().delay);
+  } else {
+    EXPECT_EQ(base::TimeDelta::FromMilliseconds(kRestoreDelayInMs),
+              tasks.front().delay);
+  }
+}
+
+TEST_F(RecommendationRestorerTest, CreateForLoginProfileOnLoginScreen) {
+  // Verifies that when a RecommendationRestorer is created for the login
+  // profile on the login screen, a RecommendationRestorerInternal is created
+  // and subsequently destroyed when a user session starts.
+  CommandLine::ForCurrentProcess()->AppendSwitch(
+      chromeos::switches::kLoginManager);
+  CreateLoginProfile();
+  ASSERT_TRUE(restorer_);
+  EXPECT_TRUE(DoesRestorerInternalExist());
+
+  restorer_->Observe(
+      chrome::NOTIFICATION_LOGIN_USER_CHANGED,
+      content::Source<RecommendationRestorerTest>(this),
+      content::NotificationService::NoDetails());
+  EXPECT_FALSE(DoesRestorerInternalExist());
+}
+
+TEST_F(RecommendationRestorerTest, CreateForLoginProfileInSession) {
+  // Verifies that when a RecommendationRestorer is created for the login
+  // profile during a user session (i.e. during a browser restart after a
+  // crash), no RecommendationRestorerInternal is created.
+  CreateLoginProfile();
+  EXPECT_TRUE(restorer_);
+  EXPECT_FALSE(DoesRestorerInternalExist());
+}
+
+TEST_F(RecommendationRestorerTest, CreateForUserProfileOnLoginScreen) {
+  // Verifies that when a RecommendationRestorer is created for a user profile
+  // on the login screen, no RecommendationRestorerInternal is created.
+  CommandLine::ForCurrentProcess()->AppendSwitch(
+      chromeos::switches::kLoginManager);
+  CreateUserProfile();
+  EXPECT_TRUE(restorer_);
+  EXPECT_FALSE(DoesRestorerInternalExist());
+}
+
+TEST_F(RecommendationRestorerTest, CreateForUserProfileInSession) {
+  // Verifies that when a RecommendationRestorer is created for a user profile
+  // during a user session, no RecommendationRestorerInternal is created.
+  CreateUserProfile();
+  EXPECT_TRUE(restorer_);
+  EXPECT_FALSE(DoesRestorerInternalExist());
+}
+
+TEST_F(RecommendationRestorerTest, NoRecommendations) {
+  // Verifies that if no recommended values have been set, user settings are not
+  // cleared when the RecommendationRestorer is instantiated.
+  prefs_->SetBoolean(prefs::kLargeCursorEnabled, true);
+  prefs_->SetBoolean(prefs::kSpokenFeedbackEnabled, true);
+  prefs_->SetBoolean(prefs::kHighContrastEnabled, true);
+  prefs_->SetBoolean(prefs::kScreenMagnifierEnabled, true);
+  prefs_->SetInteger(prefs::kScreenMagnifierType, ash::MAGNIFIER_FULL);
+
+  CommandLine::ForCurrentProcess()->AppendSwitch(
+      chromeos::switches::kLoginManager);
+  CreateLoginProfile();
+  EXPECT_TRUE(DoesRestorerInternalExist());
+
+  const PrefServiceSyncable::Preference* pref =
+      prefs_->FindPreference(prefs::kLargeCursorEnabled);
+  ASSERT_TRUE(pref);
+  EXPECT_TRUE(pref->HasUserSetting());
+  const base::Value* value = pref->GetValue();
+  ASSERT_TRUE(value);
+  EXPECT_TRUE(base::FundamentalValue(true).Equals(value));
+
+  pref = prefs_->FindPreference(prefs::kSpokenFeedbackEnabled);
+  ASSERT_TRUE(pref);
+  EXPECT_TRUE(pref->HasUserSetting());
+  value = pref->GetValue();
+  ASSERT_TRUE(value);
+  EXPECT_TRUE(base::FundamentalValue(true).Equals(value));
+
+  pref = prefs_->FindPreference(prefs::kHighContrastEnabled);
+  ASSERT_TRUE(pref);
+  EXPECT_TRUE(pref->HasUserSetting());
+  value = pref->GetValue();
+  ASSERT_TRUE(value);
+  EXPECT_TRUE(base::FundamentalValue(true).Equals(value));
+
+  pref = prefs_->FindPreference(prefs::kScreenMagnifierEnabled);
+  ASSERT_TRUE(pref);
+  EXPECT_TRUE(pref->HasUserSetting());
+  value = pref->GetValue();
+  ASSERT_TRUE(value);
+  EXPECT_TRUE(base::FundamentalValue(true).Equals(value));
+
+  pref = prefs_->FindPreference(prefs::kScreenMagnifierType);
+  ASSERT_TRUE(pref);
+  EXPECT_TRUE(pref->HasUserSetting());
+  value = pref->GetValue();
+  ASSERT_TRUE(value);
+  EXPECT_TRUE(base::FundamentalValue(ash::MAGNIFIER_FULL).Equals(value));
+
+  EXPECT_TRUE(IsTimerStopped());
+}
+
+TEST_F(RecommendationRestorerTest, RestoreOnStartup) {
+  // Verifies that if recommended values have been set, user settings are
+  // cleared when the RecommendationRestorer is instantiated.
+  recommended_prefs_->SetBoolean(prefs::kLargeCursorEnabled, false);
+  recommended_prefs_->SetBoolean(prefs::kSpokenFeedbackEnabled, false);
+  recommended_prefs_->SetBoolean(prefs::kHighContrastEnabled, false);
+  recommended_prefs_->SetBoolean(prefs::kScreenMagnifierEnabled, false);
+  recommended_prefs_->SetInteger(prefs::kScreenMagnifierType, 0);
+
+  prefs_->SetBoolean(prefs::kLargeCursorEnabled, true);
+  prefs_->SetBoolean(prefs::kSpokenFeedbackEnabled, true);
+  prefs_->SetBoolean(prefs::kHighContrastEnabled, true);
+  prefs_->SetBoolean(prefs::kScreenMagnifierEnabled, true);
+  prefs_->SetInteger(prefs::kScreenMagnifierType, ash::MAGNIFIER_FULL);
+
+  CommandLine::ForCurrentProcess()->AppendSwitch(
+      chromeos::switches::kLoginManager);
+  CreateLoginProfile();
+  EXPECT_TRUE(DoesRestorerInternalExist());
+
+  const PrefServiceSyncable::Preference* pref =
+      prefs_->FindPreference(prefs::kLargeCursorEnabled);
+  ASSERT_TRUE(pref);
+  EXPECT_TRUE(pref->IsRecommended());
+  EXPECT_FALSE(pref->HasUserSetting());
+  const base::Value* value = pref->GetValue();
+  ASSERT_TRUE(value);
+  EXPECT_TRUE(base::FundamentalValue(false).Equals(value));
+
+  pref = prefs_->FindPreference(prefs::kSpokenFeedbackEnabled);
+  ASSERT_TRUE(pref);
+  EXPECT_TRUE(pref->IsRecommended());
+  EXPECT_FALSE(pref->HasUserSetting());
+  value = pref->GetValue();
+  ASSERT_TRUE(value);
+  EXPECT_TRUE(base::FundamentalValue(false).Equals(value));
+
+  pref = prefs_->FindPreference(prefs::kHighContrastEnabled);
+  ASSERT_TRUE(pref);
+  EXPECT_TRUE(pref->IsRecommended());
+  EXPECT_FALSE(pref->HasUserSetting());
+  value = pref->GetValue();
+  ASSERT_TRUE(value);
+  EXPECT_TRUE(base::FundamentalValue(false).Equals(value));
+
+  pref = prefs_->FindPreference(prefs::kScreenMagnifierEnabled);
+  ASSERT_TRUE(pref);
+  EXPECT_TRUE(pref->IsRecommended());
+  EXPECT_FALSE(pref->HasUserSetting());
+  value = pref->GetValue();
+  ASSERT_TRUE(value);
+  EXPECT_TRUE(base::FundamentalValue(false).Equals(value));
+
+  pref = prefs_->FindPreference(prefs::kScreenMagnifierType);
+  ASSERT_TRUE(pref);
+  EXPECT_TRUE(pref->IsRecommended());
+  EXPECT_FALSE(pref->HasUserSetting());
+  value = pref->GetValue();
+  ASSERT_TRUE(value);
+  EXPECT_TRUE(base::FundamentalValue(0).Equals(value));
+
+  EXPECT_TRUE(IsTimerStopped());
+}
+
+TEST_F(RecommendationRestorerTest, RestoreOnRecommendationChange) {
+  // Verifies that if recommended values change, user settings are cleared
+  // immediately when the RecommendationRestorer is running.
+  prefs_->SetBoolean(prefs::kLargeCursorEnabled, true);
+  prefs_->SetBoolean(prefs::kSpokenFeedbackEnabled, true);
+  prefs_->SetBoolean(prefs::kHighContrastEnabled, true);
+  prefs_->SetBoolean(prefs::kScreenMagnifierEnabled, true);
+  prefs_->SetInteger(prefs::kScreenMagnifierType, ash::MAGNIFIER_FULL);
+
+  CommandLine::ForCurrentProcess()->AppendSwitch(
+      chromeos::switches::kLoginManager);
+  CreateLoginProfile();
+  EXPECT_TRUE(DoesRestorerInternalExist());
+
+  const PrefServiceSyncable::Preference* pref =
+      prefs_->FindPreference(prefs::kLargeCursorEnabled);
+  ASSERT_TRUE(pref);
+  EXPECT_TRUE(pref->HasUserSetting());
+  const base::Value* value = pref->GetValue();
+  ASSERT_TRUE(value);
+  EXPECT_TRUE(base::FundamentalValue(true).Equals(value));
+
+  pref = prefs_->FindPreference(prefs::kSpokenFeedbackEnabled);
+  ASSERT_TRUE(pref);
+  EXPECT_TRUE(pref->HasUserSetting());
+  value = pref->GetValue();
+  ASSERT_TRUE(value);
+  EXPECT_TRUE(base::FundamentalValue(true).Equals(value));
+
+  pref = prefs_->FindPreference(prefs::kHighContrastEnabled);
+  ASSERT_TRUE(pref);
+  EXPECT_TRUE(pref->HasUserSetting());
+  value = pref->GetValue();
+  ASSERT_TRUE(value);
+  EXPECT_TRUE(base::FundamentalValue(true).Equals(value));
+
+  pref = prefs_->FindPreference(prefs::kScreenMagnifierEnabled);
+  ASSERT_TRUE(pref);
+  EXPECT_TRUE(pref->HasUserSetting());
+  value = pref->GetValue();
+  ASSERT_TRUE(value);
+  EXPECT_TRUE(base::FundamentalValue(true).Equals(value));
+
+  pref = prefs_->FindPreference(prefs::kScreenMagnifierType);
+  ASSERT_TRUE(pref);
+  EXPECT_TRUE(pref->HasUserSetting());
+  value = pref->GetValue();
+  ASSERT_TRUE(value);
+  EXPECT_TRUE(base::FundamentalValue(ash::MAGNIFIER_FULL).Equals(value));
+
+  EXPECT_TRUE(IsTimerStopped());
+
+  recommended_prefs_->SetBoolean(prefs::kLargeCursorEnabled, false);
+
+  pref = prefs_->FindPreference(prefs::kLargeCursorEnabled);
+  ASSERT_TRUE(pref);
+  EXPECT_TRUE(pref->IsRecommended());
+  EXPECT_FALSE(pref->HasUserSetting());
+  value = pref->GetValue();
+  ASSERT_TRUE(value);
+  EXPECT_TRUE(base::FundamentalValue(false).Equals(value));
+
+  EXPECT_TRUE(IsTimerStopped());
+
+  recommended_prefs_->SetBoolean(prefs::kSpokenFeedbackEnabled, false);
+
+  pref = prefs_->FindPreference(prefs::kSpokenFeedbackEnabled);
+  ASSERT_TRUE(pref);
+  EXPECT_TRUE(pref->IsRecommended());
+  EXPECT_FALSE(pref->HasUserSetting());
+  value = pref->GetValue();
+  ASSERT_TRUE(value);
+  EXPECT_TRUE(base::FundamentalValue(false).Equals(value));
+
+  EXPECT_TRUE(IsTimerStopped());
+
+  recommended_prefs_->SetBoolean(prefs::kHighContrastEnabled, false);
+
+  pref = prefs_->FindPreference(prefs::kHighContrastEnabled);
+  ASSERT_TRUE(pref);
+  EXPECT_TRUE(pref->IsRecommended());
+  EXPECT_FALSE(pref->HasUserSetting());
+  value = pref->GetValue();
+  ASSERT_TRUE(value);
+  EXPECT_TRUE(base::FundamentalValue(false).Equals(value));
+
+  EXPECT_TRUE(IsTimerStopped());
+
+  recommended_prefs_->SetBoolean(prefs::kScreenMagnifierEnabled, false);
+  recommended_prefs_->SetInteger(prefs::kScreenMagnifierType, 0);
+
+  pref = prefs_->FindPreference(prefs::kScreenMagnifierEnabled);
+  ASSERT_TRUE(pref);
+  EXPECT_TRUE(pref->IsRecommended());
+  EXPECT_FALSE(pref->HasUserSetting());
+  value = pref->GetValue();
+  ASSERT_TRUE(value);
+  EXPECT_TRUE(base::FundamentalValue(false).Equals(value));
+
+  pref = prefs_->FindPreference(prefs::kScreenMagnifierType);
+  ASSERT_TRUE(pref);
+  EXPECT_TRUE(pref->IsRecommended());
+  EXPECT_FALSE(pref->HasUserSetting());
+  value = pref->GetValue();
+  ASSERT_TRUE(value);
+  EXPECT_TRUE(base::FundamentalValue(0).Equals(value));
+
+  EXPECT_TRUE(IsTimerStopped());
+}
+
+TEST_F(RecommendationRestorerTest, DoNothingOnUserChange) {
+  // Verifies that if no recommended values have been set and user settings
+  // change, they are not cleared whenthe RecommendationRestorer is running.
+  CommandLine::ForCurrentProcess()->AppendSwitch(
+      chromeos::switches::kLoginManager);
+  CreateLoginProfile();
+  EXPECT_TRUE(DoesRestorerInternalExist());
+
+  EXPECT_TRUE(IsTimerStopped());
+
+  prefs_->SetBoolean(prefs::kLargeCursorEnabled, true);
+  const PrefServiceSyncable::Preference* pref =
+      prefs_->FindPreference(prefs::kLargeCursorEnabled);
+  ASSERT_TRUE(pref);
+  EXPECT_TRUE(pref->HasUserSetting());
+  const base::Value* value = pref->GetValue();
+  ASSERT_TRUE(value);
+  EXPECT_TRUE(base::FundamentalValue(true).Equals(value));
+
+  EXPECT_TRUE(IsTimerStopped());
+
+  prefs_->SetBoolean(prefs::kSpokenFeedbackEnabled, true);
+  pref = prefs_->FindPreference(prefs::kSpokenFeedbackEnabled);
+  ASSERT_TRUE(pref);
+  EXPECT_TRUE(pref->HasUserSetting());
+  value = pref->GetValue();
+  ASSERT_TRUE(value);
+  EXPECT_TRUE(base::FundamentalValue(true).Equals(value));
+
+  EXPECT_TRUE(IsTimerStopped());
+
+  prefs_->SetBoolean(prefs::kHighContrastEnabled, true);
+  pref = prefs_->FindPreference(prefs::kHighContrastEnabled);
+  ASSERT_TRUE(pref);
+  EXPECT_TRUE(pref->HasUserSetting());
+  value = pref->GetValue();
+  ASSERT_TRUE(value);
+  EXPECT_TRUE(base::FundamentalValue(true).Equals(value));
+
+  EXPECT_TRUE(IsTimerStopped());
+
+  prefs_->SetBoolean(prefs::kScreenMagnifierEnabled, true);
+  pref = prefs_->FindPreference(prefs::kScreenMagnifierEnabled);
+  ASSERT_TRUE(pref);
+  EXPECT_TRUE(pref->HasUserSetting());
+  value = pref->GetValue();
+  ASSERT_TRUE(value);
+  EXPECT_TRUE(base::FundamentalValue(true).Equals(value));
+
+  EXPECT_TRUE(IsTimerStopped());
+
+  prefs_->SetInteger(prefs::kScreenMagnifierType, ash::MAGNIFIER_FULL);
+  pref = prefs_->FindPreference(prefs::kScreenMagnifierType);
+  ASSERT_TRUE(pref);
+  EXPECT_TRUE(pref->HasUserSetting());
+  value = pref->GetValue();
+  ASSERT_TRUE(value);
+  EXPECT_TRUE(base::FundamentalValue(ash::MAGNIFIER_FULL).Equals(value));
+
+  EXPECT_TRUE(IsTimerStopped());
+
+  EXPECT_TRUE(IsTimerStopped());
+}
+
+TEST_F(RecommendationRestorerTest, RunTimerAndRestoreOnUserChange) {
+  // Verifies that if recommended values have been set and user settings
+  // change, a timer is started and the user settings are cleared after one
+  // minute.
+  recommended_prefs_->SetBoolean(prefs::kLargeCursorEnabled, false);
+  recommended_prefs_->SetBoolean(prefs::kSpokenFeedbackEnabled, false);
+  recommended_prefs_->SetBoolean(prefs::kHighContrastEnabled, false);
+  recommended_prefs_->SetBoolean(prefs::kScreenMagnifierEnabled, false);
+  recommended_prefs_->SetInteger(prefs::kScreenMagnifierType, 0);
+
+  CommandLine::ForCurrentProcess()->AppendSwitch(
+      chromeos::switches::kLoginManager);
+  CreateLoginProfile();
+  EXPECT_TRUE(DoesRestorerInternalExist());
+
+  EXPECT_TRUE(IsTimerStopped());
+
+  prefs_->SetBoolean(prefs::kLargeCursorEnabled, true);
+  const PrefServiceSyncable::Preference* pref =
+      prefs_->FindPreference(prefs::kLargeCursorEnabled);
+  ASSERT_TRUE(pref);
+  EXPECT_TRUE(pref->HasUserSetting());
+  const base::Value* value = pref->GetValue();
+  ASSERT_TRUE(value);
+  EXPECT_TRUE(base::FundamentalValue(true).Equals(value));
+
+  VerifyTimerIsRunning(false);
+  runner_->RunPendingTasks();
+
+  pref = prefs_->FindPreference(prefs::kLargeCursorEnabled);
+  ASSERT_TRUE(pref);
+  EXPECT_TRUE(pref->IsRecommended());
+  EXPECT_FALSE(pref->HasUserSetting());
+  value = pref->GetValue();
+  ASSERT_TRUE(value);
+  EXPECT_TRUE(base::FundamentalValue(false).Equals(value));
+
+  EXPECT_TRUE(IsTimerStopped());
+
+  prefs_->SetBoolean(prefs::kSpokenFeedbackEnabled, true);
+  pref = prefs_->FindPreference(prefs::kSpokenFeedbackEnabled);
+  ASSERT_TRUE(pref);
+  EXPECT_TRUE(pref->HasUserSetting());
+  value = pref->GetValue();
+  ASSERT_TRUE(value);
+  EXPECT_TRUE(base::FundamentalValue(true).Equals(value));
+
+  VerifyTimerIsRunning(false);
+  runner_->RunPendingTasks();
+
+  pref = prefs_->FindPreference(prefs::kSpokenFeedbackEnabled);
+  ASSERT_TRUE(pref);
+  EXPECT_TRUE(pref->IsRecommended());
+  EXPECT_FALSE(pref->HasUserSetting());
+  value = pref->GetValue();
+  ASSERT_TRUE(value);
+  EXPECT_TRUE(base::FundamentalValue(false).Equals(value));
+
+  EXPECT_TRUE(IsTimerStopped());
+
+  prefs_->SetBoolean(prefs::kHighContrastEnabled, true);
+  pref = prefs_->FindPreference(prefs::kHighContrastEnabled);
+  ASSERT_TRUE(pref);
+  EXPECT_TRUE(pref->HasUserSetting());
+  value = pref->GetValue();
+  ASSERT_TRUE(value);
+  EXPECT_TRUE(base::FundamentalValue(true).Equals(value));
+
+  VerifyTimerIsRunning(false);
+  runner_->RunPendingTasks();
+
+  pref = prefs_->FindPreference(prefs::kHighContrastEnabled);
+  ASSERT_TRUE(pref);
+  EXPECT_TRUE(pref->IsRecommended());
+  EXPECT_FALSE(pref->HasUserSetting());
+  value = pref->GetValue();
+  ASSERT_TRUE(value);
+  EXPECT_TRUE(base::FundamentalValue(false).Equals(value));
+
+  EXPECT_TRUE(IsTimerStopped());
+
+  prefs_->SetBoolean(prefs::kScreenMagnifierEnabled, true);
+  pref = prefs_->FindPreference(prefs::kScreenMagnifierEnabled);
+  ASSERT_TRUE(pref);
+  EXPECT_TRUE(pref->HasUserSetting());
+  value = pref->GetValue();
+  ASSERT_TRUE(value);
+  EXPECT_TRUE(base::FundamentalValue(true).Equals(value));
+
+  VerifyTimerIsRunning(false);
+  runner_->RunPendingTasks();
+
+  pref = prefs_->FindPreference(prefs::kScreenMagnifierEnabled);
+  ASSERT_TRUE(pref);
+  EXPECT_TRUE(pref->IsRecommended());
+  EXPECT_FALSE(pref->HasUserSetting());
+  value = pref->GetValue();
+  ASSERT_TRUE(value);
+  EXPECT_TRUE(base::FundamentalValue(false).Equals(value));
+
+  EXPECT_TRUE(IsTimerStopped());
+
+  prefs_->SetInteger(prefs::kScreenMagnifierType, ash::MAGNIFIER_FULL);
+  pref = prefs_->FindPreference(prefs::kScreenMagnifierType);
+  ASSERT_TRUE(pref);
+  EXPECT_TRUE(pref->HasUserSetting());
+  value = pref->GetValue();
+  ASSERT_TRUE(value);
+  EXPECT_TRUE(base::FundamentalValue(ash::MAGNIFIER_FULL).Equals(value));
+
+  VerifyTimerIsRunning(false);
+  runner_->RunPendingTasks();
+
+  pref = prefs_->FindPreference(prefs::kScreenMagnifierType);
+  ASSERT_TRUE(pref);
+  EXPECT_TRUE(pref->IsRecommended());
+  EXPECT_FALSE(pref->HasUserSetting());
+  value = pref->GetValue();
+  ASSERT_TRUE(value);
+  EXPECT_TRUE(base::FundamentalValue(0).Equals(value));
+
+  EXPECT_TRUE(IsTimerStopped());
+}
+
+TEST_F(RecommendationRestorerTest, UserActivityResetsTimer) {
+  // Verifies that user activity resets the timer which clears user settings.
+  recommended_prefs_->SetBoolean(prefs::kLargeCursorEnabled, false);
+
+  CommandLine::ForCurrentProcess()->AppendSwitch(
+      chromeos::switches::kLoginManager);
+  CreateLoginProfile();
+  EXPECT_TRUE(DoesRestorerInternalExist());
+
+  prefs_->SetBoolean(prefs::kLargeCursorEnabled, true);
+
+  VerifyTimerIsRunning(false);
+
+  // Notify that there is user activity, then fast forward until the originally
+  // set timer fires.
+  NotifyOfUserActivity();
+  runner_->RunPendingTasks();
+
+  // Verify that the user setting has not been cleared yet.
+  const PrefServiceSyncable::Preference* pref =
+      prefs_->FindPreference(prefs::kLargeCursorEnabled);
+  ASSERT_TRUE(pref);
+  EXPECT_TRUE(pref->HasUserSetting());
+  const base::Value* value = pref->GetValue();
+  ASSERT_TRUE(value);
+  EXPECT_TRUE(base::FundamentalValue(true).Equals(value));
+
+  // Fast forward until the reset timer fires.
+  VerifyTimerIsRunning(true);
+  runner_->RunPendingTasks();
+
+  // Verify that the user setting has been cleared now.
+  pref = prefs_->FindPreference(prefs::kLargeCursorEnabled);
+  ASSERT_TRUE(pref);
+  EXPECT_TRUE(pref->IsRecommended());
+  EXPECT_FALSE(pref->HasUserSetting());
+  value = pref->GetValue();
+  ASSERT_TRUE(value);
+  EXPECT_TRUE(base::FundamentalValue(false).Equals(value));
+
+  EXPECT_TRUE(IsTimerStopped());
+}
+
+}  // namespace policy