Revert of Add TestMockTimeTaskRunner in base/test.

chrome/browser/chromeos/session_length_limiter_unittest.cc

Index: chrome/browser/chromeos/session_length_limiter_unittest.cc
diff --git a/chrome/browser/chromeos/session_length_limiter_unittest.cc b/chrome/browser/chromeos/session_length_limiter_unittest.cc
index 1d26284459a6631871a54e44467dbbc0d0de13b2..60252e3bc63e0d9a5aab16ee23cf818944b186e1 100644
--- a/chrome/browser/chromeos/session_length_limiter_unittest.cc
+++ b/chrome/browser/chromeos/session_length_limiter_unittest.cc
@@ -4,12 +4,19 @@
 
 #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"
@@ -31,6 +38,44 @@
   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 {
@@ -69,7 +114,7 @@
 
   void DestroySessionLengthLimiter();
 
-  scoped_refptr<base::TestMockTimeTaskRunner> runner_;
+  scoped_refptr<MockTimeSingleThreadTaskRunner> runner_;
   base::TimeTicks session_start_time_;
   base::TimeTicks session_stop_time_;
 
@@ -82,6 +127,64 @@
   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) {
@@ -90,8 +193,7 @@
 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() {
@@ -172,7 +274,7 @@
     UpdateSessionStartTimeIfWaitingForUserActivity() {
   if (!user_activity_seen_ &&
       local_state_.GetBoolean(prefs::kSessionWaitForInitialUserActivity)) {
-    session_start_time_ = runner_->GetCurrentMockTime();
+    session_start_time_ = runner_->GetCurrentTime();
   }
 }
 
@@ -184,19 +286,19 @@
 }
 
 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));
@@ -285,7 +387,7 @@
   // 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());
@@ -294,7 +396,7 @@
   // 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());
@@ -303,7 +405,7 @@
   // 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());
@@ -312,7 +414,7 @@
   // 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());
@@ -345,7 +447,7 @@
   // 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());
@@ -354,14 +456,14 @@
   // 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();
@@ -409,7 +511,7 @@
   // 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());
@@ -418,14 +520,14 @@
   // 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();