src/chrome/browser/chromeos/session_length_limiter_unittest.cc

   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
  27 using ::testing::Invoke;
  28 using ::testing::Mock;
  29 using ::testing::NiceMock;
  30
  31 namespace chromeos {
  32
  33 namespace {
  34
  35 class 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.
  43 class 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
  81 class 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
 130 MockTimeSingleThreadTaskRunner::MockTimeSingleThreadTaskRunner()
 131     : now_(base::TimeTicks::FromInternalValue(1000)) {
 132 }
 133
 134 bool MockTimeSingleThreadTaskRunner::RunsTasksOnCurrentThread() const {
 135   return true;
 136 }
 137
 138 bool 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
 146 bool 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
 154 const base::TimeTicks& MockTimeSingleThreadTaskRunner::GetCurrentTime() const {
 155   return now_;
 156 }
 157
 158 void 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
 170 void 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
 179 bool 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
 185 MockTimeSingleThreadTaskRunner::~MockTimeSingleThreadTaskRunner() {
 186 }
 187
 188 SessionLengthLimiterTest::SessionLengthLimiterTest()
 189     : user_activity_seen_(false),
 190       delegate_(NULL) {
 191 }
 192
 193 void SessionLengthLimiterTest::SetUp() {
 194   TestingBrowserProcess::GetGlobal()->SetLocalState(&local_state_);
 195   SessionLengthLimiter::RegisterPrefs(local_state_.registry());
 196   runner_ = new MockTimeSingleThreadTaskRunner;
 197 }
 198
 199 void SessionLengthLimiterTest::TearDown() {
 200   session_length_limiter_.reset();
 201   TestingBrowserProcess::GetGlobal()->SetLocalState(NULL);
 202 }
 203
 204 void SessionLengthLimiterTest::SetSessionUserActivitySeenPref(
 205     bool user_activity_seen) {
 206   local_state_.SetUserPref(prefs::kSessionUserActivitySeen,
 207                            new base::FundamentalValue(user_activity_seen));
 208 }
 209
 210 void SessionLengthLimiterTest::ClearSessionUserActivitySeenPref() {
 211   local_state_.ClearPref(prefs::kSessionUserActivitySeen);
 212 }
 213
 214 bool SessionLengthLimiterTest::IsSessionUserActivitySeenPrefSet() {
 215   return local_state_.HasPrefPath(prefs::kSessionUserActivitySeen);
 216 }
 217
 218 bool SessionLengthLimiterTest::GetSessionUserActivitySeenPref() {
 219   EXPECT_TRUE(IsSessionUserActivitySeenPrefSet());
 220   return local_state_.GetBoolean(prefs::kSessionUserActivitySeen);
 221 }
 222
 223 void 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
 231 void SessionLengthLimiterTest::ClearSessionStartTimePref() {
 232   local_state_.ClearPref(prefs::kSessionStartTime);
 233 }
 234
 235 bool SessionLengthLimiterTest::IsSessionStartTimePrefSet() {
 236   return local_state_.HasPrefPath(prefs::kSessionStartTime);
 237 }
 238
 239 base::TimeTicks SessionLengthLimiterTest::GetSessionStartTimePref() {
 240   EXPECT_TRUE(IsSessionStartTimePrefSet());
 241   return base::TimeTicks::FromInternalValue(
 242       local_state_.GetInt64(prefs::kSessionStartTime));
 243 }
 244
 245 void 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
 253 void SessionLengthLimiterTest::ClearSessionLengthLimitPref() {
 254   local_state_.RemoveUserPref(prefs::kSessionLengthLimit);
 255   UpdateSessionStartTimeIfWaitingForUserActivity();
 256 }
 257
 258 void 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
 266 void SessionLengthLimiterTest::SimulateUserActivity() {
 267   if (session_length_limiter_)
 268     session_length_limiter_->OnUserActivity(NULL);
 269   UpdateSessionStartTimeIfWaitingForUserActivity();
 270   user_activity_seen_ = true;
 271 }
 272
 273 void SessionLengthLimiterTest::
 274     UpdateSessionStartTimeIfWaitingForUserActivity() {
 275   if (!user_activity_seen_ &&
 276       local_state_.GetBoolean(prefs::kSessionWaitForInitialUserActivity)) {
 277     session_start_time_ = runner_->GetCurrentTime();
 278   }
 279 }
 280
 281 void SessionLengthLimiterTest::ExpectStopSession() {
 282   Mock::VerifyAndClearExpectations(delegate_);
 283   EXPECT_CALL(*delegate_, StopSession())
 284       .Times(1)
 285       .WillOnce(Invoke(this, &SessionLengthLimiterTest::SaveSessionStopTime));
 286 }
 287
 288 void SessionLengthLimiterTest::SaveSessionStopTime() {
 289   session_stop_time_ = runner_->GetCurrentTime();
 290 }
 291
 292 void 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
 307 void 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.
 315 TEST_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.
 368 TEST_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.
 430 TEST_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.
 492 TEST_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.
 552 TEST_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.
 583 TEST_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.
 626 TEST_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.
 669 TEST_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.
 682 TEST_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.
 702 TEST_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.
 720 TEST_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.
 747 TEST_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.
 779 TEST_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.
 807 TEST_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.
 831 TEST_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