blob: 9421c787d0c934fed1844bb740876fcea4444c10 [file] [log] [blame]
// Copyright (c) 2012 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "chrome/browser/chromeos/session_length_limiter.h"
#include "base/compiler_specific.h"
#include "base/memory/ref_counted.h"
#include "base/memory/scoped_ptr.h"
#include "base/prefs/testing_pref_service.h"
#include "base/strings/string_number_conversions.h"
#include "base/test/test_mock_time_task_runner.h"
#include "base/thread_task_runner_handle.h"
#include "base/values.h"
#include "chrome/common/pref_names.h"
#include "chrome/test/base/testing_browser_process.h"
#include "testing/gmock/include/gmock/gmock.h"
#include "testing/gtest/include/gtest/gtest.h"
using ::testing::Invoke;
using ::testing::Mock;
using ::testing::NiceMock;
namespace chromeos {
namespace {
class MockSessionLengthLimiterDelegate : public SessionLengthLimiter::Delegate {
public:
MOCK_CONST_METHOD0(GetCurrentTime, const base::TimeTicks(void));
MOCK_METHOD0(StopSession, void(void));
};
} // namespace
class SessionLengthLimiterTest : public testing::Test {
protected:
SessionLengthLimiterTest();
// testing::Test:
void SetUp() override;
void TearDown() override;
void SetSessionUserActivitySeenPref(bool user_activity_seen);
void ClearSessionUserActivitySeenPref();
bool IsSessionUserActivitySeenPrefSet();
bool GetSessionUserActivitySeenPref();
void SetSessionStartTimePref(const base::TimeTicks& session_start_time);
void ClearSessionStartTimePref();
bool IsSessionStartTimePrefSet();
base::TimeTicks GetSessionStartTimePref();
void SetSessionLengthLimitPref(const base::TimeDelta& session_length_limit);
void ClearSessionLengthLimitPref();
void SetWaitForInitialUserActivityPref(bool wait_for_initial_user_activity);
void SimulateUserActivity();
void UpdateSessionStartTimeIfWaitingForUserActivity();
void ExpectStopSession();
void SaveSessionStopTime();
// Clears the session state by resetting |user_activity_| and
// |session_start_time_| and creates a new SessionLengthLimiter.
void CreateSessionLengthLimiter(bool browser_restarted);
void DestroySessionLengthLimiter();
scoped_refptr<base::TestMockTimeTaskRunner> runner_;
base::TimeTicks session_start_time_;
base::TimeTicks session_stop_time_;
private:
TestingPrefServiceSimple local_state_;
bool user_activity_seen_;
MockSessionLengthLimiterDelegate* delegate_; // Owned by
// session_length_limiter_.
scoped_ptr<SessionLengthLimiter> session_length_limiter_;
};
SessionLengthLimiterTest::SessionLengthLimiterTest()
: user_activity_seen_(false),
delegate_(NULL) {
}
void SessionLengthLimiterTest::SetUp() {
TestingBrowserProcess::GetGlobal()->SetLocalState(&local_state_);
SessionLengthLimiter::RegisterPrefs(local_state_.registry());
runner_ = new base::TestMockTimeTaskRunner;
runner_->FastForwardBy(base::TimeDelta::FromInternalValue(1000));
}
void SessionLengthLimiterTest::TearDown() {
session_length_limiter_.reset();
TestingBrowserProcess::GetGlobal()->SetLocalState(NULL);
}
void SessionLengthLimiterTest::SetSessionUserActivitySeenPref(
bool user_activity_seen) {
local_state_.SetUserPref(prefs::kSessionUserActivitySeen,
new base::FundamentalValue(user_activity_seen));
}
void SessionLengthLimiterTest::ClearSessionUserActivitySeenPref() {
local_state_.ClearPref(prefs::kSessionUserActivitySeen);
}
bool SessionLengthLimiterTest::IsSessionUserActivitySeenPrefSet() {
return local_state_.HasPrefPath(prefs::kSessionUserActivitySeen);
}
bool SessionLengthLimiterTest::GetSessionUserActivitySeenPref() {
EXPECT_TRUE(IsSessionUserActivitySeenPrefSet());
return local_state_.GetBoolean(prefs::kSessionUserActivitySeen);
}
void SessionLengthLimiterTest::SetSessionStartTimePref(
const base::TimeTicks& session_start_time) {
local_state_.SetUserPref(
prefs::kSessionStartTime,
new base::StringValue(
base::Int64ToString(session_start_time.ToInternalValue())));
}
void SessionLengthLimiterTest::ClearSessionStartTimePref() {
local_state_.ClearPref(prefs::kSessionStartTime);
}
bool SessionLengthLimiterTest::IsSessionStartTimePrefSet() {
return local_state_.HasPrefPath(prefs::kSessionStartTime);
}
base::TimeTicks SessionLengthLimiterTest::GetSessionStartTimePref() {
EXPECT_TRUE(IsSessionStartTimePrefSet());
return base::TimeTicks::FromInternalValue(
local_state_.GetInt64(prefs::kSessionStartTime));
}
void SessionLengthLimiterTest::SetSessionLengthLimitPref(
const base::TimeDelta& session_length_limit) {
local_state_.SetUserPref(prefs::kSessionLengthLimit,
new base::FundamentalValue(
static_cast<int>(session_length_limit.InMilliseconds())));
UpdateSessionStartTimeIfWaitingForUserActivity();
}
void SessionLengthLimiterTest::ClearSessionLengthLimitPref() {
local_state_.RemoveUserPref(prefs::kSessionLengthLimit);
UpdateSessionStartTimeIfWaitingForUserActivity();
}
void SessionLengthLimiterTest::SetWaitForInitialUserActivityPref(
bool wait_for_initial_user_activity) {
UpdateSessionStartTimeIfWaitingForUserActivity();
local_state_.SetUserPref(
prefs::kSessionWaitForInitialUserActivity,
new base::FundamentalValue(wait_for_initial_user_activity));
}
void SessionLengthLimiterTest::SimulateUserActivity() {
if (session_length_limiter_)
session_length_limiter_->OnUserActivity(NULL);
UpdateSessionStartTimeIfWaitingForUserActivity();
user_activity_seen_ = true;
}
void SessionLengthLimiterTest::
UpdateSessionStartTimeIfWaitingForUserActivity() {
if (!user_activity_seen_ &&
local_state_.GetBoolean(prefs::kSessionWaitForInitialUserActivity)) {
session_start_time_ = runner_->NowTicks();
}
}
void SessionLengthLimiterTest::ExpectStopSession() {
Mock::VerifyAndClearExpectations(delegate_);
EXPECT_CALL(*delegate_, StopSession())
.Times(1)
.WillOnce(Invoke(this, &SessionLengthLimiterTest::SaveSessionStopTime));
}
void SessionLengthLimiterTest::SaveSessionStopTime() {
session_stop_time_ = runner_->NowTicks();
}
void SessionLengthLimiterTest::CreateSessionLengthLimiter(
bool browser_restarted) {
user_activity_seen_ = false;
session_start_time_ = runner_->NowTicks();
EXPECT_FALSE(delegate_);
delegate_ = new NiceMock<MockSessionLengthLimiterDelegate>;
ON_CALL(*delegate_, GetCurrentTime())
.WillByDefault(
Invoke(runner_.get(), &base::TestMockTimeTaskRunner::NowTicks));
EXPECT_CALL(*delegate_, StopSession()).Times(0);
session_length_limiter_.reset(
new SessionLengthLimiter(delegate_, browser_restarted));
}
void SessionLengthLimiterTest::DestroySessionLengthLimiter() {
session_length_limiter_.reset();
delegate_ = NULL;
}
// Verifies that when not instructed to wait for initial user activity, the
// session start time is set and the pref indicating user activity is cleared
// in local state during login.
TEST_F(SessionLengthLimiterTest, StartDoNotWaitForInitialUserActivity) {
// Pref indicating user activity not set. Session start time not set.
ClearSessionUserActivitySeenPref();
ClearSessionStartTimePref();
CreateSessionLengthLimiter(false);
EXPECT_FALSE(IsSessionUserActivitySeenPrefSet());
EXPECT_EQ(session_start_time_, GetSessionStartTimePref());
DestroySessionLengthLimiter();
// Pref indicating user activity set. Session start time not set.
SetSessionUserActivitySeenPref(true);
ClearSessionStartTimePref();
CreateSessionLengthLimiter(false);
EXPECT_FALSE(IsSessionUserActivitySeenPrefSet());
EXPECT_EQ(session_start_time_, GetSessionStartTimePref());
DestroySessionLengthLimiter();
// Pref indicating user activity not set. Session start time in the future.
ClearSessionUserActivitySeenPref();
SetSessionStartTimePref(session_start_time_ + base::TimeDelta::FromHours(2));
CreateSessionLengthLimiter(false);
EXPECT_FALSE(IsSessionUserActivitySeenPrefSet());
EXPECT_EQ(session_start_time_, GetSessionStartTimePref());
DestroySessionLengthLimiter();
// Pref indicating user activity set. Session start time in the future.
SetSessionUserActivitySeenPref(true);
SetSessionStartTimePref(session_start_time_ + base::TimeDelta::FromHours(2));
CreateSessionLengthLimiter(false);
EXPECT_FALSE(IsSessionUserActivitySeenPrefSet());
EXPECT_EQ(session_start_time_, GetSessionStartTimePref());
DestroySessionLengthLimiter();
// Pref indicating user activity not set. Session start time valid.
ClearSessionUserActivitySeenPref();
SetSessionStartTimePref(session_start_time_ - base::TimeDelta::FromHours(2));
CreateSessionLengthLimiter(false);
EXPECT_FALSE(IsSessionUserActivitySeenPrefSet());
EXPECT_EQ(session_start_time_, GetSessionStartTimePref());
DestroySessionLengthLimiter();
// Pref indicating user activity set. Session start time valid.
SetSessionUserActivitySeenPref(true);
SetSessionStartTimePref(session_start_time_ - base::TimeDelta::FromHours(2));
CreateSessionLengthLimiter(false);
EXPECT_FALSE(IsSessionUserActivitySeenPrefSet());
EXPECT_EQ(session_start_time_, GetSessionStartTimePref());
DestroySessionLengthLimiter();
}
// Verifies that when instructed to wait for initial user activity, the session
// start time and the pref indicating user activity are cleared in local state
// during login.
TEST_F(SessionLengthLimiterTest, StartWaitForInitialUserActivity) {
SetWaitForInitialUserActivityPref(true);
// Pref indicating user activity not set. Session start time not set.
ClearSessionUserActivitySeenPref();
ClearSessionStartTimePref();
CreateSessionLengthLimiter(false);
EXPECT_FALSE(IsSessionUserActivitySeenPrefSet());
EXPECT_FALSE(IsSessionStartTimePrefSet());
DestroySessionLengthLimiter();
// Pref indicating user activity set. Session start time not set.
SetSessionUserActivitySeenPref(true);
ClearSessionStartTimePref();
CreateSessionLengthLimiter(false);
EXPECT_FALSE(IsSessionUserActivitySeenPrefSet());
EXPECT_FALSE(IsSessionStartTimePrefSet());
DestroySessionLengthLimiter();
// Pref indicating user activity not set. Session start time in the future.
ClearSessionUserActivitySeenPref();
SetSessionStartTimePref(runner_->NowTicks() + base::TimeDelta::FromHours(2));
CreateSessionLengthLimiter(false);
EXPECT_FALSE(IsSessionUserActivitySeenPrefSet());
EXPECT_FALSE(IsSessionStartTimePrefSet());
DestroySessionLengthLimiter();
// Pref indicating user activity set. Session start time in the future.
SetSessionUserActivitySeenPref(true);
SetSessionStartTimePref(runner_->NowTicks() + base::TimeDelta::FromHours(2));
CreateSessionLengthLimiter(false);
EXPECT_FALSE(IsSessionUserActivitySeenPrefSet());
EXPECT_FALSE(IsSessionStartTimePrefSet());
DestroySessionLengthLimiter();
// Pref indicating user activity not set. Session start time valid.
ClearSessionUserActivitySeenPref();
SetSessionStartTimePref(runner_->NowTicks() - base::TimeDelta::FromHours(2));
CreateSessionLengthLimiter(false);
EXPECT_FALSE(IsSessionUserActivitySeenPrefSet());
EXPECT_FALSE(IsSessionStartTimePrefSet());
DestroySessionLengthLimiter();
// Pref indicating user activity set. Session start time valid.
SetSessionUserActivitySeenPref(true);
SetSessionStartTimePref(runner_->NowTicks() - base::TimeDelta::FromHours(2));
CreateSessionLengthLimiter(false);
EXPECT_FALSE(IsSessionUserActivitySeenPrefSet());
EXPECT_FALSE(IsSessionStartTimePrefSet());
DestroySessionLengthLimiter();
}
// Verifies that when not instructed to wait for initial user activity, local
// state is correctly updated during restart after a crash:
// * If no valid session start time is found in local state, the session start
// time is set and the pref indicating user activity is cleared.
// * If a valid session start time is found in local state, the session start
// time and the pref indicating user activity are *not* modified.
TEST_F(SessionLengthLimiterTest, RestartDoNotWaitForInitialUserActivity) {
// Pref indicating user activity not set. Session start time not set.
ClearSessionUserActivitySeenPref();
ClearSessionStartTimePref();
CreateSessionLengthLimiter(true);
EXPECT_FALSE(IsSessionUserActivitySeenPrefSet());
EXPECT_EQ(session_start_time_, GetSessionStartTimePref());
DestroySessionLengthLimiter();
// Pref indicating user activity set. Session start time not set.
SetSessionUserActivitySeenPref(true);
ClearSessionStartTimePref();
CreateSessionLengthLimiter(true);
EXPECT_FALSE(IsSessionUserActivitySeenPrefSet());
EXPECT_EQ(session_start_time_, GetSessionStartTimePref());
DestroySessionLengthLimiter();
// Pref indicating user activity not set. Session start time in the future.
ClearSessionUserActivitySeenPref();
SetSessionStartTimePref(runner_->NowTicks() + base::TimeDelta::FromHours(2));
CreateSessionLengthLimiter(true);
EXPECT_FALSE(IsSessionUserActivitySeenPrefSet());
EXPECT_EQ(session_start_time_, GetSessionStartTimePref());
DestroySessionLengthLimiter();
// Pref indicating user activity set. Session start time in the future.
SetSessionUserActivitySeenPref(true);
SetSessionStartTimePref(runner_->NowTicks() + base::TimeDelta::FromHours(2));
CreateSessionLengthLimiter(true);
EXPECT_FALSE(IsSessionUserActivitySeenPrefSet());
EXPECT_EQ(session_start_time_, GetSessionStartTimePref());
DestroySessionLengthLimiter();
const base::TimeTicks stored_session_start_time =
runner_->NowTicks() - base::TimeDelta::FromHours(2);
// Pref indicating user activity not set. Session start time valid.
ClearSessionUserActivitySeenPref();
SetSessionStartTimePref(stored_session_start_time);
CreateSessionLengthLimiter(true);
EXPECT_FALSE(IsSessionUserActivitySeenPrefSet());
EXPECT_EQ(stored_session_start_time, GetSessionStartTimePref());
DestroySessionLengthLimiter();
// Pref indicating user activity set. Session start time valid.
SetSessionUserActivitySeenPref(true);
SetSessionStartTimePref(stored_session_start_time);
CreateSessionLengthLimiter(true);
EXPECT_TRUE(IsSessionUserActivitySeenPrefSet());
EXPECT_TRUE(GetSessionUserActivitySeenPref());
EXPECT_EQ(stored_session_start_time, GetSessionStartTimePref());
DestroySessionLengthLimiter();
}
// Verifies that when instructed to wait for initial user activity, local state
// is correctly updated during restart after a crash:
// * If no valid session start time is found in local state, the session start
// time and the pref indicating user activity are cleared.
// * If a valid session start time is found in local state, the session start
// time and the pref indicating user activity are *not* modified.
TEST_F(SessionLengthLimiterTest, RestartWaitForInitialUserActivity) {
SetWaitForInitialUserActivityPref(true);
// Pref indicating user activity not set. Session start time not set.
ClearSessionUserActivitySeenPref();
ClearSessionStartTimePref();
CreateSessionLengthLimiter(true);
EXPECT_FALSE(IsSessionUserActivitySeenPrefSet());
EXPECT_FALSE(IsSessionStartTimePrefSet());
DestroySessionLengthLimiter();
// Pref indicating user activity set. Session start time not set.
SetSessionUserActivitySeenPref(true);
ClearSessionStartTimePref();
CreateSessionLengthLimiter(true);
EXPECT_FALSE(IsSessionUserActivitySeenPrefSet());
EXPECT_FALSE(IsSessionStartTimePrefSet());
DestroySessionLengthLimiter();
// Pref indicating user activity not set. Session start time in the future.
ClearSessionUserActivitySeenPref();
SetSessionStartTimePref(runner_->NowTicks() + base::TimeDelta::FromHours(2));
CreateSessionLengthLimiter(true);
EXPECT_FALSE(IsSessionUserActivitySeenPrefSet());
EXPECT_FALSE(IsSessionStartTimePrefSet());
DestroySessionLengthLimiter();
// Pref indicating user activity set. Session start time in the future.
SetSessionUserActivitySeenPref(true);
SetSessionStartTimePref(runner_->NowTicks() + base::TimeDelta::FromHours(2));
CreateSessionLengthLimiter(true);
EXPECT_FALSE(IsSessionUserActivitySeenPrefSet());
EXPECT_FALSE(IsSessionStartTimePrefSet());
DestroySessionLengthLimiter();
const base::TimeTicks stored_session_start_time =
runner_->NowTicks() - base::TimeDelta::FromHours(2);
// Pref indicating user activity not set. Session start time valid.
ClearSessionUserActivitySeenPref();
SetSessionStartTimePref(stored_session_start_time);
CreateSessionLengthLimiter(true);
EXPECT_FALSE(IsSessionUserActivitySeenPrefSet());
EXPECT_EQ(stored_session_start_time, GetSessionStartTimePref());
DestroySessionLengthLimiter();
// Pref indicating user activity set. Session start time valid.
SetSessionUserActivitySeenPref(true);
SetSessionStartTimePref(stored_session_start_time);
CreateSessionLengthLimiter(true);
EXPECT_TRUE(IsSessionUserActivitySeenPrefSet());
EXPECT_TRUE(GetSessionUserActivitySeenPref());
EXPECT_EQ(stored_session_start_time, GetSessionStartTimePref());
DestroySessionLengthLimiter();
}
// Verifies that local state is correctly updated when waiting for initial user
// activity is toggled and no user activity has occurred yet.
TEST_F(SessionLengthLimiterTest, ToggleWaitForInitialUserActivity) {
CreateSessionLengthLimiter(false);
// Verify that the pref indicating user activity was not set and the session
// start time was set.
EXPECT_FALSE(IsSessionUserActivitySeenPrefSet());
EXPECT_EQ(session_start_time_, GetSessionStartTimePref());
// Enable waiting for initial user activity.
runner_->FastForwardBy(base::TimeDelta::FromSeconds(1));
SetWaitForInitialUserActivityPref(true);
// Verify that the session start time was cleared and the pref indicating user
// activity was not set.
EXPECT_FALSE(IsSessionUserActivitySeenPrefSet());
EXPECT_FALSE(IsSessionStartTimePrefSet());
// Disable waiting for initial user activity.
runner_->FastForwardBy(base::TimeDelta::FromSeconds(1));
SetWaitForInitialUserActivityPref(false);
// Verify that the pref indicating user activity was not set and the session
// start time was.
EXPECT_FALSE(IsSessionUserActivitySeenPrefSet());
EXPECT_EQ(session_start_time_, GetSessionStartTimePref());
}
// Verifies that local state is correctly updated when instructed not to wait
// for initial user activity and user activity occurs. Also verifies that once
// initial user activity has occurred, neither the session start time nor the
// pref indicating user activity change in local state anymore.
TEST_F(SessionLengthLimiterTest, UserActivityWhileNotWaiting) {
CreateSessionLengthLimiter(false);
// Verify that the pref indicating user activity was not set and the session
// start time was set.
EXPECT_FALSE(IsSessionUserActivitySeenPrefSet());
EXPECT_EQ(session_start_time_, GetSessionStartTimePref());
// Simulate user activity.
runner_->FastForwardBy(base::TimeDelta::FromSeconds(1));
SimulateUserActivity();
// Verify that the pref indicating user activity and the session start time
// were set.
EXPECT_TRUE(IsSessionUserActivitySeenPrefSet());
EXPECT_TRUE(GetSessionUserActivitySeenPref());
EXPECT_EQ(session_start_time_, GetSessionStartTimePref());
// Simulate user activity.
runner_->FastForwardBy(base::TimeDelta::FromSeconds(1));
SimulateUserActivity();
// Verify that the pref indicating user activity and the session start time
// were not changed.
EXPECT_TRUE(IsSessionUserActivitySeenPrefSet());
EXPECT_TRUE(GetSessionUserActivitySeenPref());
EXPECT_EQ(session_start_time_, GetSessionStartTimePref());
// Enable waiting for initial user activity.
runner_->FastForwardBy(base::TimeDelta::FromSeconds(1));
SetWaitForInitialUserActivityPref(true);
// Verify that the pref indicating user activity and the session start time
// were not changed.
EXPECT_TRUE(IsSessionUserActivitySeenPrefSet());
EXPECT_TRUE(GetSessionUserActivitySeenPref());
EXPECT_EQ(session_start_time_, GetSessionStartTimePref());
}
// Verifies that local state is correctly updated when instructed to wait for
// initial user activity and user activity occurs. Also verifies that once
// initial user activity has occurred, neither the session start time nor the
// pref indicating user activity change in local state anymore.
TEST_F(SessionLengthLimiterTest, UserActivityWhileWaiting) {
SetWaitForInitialUserActivityPref(true);
CreateSessionLengthLimiter(false);
// Verify that the pref indicating user activity and the session start time
// were not set.
EXPECT_FALSE(IsSessionUserActivitySeenPrefSet());
EXPECT_FALSE(IsSessionStartTimePrefSet());
// Simulate user activity.
runner_->FastForwardBy(base::TimeDelta::FromSeconds(1));
SimulateUserActivity();
// Verify that the pref indicating user activity and the session start time
// were set.
EXPECT_TRUE(IsSessionUserActivitySeenPrefSet());
EXPECT_TRUE(GetSessionUserActivitySeenPref());
EXPECT_EQ(session_start_time_, GetSessionStartTimePref());
// Simulate user activity.
runner_->FastForwardBy(base::TimeDelta::FromSeconds(1));
SimulateUserActivity();
// Verify that the pref indicating user activity and the session start time
// were not changed.
EXPECT_TRUE(IsSessionUserActivitySeenPrefSet());
EXPECT_TRUE(GetSessionUserActivitySeenPref());
EXPECT_EQ(session_start_time_, GetSessionStartTimePref());
// Disable waiting for initial user activity.
runner_->FastForwardBy(base::TimeDelta::FromSeconds(1));
SetWaitForInitialUserActivityPref(false);
// Verify that the pref indicating user activity and the session start time
// were not changed.
EXPECT_TRUE(IsSessionUserActivitySeenPrefSet());
EXPECT_TRUE(GetSessionUserActivitySeenPref());
EXPECT_EQ(session_start_time_, GetSessionStartTimePref());
}
// Creates a SessionLengthLimiter without setting a limit. Verifies that the
// limiter does not start a timer.
TEST_F(SessionLengthLimiterTest, RunWithoutLimit) {
base::ThreadTaskRunnerHandle runner_handler(runner_);
CreateSessionLengthLimiter(false);
// Verify that no timer fires to terminate the session.
runner_->FastForwardUntilNoTasksRemain();
}
// Creates a SessionLengthLimiter after setting a limit and instructs it not to
// wait for user activity. Verifies that the limiter starts a timer even if no
// user activity occurs and that when the session length reaches the limit, the
// session is terminated.
TEST_F(SessionLengthLimiterTest, RunWithoutUserActivityWhileNotWaiting) {
base::ThreadTaskRunnerHandle runner_handler(runner_);
// Set a 60 second session time limit.
SetSessionLengthLimitPref(base::TimeDelta::FromSeconds(60));
CreateSessionLengthLimiter(false);
EXPECT_EQ(session_start_time_, GetSessionStartTimePref());
// Verify that the timer fires and the session is terminated when the session
// length limit is reached.
ExpectStopSession();
runner_->FastForwardUntilNoTasksRemain();
EXPECT_EQ(session_start_time_ + base::TimeDelta::FromSeconds(60),
session_stop_time_);
}
// Creates a SessionLengthLimiter after setting a limit and instructs it to wait
// for initial user activity. Verifies that if no user activity occurs, the
// limiter does not start a timer.
TEST_F(SessionLengthLimiterTest, RunWithoutUserActivityWhileWaiting) {
base::ThreadTaskRunnerHandle runner_handler(runner_);
SetWaitForInitialUserActivityPref(true);
// Set a 60 second session time limit.
SetSessionLengthLimitPref(base::TimeDelta::FromSeconds(60));
CreateSessionLengthLimiter(false);
EXPECT_FALSE(IsSessionStartTimePrefSet());
// Verify that no timer fires to terminate the session.
runner_->FastForwardUntilNoTasksRemain();
}
// Creates a SessionLengthLimiter after setting a limit and instructs it not to
// wait for user activity. Verifies that the limiter starts a timer and that
// when the session length reaches the limit, the session is terminated. Also
// verifies that user activity does not affect the timer.
TEST_F(SessionLengthLimiterTest, RunWithUserActivityWhileNotWaiting) {
base::ThreadTaskRunnerHandle runner_handler(runner_);
// Set a 60 second session time limit.
SetSessionLengthLimitPref(base::TimeDelta::FromSeconds(60));
CreateSessionLengthLimiter(false);
EXPECT_EQ(session_start_time_, GetSessionStartTimePref());
// Simulate user activity after 20 seconds.
runner_->FastForwardBy(base::TimeDelta::FromSeconds(20));
SimulateUserActivity();
EXPECT_EQ(session_start_time_, GetSessionStartTimePref());
// Verify that the timer fires and the session is terminated when the session
// length limit is reached.
ExpectStopSession();
runner_->FastForwardUntilNoTasksRemain();
EXPECT_EQ(session_start_time_ + base::TimeDelta::FromSeconds(60),
session_stop_time_);
}
// Creates a SessionLengthLimiter after setting a limit and instructs it to wait
// for initial user activity. Verifies that once user activity occurs, the
// limiter starts a timer and that when the session length reaches the limit,
// the session is terminated. Also verifies that further user activity does not
// affect the timer.
TEST_F(SessionLengthLimiterTest, RunWithUserActivityWhileWaiting) {
base::ThreadTaskRunnerHandle runner_handler(runner_);
SetWaitForInitialUserActivityPref(true);
// Set a 60 second session time limit.
SetSessionLengthLimitPref(base::TimeDelta::FromSeconds(60));
CreateSessionLengthLimiter(false);
EXPECT_FALSE(IsSessionStartTimePrefSet());
// Simulate user activity after 20 seconds.
runner_->FastForwardBy(base::TimeDelta::FromSeconds(20));
SimulateUserActivity();
EXPECT_EQ(session_start_time_, GetSessionStartTimePref());
// Simulate user activity after 20 seconds.
runner_->FastForwardBy(base::TimeDelta::FromSeconds(20));
SimulateUserActivity();
EXPECT_EQ(session_start_time_, GetSessionStartTimePref());
// Verify that the timer fires and the session is terminated when the session
// length limit is reached.
ExpectStopSession();
runner_->FastForwardUntilNoTasksRemain();
EXPECT_EQ(session_start_time_ + base::TimeDelta::FromSeconds(60),
session_stop_time_);
}
// Creates a SessionLengthLimiter after setting a 60 second limit, allows 50
// seconds of session time to pass, then increases the limit to 90 seconds.
// Verifies that when the session time reaches the new 90 second limit, the
// session is terminated.
TEST_F(SessionLengthLimiterTest, RunAndIncreaseSessionLengthLimit) {
base::ThreadTaskRunnerHandle runner_handler(runner_);
// Set a 60 second session time limit.
SetSessionLengthLimitPref(base::TimeDelta::FromSeconds(60));
CreateSessionLengthLimiter(false);
// Fast forward the time by 50 seconds, verifying that no timer fires to
// terminate the session.
runner_->FastForwardBy(base::TimeDelta::FromSeconds(50));
// Increase the session length limit to 90 seconds.
SetSessionLengthLimitPref(base::TimeDelta::FromSeconds(90));
// Verify that the the timer fires and the session is terminated when the
// session length limit is reached.
ExpectStopSession();
runner_->FastForwardUntilNoTasksRemain();
EXPECT_EQ(session_start_time_ + base::TimeDelta::FromSeconds(90),
session_stop_time_);
}
// Creates a SessionLengthLimiter after setting a 60 second limit, allows 50
// seconds of session time to pass, then decreases the limit to 40 seconds.
// Verifies that when the limit is decreased to 40 seconds after 50 seconds of
// session time have passed, the next timer tick causes the session to be
// terminated.
TEST_F(SessionLengthLimiterTest, RunAndDecreaseSessionLengthLimit) {
base::ThreadTaskRunnerHandle runner_handler(runner_);
// Set a 60 second session time limit.
SetSessionLengthLimitPref(base::TimeDelta::FromSeconds(60));
CreateSessionLengthLimiter(false);
// Fast forward the time by 50 seconds, verifying that no timer fires to
// terminate the session.
runner_->FastForwardBy(base::TimeDelta::FromSeconds(50));
// Verify that reducing the session length limit below the 50 seconds that
// have already elapsed causes the session to be terminated immediately.
ExpectStopSession();
SetSessionLengthLimitPref(base::TimeDelta::FromSeconds(40));
EXPECT_EQ(session_start_time_ + base::TimeDelta::FromSeconds(50),
session_stop_time_);
}
// Creates a SessionLengthLimiter after setting a 60 second limit, allows 50
// seconds of session time to pass, then removes the limit. Verifies that after
// the limit is removed, the session is not terminated when the session time
// reaches the original 60 second limit.
TEST_F(SessionLengthLimiterTest, RunAndRemoveSessionLengthLimit) {
base::ThreadTaskRunnerHandle runner_handler(runner_);
// Set a 60 second session time limit.
SetSessionLengthLimitPref(base::TimeDelta::FromSeconds(60));
CreateSessionLengthLimiter(false);
// Fast forward the time by 50 seconds, verifying that no timer fires to
// terminate the session.
runner_->FastForwardBy(base::TimeDelta::FromSeconds(50));
// Remove the session length limit.
ClearSessionLengthLimitPref();
// Verify that no timer fires to terminate the session.
runner_->FastForwardUntilNoTasksRemain();
}
} // namespace chromeos