recommendation_restorer_unittest.cc revision cedac228d2dd51db4b79ea1e72c7f249408ee061 
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/pref_registry/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
32namespace policy {
33
34namespace {
35  // The amount of idle time after which recommended values are restored.
36  const int kRestoreDelayInMs = 60 * 1000;  // 1 minute.
37}  // namespace
38
39class 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
84RecommendationRestorerTest::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
99void RecommendationRestorerTest::SetUp() {
100  testing::Test::SetUp();
101  ASSERT_TRUE(profile_manager_.SetUp());
102}
103
104void RecommendationRestorerTest::RegisterUserProfilePrefs() {
105  chrome::RegisterUserProfilePrefs(prefs_->registry());
106}
107
108void RecommendationRestorerTest::RegisterLoginProfilePrefs() {
109  chrome::RegisterLoginProfilePrefs(prefs_->registry());
110}
111
112void 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
121void 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
130void 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
140void 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
149void 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
156void RecommendationRestorerTest::NotifyOfUserActivity() {
157  ASSERT_TRUE(restorer_);
158  restorer_->OnUserActivity(NULL);
159}
160
161void 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
173void 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
188void 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
201void 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
216void RecommendationRestorerTest::VerifyNotListeningForNotifications() const {
217  ASSERT_TRUE(restorer_);
218  EXPECT_TRUE(restorer_->pref_change_registrar_.IsEmpty());
219  EXPECT_TRUE(restorer_->notification_registrar_.IsEmpty());
220}
221
222void RecommendationRestorerTest::VerifyTimerIsStopped() const {
223  ASSERT_TRUE(restorer_);
224  EXPECT_FALSE(restorer_->restore_timer_.IsRunning());
225}
226
227void 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
234TEST_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
249TEST_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
262TEST_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
275TEST_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
334TEST_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
384TEST_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
425TEST_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
487TEST_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
503TEST_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
516TEST_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
543