Revert of Add TestMockTimeTaskRunner in base/test.

chrome/browser/chromeos/session_length_limiter_unittest.cc

 // 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 <queue>
+#include <utility>
+#include <vector>
+
+#include "base/callback.h"
 #include "base/compiler_specific.h"
+#include "base/location.h"
+#include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/prefs/testing_pref_service.h"
+#include "base/single_thread_task_runner.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));
 };
 
+// A SingleThreadTaskRunner that mocks the current time and allows it to be
+// fast-forwarded.
+class MockTimeSingleThreadTaskRunner : public base::SingleThreadTaskRunner {
+ public:
+  MockTimeSingleThreadTaskRunner();
+
+  // base::SingleThreadTaskRunner:
+  virtual bool RunsTasksOnCurrentThread() const override;
+  virtual bool PostDelayedTask(const tracked_objects::Location& from_here,
+                               const base::Closure& task,
+                               base::TimeDelta delay) override;
+  virtual bool PostNonNestableDelayedTask(
+      const tracked_objects::Location& from_here,
+      const base::Closure& task,
+      base::TimeDelta delay) override;
+
+  const base::TimeTicks& GetCurrentTime() const;
+
+  void FastForwardBy(const base::TimeDelta& time_delta);
+  void FastForwardUntilNoTasksRemain();
+
+ private:
+  // Strict weak temporal ordering of tasks.
+  class TemporalOrder {
+   public:
+    bool operator()(
+        const std::pair<base::TimeTicks, base::Closure>& first_task,
+        const std::pair<base::TimeTicks, base::Closure>& second_task) const;
+  };
+
+  virtual ~MockTimeSingleThreadTaskRunner();
+
+  base::TimeTicks now_;
+  std::priority_queue<std::pair<base::TimeTicks, base::Closure>,
+                      std::vector<std::pair<base::TimeTicks, base::Closure> >,
+                      TemporalOrder> tasks_;
+};
+
 }  // namespace
 
 class SessionLengthLimiterTest : public testing::Test {
  protected:
   SessionLengthLimiterTest();
 
   // testing::Test:
   virtual void SetUp() override;
   virtual void TearDown() override;
 
@@ skipping 18 matching lines @@
 
   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_;
+  scoped_refptr<MockTimeSingleThreadTaskRunner> 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_;
 };
 
+MockTimeSingleThreadTaskRunner::MockTimeSingleThreadTaskRunner()
+    : now_(base::TimeTicks::FromInternalValue(1000)) {
+}
+
+bool MockTimeSingleThreadTaskRunner::RunsTasksOnCurrentThread() const {
+  return true;
+}
+
+bool MockTimeSingleThreadTaskRunner::PostDelayedTask(
+    const tracked_objects::Location& from_here,
+    const base::Closure& task,
+    base::TimeDelta delay) {
+  tasks_.push(std::pair<base::TimeTicks, base::Closure>(now_ + delay, task));
+  return true;
+}
+
+bool MockTimeSingleThreadTaskRunner::PostNonNestableDelayedTask(
+    const tracked_objects::Location& from_here,
+    const base::Closure& task,
+    base::TimeDelta delay) {
+  NOTREACHED();
+  return false;
+}
+
+const base::TimeTicks& MockTimeSingleThreadTaskRunner::GetCurrentTime() const {
+  return now_;
+}
+
+void MockTimeSingleThreadTaskRunner::FastForwardBy(
+    const base::TimeDelta& time_delta) {
+  const base::TimeTicks latest = now_ + time_delta;
+  while (!tasks_.empty() && tasks_.top().first <= latest) {
+    now_ = tasks_.top().first;
+    base::Closure task = tasks_.top().second;
+    tasks_.pop();
+    task.Run();
+  }
+  now_ = latest;
+}
+
+void MockTimeSingleThreadTaskRunner::FastForwardUntilNoTasksRemain() {
+  while (!tasks_.empty()) {
+    now_ = tasks_.top().first;
+    base::Closure task = tasks_.top().second;
+    tasks_.pop();
+    task.Run();
+  }
+}
+
+bool MockTimeSingleThreadTaskRunner::TemporalOrder::operator()(
+    const std::pair<base::TimeTicks, base::Closure>& first_task,
+    const std::pair<base::TimeTicks, base::Closure>& second_task) const {
+  return first_task.first > second_task.first;
+}
+
+MockTimeSingleThreadTaskRunner::~MockTimeSingleThreadTaskRunner() {
+}
+
 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));
+  runner_ = new MockTimeSingleThreadTaskRunner;
 }
 
 void SessionLengthLimiterTest::TearDown() {
   session_length_limiter_.reset();
   TestingBrowserProcess::GetGlobal()->SetLocalState(NULL);
 }
 
 void SessionLengthLimiterTest::SetSessionUserActivitySeenPref(
     bool user_activity_seen) {
   local_state_.SetUserPref(prefs::kSessionUserActivitySeen,
@@ skipping 60 matching lines @@
   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_->GetCurrentMockTime();
+    session_start_time_ = runner_->GetCurrentTime();
   }
 }
 
 void SessionLengthLimiterTest::ExpectStopSession() {
   Mock::VerifyAndClearExpectations(delegate_);
   EXPECT_CALL(*delegate_, StopSession())
       .Times(1)
       .WillOnce(Invoke(this, &SessionLengthLimiterTest::SaveSessionStopTime));
 }
 
 void SessionLengthLimiterTest::SaveSessionStopTime() {
-  session_stop_time_ = runner_->GetCurrentMockTime();
+  session_stop_time_ = runner_->GetCurrentTime();
 }
 
 void SessionLengthLimiterTest::CreateSessionLengthLimiter(
     bool browser_restarted) {
   user_activity_seen_ = false;
-  session_start_time_ = runner_->GetCurrentMockTime();
+  session_start_time_ = runner_->GetCurrentTime();
 
   EXPECT_FALSE(delegate_);
   delegate_ = new NiceMock<MockSessionLengthLimiterDelegate>;
   ON_CALL(*delegate_, GetCurrentTime())
-      .WillByDefault(Invoke(
-          runner_.get(), &base::TestMockTimeTaskRunner::GetCurrentMockTime));
+      .WillByDefault(Invoke(runner_.get(),
+                            &MockTimeSingleThreadTaskRunner::GetCurrentTime));
   EXPECT_CALL(*delegate_, StopSession()).Times(0);
   session_length_limiter_.reset(
       new SessionLengthLimiter(delegate_, browser_restarted));
 }
 
 void SessionLengthLimiterTest::DestroySessionLengthLimiter() {
   session_length_limiter_.reset();
   delegate_ = NULL;
 }
 
@@ skipping 68 matching lines @@
   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_->GetCurrentMockTime() + base::TimeDelta::FromHours(2));
+      runner_->GetCurrentTime() + 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_->GetCurrentMockTime() + base::TimeDelta::FromHours(2));
+      runner_->GetCurrentTime() + 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_->GetCurrentMockTime() - base::TimeDelta::FromHours(2));
+      runner_->GetCurrentTime() - 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_->GetCurrentMockTime() - base::TimeDelta::FromHours(2));
+      runner_->GetCurrentTime() - 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.
@@ skipping 12 matching lines @@
   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_->GetCurrentMockTime() + base::TimeDelta::FromHours(2));
+      runner_->GetCurrentTime() + 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_->GetCurrentMockTime() + base::TimeDelta::FromHours(2));
+      runner_->GetCurrentTime() + base::TimeDelta::FromHours(2));
   CreateSessionLengthLimiter(true);
   EXPECT_FALSE(IsSessionUserActivitySeenPrefSet());
   EXPECT_EQ(session_start_time_, GetSessionStartTimePref());
   DestroySessionLengthLimiter();
 
   const base::TimeTicks stored_session_start_time =
-      runner_->GetCurrentMockTime() - base::TimeDelta::FromHours(2);
+      runner_->GetCurrentTime() - 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.
@@ skipping 27 matching lines @@
   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_->GetCurrentMockTime() + base::TimeDelta::FromHours(2));
+      runner_->GetCurrentTime() + 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_->GetCurrentMockTime() + base::TimeDelta::FromHours(2));
+      runner_->GetCurrentTime() + base::TimeDelta::FromHours(2));
   CreateSessionLengthLimiter(true);
   EXPECT_FALSE(IsSessionUserActivitySeenPrefSet());
   EXPECT_FALSE(IsSessionStartTimePrefSet());
   DestroySessionLengthLimiter();
 
   const base::TimeTicks stored_session_start_time =
-      runner_->GetCurrentMockTime() - base::TimeDelta::FromHours(2);
+      runner_->GetCurrentTime() - 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.
@@ skipping 300 matching lines @@
   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