1// Copyright (c) 2012 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/session_length_limiter.h"
6
7#include <queue>
8#include <utility>
9#include <vector>
10
11#include "base/callback.h"
12#include "base/compiler_specific.h"
13#include "base/location.h"
14#include "base/logging.h"
15#include "base/memory/ref_counted.h"
16#include "base/memory/scoped_ptr.h"
17#include "base/prefs/testing_pref_service.h"
18#include "base/single_thread_task_runner.h"
19#include "base/strings/string_number_conversions.h"
20#include "base/thread_task_runner_handle.h"
21#include "base/values.h"
22#include "chrome/common/pref_names.h"
23#include "chrome/test/base/testing_browser_process.h"
24#include "testing/gmock/include/gmock/gmock.h"
25#include "testing/gtest/include/gtest/gtest.h"
26
27using ::testing::Invoke;
28using ::testing::Mock;
29using ::testing::NiceMock;
30
31namespace chromeos {
32
33namespace {
34
35class MockSessionLengthLimiterDelegate : public SessionLengthLimiter::Delegate {
36 public:
37  MOCK_CONST_METHOD0(GetCurrentTime, const base::TimeTicks(void));
38  MOCK_METHOD0(StopSession, void(void));
39};
40
41// A SingleThreadTaskRunner that mocks the current time and allows it to be
42// fast-forwarded.
43class MockTimeSingleThreadTaskRunner : public base::SingleThreadTaskRunner {
44 public:
45  MockTimeSingleThreadTaskRunner();
46
47  // base::SingleThreadTaskRunner:
48  virtual bool RunsTasksOnCurrentThread() const OVERRIDE;
49  virtual bool PostDelayedTask(const tracked_objects::Location& from_here,
50                               const base::Closure& task,
51                               base::TimeDelta delay) OVERRIDE;
52  virtual bool PostNonNestableDelayedTask(
53      const tracked_objects::Location& from_here,
54      const base::Closure& task,
55      base::TimeDelta delay) OVERRIDE;
56
57  const base::TimeTicks& GetCurrentTime() const;
58
59  void FastForwardBy(const base::TimeDelta& time_delta);
60  void FastForwardUntilNoTasksRemain();
61
62 private:
63  // Strict weak temporal ordering of tasks.
64  class TemporalOrder {
65   public:
66    bool operator()(
67        const std::pair<base::TimeTicks, base::Closure>& first_task,
68        const std::pair<base::TimeTicks, base::Closure>& second_task) const;
69  };
70
71  virtual ~MockTimeSingleThreadTaskRunner();
72
73  base::TimeTicks now_;
74  std::priority_queue<std::pair<base::TimeTicks, base::Closure>,
75                      std::vector<std::pair<base::TimeTicks, base::Closure> >,
76                      TemporalOrder> tasks_;
77};
78
79}  // namespace
80
81class SessionLengthLimiterTest : public testing::Test {
82 protected:
83  SessionLengthLimiterTest();
84
85  // testing::Test:
86  virtual void SetUp() OVERRIDE;
87  virtual void TearDown() OVERRIDE;
88
89  void SetSessionUserActivitySeenPref(bool user_activity_seen);
90  void ClearSessionUserActivitySeenPref();
91  bool IsSessionUserActivitySeenPrefSet();
92  bool GetSessionUserActivitySeenPref();
93
94  void SetSessionStartTimePref(const base::TimeTicks& session_start_time);
95  void ClearSessionStartTimePref();
96  bool IsSessionStartTimePrefSet();
97  base::TimeTicks GetSessionStartTimePref();
98
99  void SetSessionLengthLimitPref(const base::TimeDelta& session_length_limit);
100  void ClearSessionLengthLimitPref();
101
102  void SetWaitForInitialUserActivityPref(bool wait_for_initial_user_activity);
103
104  void SimulateUserActivity();
105
106  void UpdateSessionStartTimeIfWaitingForUserActivity();
107
108  void ExpectStopSession();
109  void SaveSessionStopTime();
110
111  // Clears the session state by resetting |user_activity_| and
112  // |session_start_time_| and creates a new SessionLengthLimiter.
113  void CreateSessionLengthLimiter(bool browser_restarted);
114
115  void DestroySessionLengthLimiter();
116
117  scoped_refptr<MockTimeSingleThreadTaskRunner> runner_;
118  base::TimeTicks session_start_time_;
119  base::TimeTicks session_stop_time_;
120
121 private:
122  TestingPrefServiceSimple local_state_;
123  bool user_activity_seen_;
124
125  MockSessionLengthLimiterDelegate* delegate_;  // Owned by
126                                                // session_length_limiter_.
127  scoped_ptr<SessionLengthLimiter> session_length_limiter_;
128};
129
130MockTimeSingleThreadTaskRunner::MockTimeSingleThreadTaskRunner()
131    : now_(base::TimeTicks::FromInternalValue(1000)) {
132}
133
134bool MockTimeSingleThreadTaskRunner::RunsTasksOnCurrentThread() const {
135  return true;
136}
137
138bool MockTimeSingleThreadTaskRunner::PostDelayedTask(
139    const tracked_objects::Location& from_here,
140    const base::Closure& task,
141    base::TimeDelta delay) {
142  tasks_.push(std::pair<base::TimeTicks, base::Closure>(now_ + delay, task));
143  return true;
144}
145
146bool MockTimeSingleThreadTaskRunner::PostNonNestableDelayedTask(
147    const tracked_objects::Location& from_here,
148    const base::Closure& task,
149    base::TimeDelta delay) {
150  NOTREACHED();
151  return false;
152}
153
154const base::TimeTicks& MockTimeSingleThreadTaskRunner::GetCurrentTime() const {
155  return now_;
156}
157
158void MockTimeSingleThreadTaskRunner::FastForwardBy(
159    const base::TimeDelta& time_delta) {
160  const base::TimeTicks latest = now_ + time_delta;
161  while (!tasks_.empty() && tasks_.top().first <= latest) {
162    now_ = tasks_.top().first;
163    base::Closure task = tasks_.top().second;
164    tasks_.pop();
165    task.Run();
166  }
167  now_ = latest;
168}
169
170void MockTimeSingleThreadTaskRunner::FastForwardUntilNoTasksRemain() {
171  while (!tasks_.empty()) {
172    now_ = tasks_.top().first;
173    base::Closure task = tasks_.top().second;
174    tasks_.pop();
175    task.Run();
176  }
177}
178
179bool MockTimeSingleThreadTaskRunner::TemporalOrder::operator()(
180    const std::pair<base::TimeTicks, base::Closure>& first_task,
181    const std::pair<base::TimeTicks, base::Closure>& second_task) const {
182  return first_task.first > second_task.first;
183}
184
185MockTimeSingleThreadTaskRunner::~MockTimeSingleThreadTaskRunner() {
186}
187
188SessionLengthLimiterTest::SessionLengthLimiterTest()
189    : user_activity_seen_(false),
190      delegate_(NULL) {
191}
192
193void SessionLengthLimiterTest::SetUp() {
194  TestingBrowserProcess::GetGlobal()->SetLocalState(&local_state_);
195  SessionLengthLimiter::RegisterPrefs(local_state_.registry());
196  runner_ = new MockTimeSingleThreadTaskRunner;
197}
198
199void SessionLengthLimiterTest::TearDown() {
200  session_length_limiter_.reset();
201  TestingBrowserProcess::GetGlobal()->SetLocalState(NULL);
202}
203
204void SessionLengthLimiterTest::SetSessionUserActivitySeenPref(
205    bool user_activity_seen) {
206  local_state_.SetUserPref(prefs::kSessionUserActivitySeen,
207                           new base::FundamentalValue(user_activity_seen));
208}
209
210void SessionLengthLimiterTest::ClearSessionUserActivitySeenPref() {
211  local_state_.ClearPref(prefs::kSessionUserActivitySeen);
212}
213
214bool SessionLengthLimiterTest::IsSessionUserActivitySeenPrefSet() {
215  return local_state_.HasPrefPath(prefs::kSessionUserActivitySeen);
216}
217
218bool SessionLengthLimiterTest::GetSessionUserActivitySeenPref() {
219  EXPECT_TRUE(IsSessionUserActivitySeenPrefSet());
220  return local_state_.GetBoolean(prefs::kSessionUserActivitySeen);
221}
222
223void SessionLengthLimiterTest::SetSessionStartTimePref(
224    const base::TimeTicks& session_start_time) {
225  local_state_.SetUserPref(
226      prefs::kSessionStartTime,
227      new base::StringValue(
228          base::Int64ToString(session_start_time.ToInternalValue())));
229}
230
231void SessionLengthLimiterTest::ClearSessionStartTimePref() {
232  local_state_.ClearPref(prefs::kSessionStartTime);
233}
234
235bool SessionLengthLimiterTest::IsSessionStartTimePrefSet() {
236  return local_state_.HasPrefPath(prefs::kSessionStartTime);
237}
238
239base::TimeTicks SessionLengthLimiterTest::GetSessionStartTimePref() {
240  EXPECT_TRUE(IsSessionStartTimePrefSet());
241  return base::TimeTicks::FromInternalValue(
242      local_state_.GetInt64(prefs::kSessionStartTime));
243}
244
245void SessionLengthLimiterTest::SetSessionLengthLimitPref(
246    const base::TimeDelta& session_length_limit) {
247  local_state_.SetUserPref(prefs::kSessionLengthLimit,
248      new base::FundamentalValue(
249          static_cast<int>(session_length_limit.InMilliseconds())));
250  UpdateSessionStartTimeIfWaitingForUserActivity();
251}
252
253void SessionLengthLimiterTest::ClearSessionLengthLimitPref() {
254  local_state_.RemoveUserPref(prefs::kSessionLengthLimit);
255  UpdateSessionStartTimeIfWaitingForUserActivity();
256}
257
258void SessionLengthLimiterTest::SetWaitForInitialUserActivityPref(
259    bool wait_for_initial_user_activity) {
260  UpdateSessionStartTimeIfWaitingForUserActivity();
261  local_state_.SetUserPref(
262      prefs::kSessionWaitForInitialUserActivity,
263      new base::FundamentalValue(wait_for_initial_user_activity));
264}
265
266void SessionLengthLimiterTest::SimulateUserActivity() {
267  if (session_length_limiter_)
268    session_length_limiter_->OnUserActivity(NULL);
269  UpdateSessionStartTimeIfWaitingForUserActivity();
270  user_activity_seen_ = true;
271}
272
273void SessionLengthLimiterTest::
274    UpdateSessionStartTimeIfWaitingForUserActivity() {
275  if (!user_activity_seen_ &&
276      local_state_.GetBoolean(prefs::kSessionWaitForInitialUserActivity)) {
277    session_start_time_ = runner_->GetCurrentTime();
278  }
279}
280
281void SessionLengthLimiterTest::ExpectStopSession() {
282  Mock::VerifyAndClearExpectations(delegate_);
283  EXPECT_CALL(*delegate_, StopSession())
284      .Times(1)
285      .WillOnce(Invoke(this, &SessionLengthLimiterTest::SaveSessionStopTime));
286}
287
288void SessionLengthLimiterTest::SaveSessionStopTime() {
289  session_stop_time_ = runner_->GetCurrentTime();
290}
291
292void SessionLengthLimiterTest::CreateSessionLengthLimiter(
293    bool browser_restarted) {
294  user_activity_seen_ = false;
295  session_start_time_ = runner_->GetCurrentTime();
296
297  EXPECT_FALSE(delegate_);
298  delegate_ = new NiceMock<MockSessionLengthLimiterDelegate>;
299  ON_CALL(*delegate_, GetCurrentTime())
300      .WillByDefault(Invoke(runner_.get(),
301                            &MockTimeSingleThreadTaskRunner::GetCurrentTime));
302  EXPECT_CALL(*delegate_, StopSession()).Times(0);
303  session_length_limiter_.reset(
304      new SessionLengthLimiter(delegate_, browser_restarted));
305}
306
307void SessionLengthLimiterTest::DestroySessionLengthLimiter() {
308  session_length_limiter_.reset();
309  delegate_ = NULL;
310}
311
312// Verifies that when not instructed to wait for initial user activity, the
313// session start time is set and the pref indicating user activity is cleared
314// in local state during login.
315TEST_F(SessionLengthLimiterTest, StartDoNotWaitForInitialUserActivity) {
316  // Pref indicating user activity not set. Session start time not set.
317  ClearSessionUserActivitySeenPref();
318  ClearSessionStartTimePref();
319  CreateSessionLengthLimiter(false);
320  EXPECT_FALSE(IsSessionUserActivitySeenPrefSet());
321  EXPECT_EQ(session_start_time_, GetSessionStartTimePref());
322  DestroySessionLengthLimiter();
323
324  // Pref indicating user activity set. Session start time not set.
325  SetSessionUserActivitySeenPref(true);
326  ClearSessionStartTimePref();
327  CreateSessionLengthLimiter(false);
328  EXPECT_FALSE(IsSessionUserActivitySeenPrefSet());
329  EXPECT_EQ(session_start_time_, GetSessionStartTimePref());
330  DestroySessionLengthLimiter();
331
332  // Pref indicating user activity not set. Session start time in the future.
333  ClearSessionUserActivitySeenPref();
334  SetSessionStartTimePref(session_start_time_ + base::TimeDelta::FromHours(2));
335  CreateSessionLengthLimiter(false);
336  EXPECT_FALSE(IsSessionUserActivitySeenPrefSet());
337  EXPECT_EQ(session_start_time_, GetSessionStartTimePref());
338  DestroySessionLengthLimiter();
339
340  // Pref indicating user activity set. Session start time in the future.
341  SetSessionUserActivitySeenPref(true);
342  SetSessionStartTimePref(session_start_time_ + base::TimeDelta::FromHours(2));
343  CreateSessionLengthLimiter(false);
344  EXPECT_FALSE(IsSessionUserActivitySeenPrefSet());
345  EXPECT_EQ(session_start_time_, GetSessionStartTimePref());
346  DestroySessionLengthLimiter();
347
348  // Pref indicating user activity not set. Session start time valid.
349  ClearSessionUserActivitySeenPref();
350  SetSessionStartTimePref(session_start_time_ - base::TimeDelta::FromHours(2));
351  CreateSessionLengthLimiter(false);
352  EXPECT_FALSE(IsSessionUserActivitySeenPrefSet());
353  EXPECT_EQ(session_start_time_, GetSessionStartTimePref());
354  DestroySessionLengthLimiter();
355
356  // Pref indicating user activity set. Session start time valid.
357  SetSessionUserActivitySeenPref(true);
358  SetSessionStartTimePref(session_start_time_ - base::TimeDelta::FromHours(2));
359  CreateSessionLengthLimiter(false);
360  EXPECT_FALSE(IsSessionUserActivitySeenPrefSet());
361  EXPECT_EQ(session_start_time_, GetSessionStartTimePref());
362  DestroySessionLengthLimiter();
363}
364
365// Verifies that when instructed to wait for initial user activity, the session
366// start time and the pref indicating user activity are cleared in local state
367// during login.
368TEST_F(SessionLengthLimiterTest, StartWaitForInitialUserActivity) {
369   SetWaitForInitialUserActivityPref(true);
370
371  // Pref indicating user activity not set. Session start time not set.
372  ClearSessionUserActivitySeenPref();
373  ClearSessionStartTimePref();
374  CreateSessionLengthLimiter(false);
375  EXPECT_FALSE(IsSessionUserActivitySeenPrefSet());
376  EXPECT_FALSE(IsSessionStartTimePrefSet());
377  DestroySessionLengthLimiter();
378
379  // Pref indicating user activity set. Session start time not set.
380  SetSessionUserActivitySeenPref(true);
381  ClearSessionStartTimePref();
382  CreateSessionLengthLimiter(false);
383  EXPECT_FALSE(IsSessionUserActivitySeenPrefSet());
384  EXPECT_FALSE(IsSessionStartTimePrefSet());
385  DestroySessionLengthLimiter();
386
387  // Pref indicating user activity not set. Session start time in the future.
388  ClearSessionUserActivitySeenPref();
389  SetSessionStartTimePref(
390      runner_->GetCurrentTime() + base::TimeDelta::FromHours(2));
391  CreateSessionLengthLimiter(false);
392  EXPECT_FALSE(IsSessionUserActivitySeenPrefSet());
393  EXPECT_FALSE(IsSessionStartTimePrefSet());
394  DestroySessionLengthLimiter();
395
396  // Pref indicating user activity set. Session start time in the future.
397  SetSessionUserActivitySeenPref(true);
398  SetSessionStartTimePref(
399      runner_->GetCurrentTime() + base::TimeDelta::FromHours(2));
400  CreateSessionLengthLimiter(false);
401  EXPECT_FALSE(IsSessionUserActivitySeenPrefSet());
402  EXPECT_FALSE(IsSessionStartTimePrefSet());
403  DestroySessionLengthLimiter();
404
405  // Pref indicating user activity not set. Session start time valid.
406  ClearSessionUserActivitySeenPref();
407  SetSessionStartTimePref(
408      runner_->GetCurrentTime() - base::TimeDelta::FromHours(2));
409  CreateSessionLengthLimiter(false);
410  EXPECT_FALSE(IsSessionUserActivitySeenPrefSet());
411  EXPECT_FALSE(IsSessionStartTimePrefSet());
412  DestroySessionLengthLimiter();
413
414  // Pref indicating user activity set. Session start time valid.
415  SetSessionUserActivitySeenPref(true);
416  SetSessionStartTimePref(
417      runner_->GetCurrentTime() - base::TimeDelta::FromHours(2));
418  CreateSessionLengthLimiter(false);
419  EXPECT_FALSE(IsSessionUserActivitySeenPrefSet());
420  EXPECT_FALSE(IsSessionStartTimePrefSet());
421  DestroySessionLengthLimiter();
422}
423
424// Verifies that when not instructed to wait for initial user activity, local
425// state is correctly updated during restart after a crash:
426// * If no valid session start time is found in local state, the session start
427//   time is set and the pref indicating user activity is cleared.
428// * If a valid session start time is found in local state, the session start
429//   time and the pref indicating user activity are *not* modified.
430TEST_F(SessionLengthLimiterTest, RestartDoNotWaitForInitialUserActivity) {
431  // Pref indicating user activity not set. Session start time not set.
432  ClearSessionUserActivitySeenPref();
433  ClearSessionStartTimePref();
434  CreateSessionLengthLimiter(true);
435  EXPECT_FALSE(IsSessionUserActivitySeenPrefSet());
436  EXPECT_EQ(session_start_time_, GetSessionStartTimePref());
437  DestroySessionLengthLimiter();
438
439  // Pref indicating user activity set. Session start time not set.
440  SetSessionUserActivitySeenPref(true);
441  ClearSessionStartTimePref();
442  CreateSessionLengthLimiter(true);
443  EXPECT_FALSE(IsSessionUserActivitySeenPrefSet());
444  EXPECT_EQ(session_start_time_, GetSessionStartTimePref());
445  DestroySessionLengthLimiter();
446
447  // Pref indicating user activity not set. Session start time in the future.
448  ClearSessionUserActivitySeenPref();
449  SetSessionStartTimePref(
450      runner_->GetCurrentTime() + base::TimeDelta::FromHours(2));
451  CreateSessionLengthLimiter(true);
452  EXPECT_FALSE(IsSessionUserActivitySeenPrefSet());
453  EXPECT_EQ(session_start_time_, GetSessionStartTimePref());
454  DestroySessionLengthLimiter();
455
456  // Pref indicating user activity set. Session start time in the future.
457  SetSessionUserActivitySeenPref(true);
458  SetSessionStartTimePref(
459      runner_->GetCurrentTime() + base::TimeDelta::FromHours(2));
460  CreateSessionLengthLimiter(true);
461  EXPECT_FALSE(IsSessionUserActivitySeenPrefSet());
462  EXPECT_EQ(session_start_time_, GetSessionStartTimePref());
463  DestroySessionLengthLimiter();
464
465  const base::TimeTicks stored_session_start_time =
466      runner_->GetCurrentTime() - base::TimeDelta::FromHours(2);
467
468  // Pref indicating user activity not set. Session start time valid.
469  ClearSessionUserActivitySeenPref();
470  SetSessionStartTimePref(stored_session_start_time);
471  CreateSessionLengthLimiter(true);
472  EXPECT_FALSE(IsSessionUserActivitySeenPrefSet());
473  EXPECT_EQ(stored_session_start_time, GetSessionStartTimePref());
474  DestroySessionLengthLimiter();
475
476  // Pref indicating user activity set. Session start time valid.
477  SetSessionUserActivitySeenPref(true);
478  SetSessionStartTimePref(stored_session_start_time);
479  CreateSessionLengthLimiter(true);
480  EXPECT_TRUE(IsSessionUserActivitySeenPrefSet());
481  EXPECT_TRUE(GetSessionUserActivitySeenPref());
482  EXPECT_EQ(stored_session_start_time, GetSessionStartTimePref());
483  DestroySessionLengthLimiter();
484}
485
486// Verifies that when instructed to wait for initial user activity, local state
487// is correctly updated during restart after a crash:
488// * If no valid session start time is found in local state, the session start
489//   time and the pref indicating user activity are cleared.
490// * If a valid session start time is found in local state, the session start
491//   time and the pref indicating user activity are *not* modified.
492TEST_F(SessionLengthLimiterTest, RestartWaitForInitialUserActivity) {
493  SetWaitForInitialUserActivityPref(true);
494
495  // Pref indicating user activity not set. Session start time not set.
496  ClearSessionUserActivitySeenPref();
497  ClearSessionStartTimePref();
498  CreateSessionLengthLimiter(true);
499  EXPECT_FALSE(IsSessionUserActivitySeenPrefSet());
500  EXPECT_FALSE(IsSessionStartTimePrefSet());
501  DestroySessionLengthLimiter();
502
503  // Pref indicating user activity set. Session start time not set.
504  SetSessionUserActivitySeenPref(true);
505  ClearSessionStartTimePref();
506  CreateSessionLengthLimiter(true);
507  EXPECT_FALSE(IsSessionUserActivitySeenPrefSet());
508  EXPECT_FALSE(IsSessionStartTimePrefSet());
509  DestroySessionLengthLimiter();
510
511  // Pref indicating user activity not set. Session start time in the future.
512  ClearSessionUserActivitySeenPref();
513  SetSessionStartTimePref(
514      runner_->GetCurrentTime() + base::TimeDelta::FromHours(2));
515  CreateSessionLengthLimiter(true);
516  EXPECT_FALSE(IsSessionUserActivitySeenPrefSet());
517  EXPECT_FALSE(IsSessionStartTimePrefSet());
518  DestroySessionLengthLimiter();
519
520  // Pref indicating user activity set. Session start time in the future.
521  SetSessionUserActivitySeenPref(true);
522  SetSessionStartTimePref(
523      runner_->GetCurrentTime() + base::TimeDelta::FromHours(2));
524  CreateSessionLengthLimiter(true);
525  EXPECT_FALSE(IsSessionUserActivitySeenPrefSet());
526  EXPECT_FALSE(IsSessionStartTimePrefSet());
527  DestroySessionLengthLimiter();
528
529  const base::TimeTicks stored_session_start_time =
530      runner_->GetCurrentTime() - base::TimeDelta::FromHours(2);
531
532  // Pref indicating user activity not set. Session start time valid.
533  ClearSessionUserActivitySeenPref();
534  SetSessionStartTimePref(stored_session_start_time);
535  CreateSessionLengthLimiter(true);
536  EXPECT_FALSE(IsSessionUserActivitySeenPrefSet());
537  EXPECT_EQ(stored_session_start_time, GetSessionStartTimePref());
538  DestroySessionLengthLimiter();
539
540  // Pref indicating user activity set. Session start time valid.
541  SetSessionUserActivitySeenPref(true);
542  SetSessionStartTimePref(stored_session_start_time);
543  CreateSessionLengthLimiter(true);
544  EXPECT_TRUE(IsSessionUserActivitySeenPrefSet());
545  EXPECT_TRUE(GetSessionUserActivitySeenPref());
546  EXPECT_EQ(stored_session_start_time, GetSessionStartTimePref());
547  DestroySessionLengthLimiter();
548}
549
550// Verifies that local state is correctly updated when waiting for initial user
551// activity is toggled and no user activity has occurred yet.
552TEST_F(SessionLengthLimiterTest, ToggleWaitForInitialUserActivity) {
553  CreateSessionLengthLimiter(false);
554
555  // Verify that the pref indicating user activity was not set and the session
556  // start time was set.
557  EXPECT_FALSE(IsSessionUserActivitySeenPrefSet());
558  EXPECT_EQ(session_start_time_, GetSessionStartTimePref());
559
560  // Enable waiting for initial user activity.
561  runner_->FastForwardBy(base::TimeDelta::FromSeconds(1));
562  SetWaitForInitialUserActivityPref(true);
563
564  // Verify that the session start time was cleared and the pref indicating user
565  // activity was not set.
566  EXPECT_FALSE(IsSessionUserActivitySeenPrefSet());
567  EXPECT_FALSE(IsSessionStartTimePrefSet());
568
569  // Disable waiting for initial user activity.
570  runner_->FastForwardBy(base::TimeDelta::FromSeconds(1));
571  SetWaitForInitialUserActivityPref(false);
572
573  // Verify that the pref indicating user activity was not set and the session
574  // start time was.
575  EXPECT_FALSE(IsSessionUserActivitySeenPrefSet());
576  EXPECT_EQ(session_start_time_, GetSessionStartTimePref());
577}
578
579// Verifies that local state is correctly updated when instructed not to wait
580// for initial user activity and user activity occurs. Also verifies that once
581// initial user activity has occurred, neither the session start time nor the
582// pref indicating user activity change in local state anymore.
583TEST_F(SessionLengthLimiterTest, UserActivityWhileNotWaiting) {
584  CreateSessionLengthLimiter(false);
585
586  // Verify that the pref indicating user activity was not set and the session
587  // start time was set.
588  EXPECT_FALSE(IsSessionUserActivitySeenPrefSet());
589  EXPECT_EQ(session_start_time_, GetSessionStartTimePref());
590
591  // Simulate user activity.
592  runner_->FastForwardBy(base::TimeDelta::FromSeconds(1));
593  SimulateUserActivity();
594
595  // Verify that the pref indicating user activity and the session start time
596  // were set.
597  EXPECT_TRUE(IsSessionUserActivitySeenPrefSet());
598  EXPECT_TRUE(GetSessionUserActivitySeenPref());
599  EXPECT_EQ(session_start_time_, GetSessionStartTimePref());
600
601  // Simulate user activity.
602  runner_->FastForwardBy(base::TimeDelta::FromSeconds(1));
603  SimulateUserActivity();
604
605  // Verify that the pref indicating user activity and the session start time
606  // were not changed.
607  EXPECT_TRUE(IsSessionUserActivitySeenPrefSet());
608  EXPECT_TRUE(GetSessionUserActivitySeenPref());
609  EXPECT_EQ(session_start_time_, GetSessionStartTimePref());
610
611  // Enable waiting for initial user activity.
612  runner_->FastForwardBy(base::TimeDelta::FromSeconds(1));
613  SetWaitForInitialUserActivityPref(true);
614
615  // Verify that the pref indicating user activity and the session start time
616  // were not changed.
617  EXPECT_TRUE(IsSessionUserActivitySeenPrefSet());
618  EXPECT_TRUE(GetSessionUserActivitySeenPref());
619  EXPECT_EQ(session_start_time_, GetSessionStartTimePref());
620}
621
622// Verifies that local state is correctly updated when instructed to wait for
623// initial user activity and user activity occurs. Also verifies that once
624// initial user activity has occurred, neither the session start time nor the
625// pref indicating user activity change in local state anymore.
626TEST_F(SessionLengthLimiterTest, UserActivityWhileWaiting) {
627  SetWaitForInitialUserActivityPref(true);
628
629  CreateSessionLengthLimiter(false);
630
631  // Verify that the pref indicating user activity and the session start time
632  // were not set.
633  EXPECT_FALSE(IsSessionUserActivitySeenPrefSet());
634  EXPECT_FALSE(IsSessionStartTimePrefSet());
635
636  // Simulate user activity.
637  runner_->FastForwardBy(base::TimeDelta::FromSeconds(1));
638  SimulateUserActivity();
639
640  // Verify that the pref indicating user activity and the session start time
641  // were set.
642  EXPECT_TRUE(IsSessionUserActivitySeenPrefSet());
643  EXPECT_TRUE(GetSessionUserActivitySeenPref());
644  EXPECT_EQ(session_start_time_, GetSessionStartTimePref());
645
646  // Simulate user activity.
647  runner_->FastForwardBy(base::TimeDelta::FromSeconds(1));
648  SimulateUserActivity();
649
650  // Verify that the pref indicating user activity and the session start time
651  // were not changed.
652  EXPECT_TRUE(IsSessionUserActivitySeenPrefSet());
653  EXPECT_TRUE(GetSessionUserActivitySeenPref());
654  EXPECT_EQ(session_start_time_, GetSessionStartTimePref());
655
656  // Disable waiting for initial user activity.
657  runner_->FastForwardBy(base::TimeDelta::FromSeconds(1));
658  SetWaitForInitialUserActivityPref(false);
659
660  // Verify that the pref indicating user activity and the session start time
661  // were not changed.
662  EXPECT_TRUE(IsSessionUserActivitySeenPrefSet());
663  EXPECT_TRUE(GetSessionUserActivitySeenPref());
664  EXPECT_EQ(session_start_time_, GetSessionStartTimePref());
665}
666
667// Creates a SessionLengthLimiter without setting a limit. Verifies that the
668// limiter does not start a timer.
669TEST_F(SessionLengthLimiterTest, RunWithoutLimit) {
670  base::ThreadTaskRunnerHandle runner_handler(runner_);
671
672  CreateSessionLengthLimiter(false);
673
674  // Verify that no timer fires to terminate the session.
675  runner_->FastForwardUntilNoTasksRemain();
676}
677
678// Creates a SessionLengthLimiter after setting a limit and instructs it not to
679// wait for user activity. Verifies that the limiter starts a timer even if no
680// user activity occurs and that when the session length reaches the limit, the
681// session is terminated.
682TEST_F(SessionLengthLimiterTest, RunWithoutUserActivityWhileNotWaiting) {
683  base::ThreadTaskRunnerHandle runner_handler(runner_);
684
685  // Set a 60 second session time limit.
686  SetSessionLengthLimitPref(base::TimeDelta::FromSeconds(60));
687
688  CreateSessionLengthLimiter(false);
689  EXPECT_EQ(session_start_time_, GetSessionStartTimePref());
690
691  // Verify that the timer fires and the session is terminated when the session
692  // length limit is reached.
693  ExpectStopSession();
694  runner_->FastForwardUntilNoTasksRemain();
695  EXPECT_EQ(session_start_time_ + base::TimeDelta::FromSeconds(60),
696            session_stop_time_);
697}
698
699// Creates a SessionLengthLimiter after setting a limit and instructs it to wait
700// for initial user activity. Verifies that if no user activity occurs, the
701// limiter does not start a timer.
702TEST_F(SessionLengthLimiterTest, RunWithoutUserActivityWhileWaiting) {
703  base::ThreadTaskRunnerHandle runner_handler(runner_);
704  SetWaitForInitialUserActivityPref(true);
705
706  // Set a 60 second session time limit.
707  SetSessionLengthLimitPref(base::TimeDelta::FromSeconds(60));
708
709  CreateSessionLengthLimiter(false);
710  EXPECT_FALSE(IsSessionStartTimePrefSet());
711
712  // Verify that no timer fires to terminate the session.
713  runner_->FastForwardUntilNoTasksRemain();
714}
715
716// Creates a SessionLengthLimiter after setting a limit and instructs it not to
717// wait for user activity. Verifies that the limiter starts a timer and that
718// when the session length reaches the limit, the session is terminated. Also
719// verifies that user activity does not affect the timer.
720TEST_F(SessionLengthLimiterTest, RunWithUserActivityWhileNotWaiting) {
721  base::ThreadTaskRunnerHandle runner_handler(runner_);
722
723  // Set a 60 second session time limit.
724  SetSessionLengthLimitPref(base::TimeDelta::FromSeconds(60));
725
726  CreateSessionLengthLimiter(false);
727  EXPECT_EQ(session_start_time_, GetSessionStartTimePref());
728
729  // Simulate user activity after 20 seconds.
730  runner_->FastForwardBy(base::TimeDelta::FromSeconds(20));
731  SimulateUserActivity();
732  EXPECT_EQ(session_start_time_, GetSessionStartTimePref());
733
734  // Verify that the timer fires and the session is terminated when the session
735  // length limit is reached.
736  ExpectStopSession();
737  runner_->FastForwardUntilNoTasksRemain();
738  EXPECT_EQ(session_start_time_ + base::TimeDelta::FromSeconds(60),
739            session_stop_time_);
740}
741
742// Creates a SessionLengthLimiter after setting a limit and instructs it to wait
743// for initial user activity. Verifies that once user activity occurs, the
744// limiter starts a timer and that when the session length reaches the limit,
745// the session is terminated. Also verifies that further user activity does not
746// affect the timer.
747TEST_F(SessionLengthLimiterTest, RunWithUserActivityWhileWaiting) {
748  base::ThreadTaskRunnerHandle runner_handler(runner_);
749  SetWaitForInitialUserActivityPref(true);
750
751  // Set a 60 second session time limit.
752  SetSessionLengthLimitPref(base::TimeDelta::FromSeconds(60));
753
754  CreateSessionLengthLimiter(false);
755  EXPECT_FALSE(IsSessionStartTimePrefSet());
756
757  // Simulate user activity after 20 seconds.
758  runner_->FastForwardBy(base::TimeDelta::FromSeconds(20));
759  SimulateUserActivity();
760  EXPECT_EQ(session_start_time_, GetSessionStartTimePref());
761
762  // Simulate user activity after 20 seconds.
763  runner_->FastForwardBy(base::TimeDelta::FromSeconds(20));
764  SimulateUserActivity();
765  EXPECT_EQ(session_start_time_, GetSessionStartTimePref());
766
767  // Verify that the timer fires and the session is terminated when the session
768  // length limit is reached.
769  ExpectStopSession();
770  runner_->FastForwardUntilNoTasksRemain();
771  EXPECT_EQ(session_start_time_ + base::TimeDelta::FromSeconds(60),
772            session_stop_time_);
773}
774
775// Creates a SessionLengthLimiter after setting a 60 second limit, allows 50
776// seconds of session time to pass, then increases the limit to 90 seconds.
777// Verifies that when the session time reaches the new 90 second limit, the
778// session is terminated.
779TEST_F(SessionLengthLimiterTest, RunAndIncreaseSessionLengthLimit) {
780  base::ThreadTaskRunnerHandle runner_handler(runner_);
781
782  // Set a 60 second session time limit.
783  SetSessionLengthLimitPref(base::TimeDelta::FromSeconds(60));
784
785  CreateSessionLengthLimiter(false);
786
787  // Fast forward the time by 50 seconds, verifying that no timer fires to
788  // terminate the session.
789  runner_->FastForwardBy(base::TimeDelta::FromSeconds(50));
790
791  // Increase the session length limit to 90 seconds.
792  SetSessionLengthLimitPref(base::TimeDelta::FromSeconds(90));
793
794  // Verify that the the timer fires and the session is terminated when the
795  // session length limit is reached.
796  ExpectStopSession();
797  runner_->FastForwardUntilNoTasksRemain();
798  EXPECT_EQ(session_start_time_ + base::TimeDelta::FromSeconds(90),
799            session_stop_time_);
800}
801
802// Creates a SessionLengthLimiter after setting a 60 second limit, allows 50
803// seconds of session time to pass, then decreases the limit to 40 seconds.
804// Verifies that when the limit is decreased to 40 seconds after 50 seconds of
805// session time have passed, the next timer tick causes the session to be
806// terminated.
807TEST_F(SessionLengthLimiterTest, RunAndDecreaseSessionLengthLimit) {
808  base::ThreadTaskRunnerHandle runner_handler(runner_);
809
810  // Set a 60 second session time limit.
811  SetSessionLengthLimitPref(base::TimeDelta::FromSeconds(60));
812
813  CreateSessionLengthLimiter(false);
814
815  // Fast forward the time by 50 seconds, verifying that no timer fires to
816  // terminate the session.
817  runner_->FastForwardBy(base::TimeDelta::FromSeconds(50));
818
819  // Verify that reducing the session length limit below the 50 seconds that
820  // have already elapsed causes the session to be terminated immediately.
821  ExpectStopSession();
822  SetSessionLengthLimitPref(base::TimeDelta::FromSeconds(40));
823  EXPECT_EQ(session_start_time_ + base::TimeDelta::FromSeconds(50),
824            session_stop_time_);
825}
826
827// Creates a SessionLengthLimiter after setting a 60 second limit, allows 50
828// seconds of session time to pass, then removes the limit. Verifies that after
829// the limit is removed, the session is not terminated when the session time
830// reaches the original 60 second limit.
831TEST_F(SessionLengthLimiterTest, RunAndRemoveSessionLengthLimit) {
832  base::ThreadTaskRunnerHandle runner_handler(runner_);
833
834  // Set a 60 second session time limit.
835  SetSessionLengthLimitPref(base::TimeDelta::FromSeconds(60));
836
837  CreateSessionLengthLimiter(false);
838
839  // Fast forward the time by 50 seconds, verifying that no timer fires to
840  // terminate the session.
841  runner_->FastForwardBy(base::TimeDelta::FromSeconds(50));
842
843  // Remove the session length limit.
844  ClearSessionLengthLimitPref();
845
846  // Verify that no timer fires to terminate the session.
847  runner_->FastForwardUntilNoTasksRemain();
848}
849
850}  // namespace chromeos
851