Make base::Timer sequence-friendly.

base/timer/timer_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 "base/timer/timer.h"
 
 #include <stddef.h>
 
 #include <memory>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/sequenced_task_runner.h"
-#include "base/single_thread_task_runner.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/test/sequenced_worker_pool_owner.h"
 #include "base/test/test_mock_time_task_runner.h"
 #include "base/threading/platform_thread.h"
 #include "base/threading/sequenced_task_runner_handle.h"
 #include "base/threading/thread.h"
-#include "base/threading/thread_task_runner_handle.h"
 #include "base/time/tick_clock.h"
 #include "base/time/time.h"
 #include "build/build_config.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace base {
 
 namespace {
 
 // The message loops on which each timer should be tested.
@@ skipping 63 matching lines @@
  public:
   // |did_run|, if provided, will be signaled when Run() fires.
   explicit OneShotTimerTester(
       WaitableEvent* did_run = nullptr,
       const TimeDelta& delay = TimeDelta::FromMilliseconds(10))
       : OneShotTimerTesterBase(did_run, delay),
         quit_closure_(run_loop_.QuitClosure()) {}
 
   ~OneShotTimerTester() override = default;
 
-  void SetTaskRunner(scoped_refptr<SingleThreadTaskRunner> task_runner) {
+  void SetTaskRunner(scoped_refptr<SequencedTaskRunner> task_runner) {
     timer_->SetTaskRunner(std::move(task_runner));
 
     // Run() will be invoked on |task_runner| but |run_loop_|'s QuitClosure
     // needs to run on this thread (where the MessageLoop lives).
-    quit_closure_ =
-        Bind(IgnoreResult(&SingleThreadTaskRunner::PostTask),
-             ThreadTaskRunnerHandle::Get(), FROM_HERE, run_loop_.QuitClosure());
+    quit_closure_ = Bind(IgnoreResult(&SequencedTaskRunner::PostTask),
+                         SequencedTaskRunnerHandle::Get(), FROM_HERE,
+                         run_loop_.QuitClosure());
   }
 
   // Blocks until Run() executes and confirms that Run() didn't fire before
   // |delay_| expired.
   void WaitAndConfirmTimerFiredAfterDelay() {
     run_loop_.Run();
 
     EXPECT_NE(TimeTicks(), started_time());
     EXPECT_GE(TimeTicks::Now() - started_time(), delay());
   }
@@ skipping 488 matching lines @@
               false);
   EXPECT_FALSE(timer.IsRunning());
   timer.Reset();
   EXPECT_TRUE(timer.IsRunning());
   timer.Stop();
   EXPECT_FALSE(timer.IsRunning());
   timer.Reset();
   EXPECT_TRUE(timer.IsRunning());
 }
 
+//-----------------------------------------------------------------------------
+
 namespace {
 
 bool g_callback_happened1 = false;
 bool g_callback_happened2 = false;
 
 void ClearAllCallbackHappened() {
   g_callback_happened1 = false;
   g_callback_happened2 = false;
 }
 
@@ skipping 33 matching lines @@
     timer.Start(FROM_HERE, TimeDelta::FromMilliseconds(10),
                 Bind(&SetCallbackHappened1));
     timer.Reset();
     // Since Reset happened before task ran, the user_task must not be cleared:
     ASSERT_FALSE(timer.user_task().is_null());
     RunLoop().Run();
     EXPECT_TRUE(g_callback_happened1);
   }
 }
 
+namespace {
+
+const size_t kNumWorkerThreads = 3;
+
+// Fixture for tests requiring a worker pool. Includes a WaitableEvent so
+// that cases may Wait() on one thread and Signal() (explicitly, or implicitly
+// via helper methods) on another.
+class TimerSequenceTest : public testing::Test {
+ public:
+  TimerSequenceTest()
+      : event_(WaitableEvent::ResetPolicy::AUTOMATIC,
+               WaitableEvent::InitialState::NOT_SIGNALED) {}
+
+  void SetUp() override {
+    pool1_owner_.reset(
+        new SequencedWorkerPoolOwner(kNumWorkerThreads, "test1"));
+    pool2_owner_.reset(
+        new SequencedWorkerPoolOwner(kNumWorkerThreads, "test2"));
+  }
+
+  // Block until Signal() is called on another thread.
+  void Wait() { event_.Wait(); }
+
+  void Signal() { event_.Signal(); }
+
+  // Helper to augment a task with a subsequent call to Signal().
+  Closure TaskWithSignal(const Closure& task) {
+    return Bind(&TimerSequenceTest::RunTaskAndSignal, Unretained(this), task);
+  }
+
+  // Create the timer.
+  void CreateTimer() { timer_.reset(new OneShotTimer); }
+
+  // Schedule an event on the timer.
+  void StartTimer(TimeDelta delay, const Closure& task) {
+    timer_->Start(FROM_HERE, delay, task);
+  }
+
+  void SetTaskRunnerForTimer(scoped_refptr<SequencedTaskRunner> task_runner) {
+    timer_->SetTaskRunner(std::move(task_runner));
+  }
+
+  // Tell the timer to abandon the task.
+  void AbandonTask() {
+    EXPECT_TRUE(timer_->IsRunning());
+    // Reset() to call Timer::AbandonScheduledTask()
+    timer_->Reset();
+    EXPECT_TRUE(timer_->IsRunning());
+    timer_->Stop();
+    EXPECT_FALSE(timer_->IsRunning());
+  }
+
+  static void VerifyAffinity(const SequencedTaskRunner* task_runner) {
+    EXPECT_TRUE(task_runner->RunsTasksOnCurrentThread());
+  }
+
+  // Delete the timer.
+  void DeleteTimer() { timer_.reset(); }
+
+ protected:
+  const scoped_refptr<SequencedWorkerPool>& pool1() {
+    return pool1_owner_->pool();
+  }
+  const scoped_refptr<SequencedWorkerPool>& pool2() {
+    return pool2_owner_->pool();
+  }
+
+ private:
+  void RunTaskAndSignal(const Closure& task) {
+    task.Run();
+    Signal();
+  }
+
+  WaitableEvent event_;
+
+  MessageLoop message_loop_;
+  std::unique_ptr<SequencedWorkerPoolOwner> pool1_owner_;
+  std::unique_ptr<SequencedWorkerPoolOwner> pool2_owner_;
+
+  std::unique_ptr<OneShotTimer> timer_;
+
+  DISALLOW_COPY_AND_ASSIGN(TimerSequenceTest);
+};
+
+}  // namespace
+
+TEST_F(TimerSequenceTest, OneShotTimerTaskOnPoolThread) {
+  scoped_refptr<SequencedTaskRunner> task_runner =
+      pool1()->GetSequencedTaskRunner(pool1()->GetSequenceToken());
+
+  // Timer is created on this thread.
+  CreateTimer();
+
+  // Task will execute on a pool thread.
+  SetTaskRunnerForTimer(task_runner);
+  StartTimer(TimeDelta::FromMilliseconds(1),
+             Bind(&TimerSequenceTest::Signal, Unretained(this)));
+  Wait();
+
+  // Timer will be destroyed on this thread.
+  DeleteTimer();
+}
+
+TEST_F(TimerSequenceTest, OneShotTimerUsedOnPoolThread) {
+  scoped_refptr<SequencedTaskRunner> task_runner =
+      pool1()->GetSequencedTaskRunner(pool1()->GetSequenceToken());
+
+  // Timer is created on this thread.
+  CreateTimer();
+
+  // Task will be scheduled from a pool thread.
+  task_runner->PostTask(
+      FROM_HERE, Bind(&TimerSequenceTest::StartTimer, Unretained(this),
+                      TimeDelta::FromMilliseconds(1),
+                      Bind(&TimerSequenceTest::Signal, Unretained(this))));
+  Wait();
+
+  // Timer must be destroyed on pool thread, too.
+  task_runner->PostTask(
+      FROM_HERE,
+      TaskWithSignal(Bind(&TimerSequenceTest::DeleteTimer, Unretained(this))));
+  Wait();
+}
+
+TEST_F(TimerSequenceTest, OneShotTimerTwoPoolsAbandonTask) {
+  scoped_refptr<SequencedTaskRunner> task_runner1 =
+      pool1()->GetSequencedTaskRunner(pool1()->GetSequenceToken());
+  scoped_refptr<SequencedTaskRunner> task_runner2 =
+      pool2()->GetSequencedTaskRunner(pool2()->GetSequenceToken());
+
+  // Create timer on pool #1.
+  task_runner1->PostTask(
+      FROM_HERE,
+      TaskWithSignal(Bind(&TimerSequenceTest::CreateTimer, Unretained(this))));
+  Wait();
+
+  // And tell it to execute on a different pool (#2).
+  task_runner1->PostTask(
+      FROM_HERE, TaskWithSignal(Bind(&TimerSequenceTest::SetTaskRunnerForTimer,
+                                     Unretained(this), task_runner2)));
+  Wait();
+
+  // Task will be scheduled from pool #1.
+  task_runner1->PostTask(FROM_HERE,
+                         Bind(&TimerSequenceTest::StartTimer, Unretained(this),
+                              TimeDelta::FromHours(1), Bind(&DoNothing)));
+
+  // Abandon task - must be called from scheduling pool (#1).
+  task_runner1->PostTask(
+      FROM_HERE,
+      TaskWithSignal(Bind(&TimerSequenceTest::AbandonTask, Unretained(this))));
+  Wait();
+
+  // Timer must be destroyed on the pool it was scheduled from (#1).
+  task_runner1->PostTask(
+      FROM_HERE,
+      TaskWithSignal(Bind(&TimerSequenceTest::DeleteTimer, Unretained(this))));
+  Wait();
+}
+
+TEST_F(TimerSequenceTest, OneShotTimerUsedAndTaskedOnDifferentPools) {
+  scoped_refptr<SequencedTaskRunner> task_runner1 =
+      pool1()->GetSequencedTaskRunner(pool1()->GetSequenceToken());
+  scoped_refptr<SequencedTaskRunner> task_runner2 =
+      pool2()->GetSequencedTaskRunner(pool2()->GetSequenceToken());
+
+  // Create timer on pool #1.
+  task_runner1->PostTask(
+      FROM_HERE,
+      TaskWithSignal(Bind(&TimerSequenceTest::CreateTimer, Unretained(this))));
+  Wait();
+
+  // And tell it to execute on a different pool (#2).
+  task_runner1->PostTask(
+      FROM_HERE, TaskWithSignal(Bind(&TimerSequenceTest::SetTaskRunnerForTimer,
+                                     Unretained(this), task_runner2)));
+  Wait();
+
+  // Task will be scheduled from pool #1.
+  task_runner1->PostTask(
+      FROM_HERE, Bind(&TimerSequenceTest::StartTimer, Unretained(this),
+                      TimeDelta::FromMilliseconds(1),
+                      TaskWithSignal(Bind(&TimerSequenceTest::VerifyAffinity,
+                                          Unretained(task_runner2.get())))));
+
+  Wait();
+
+  // Timer must be destroyed on the pool it was scheduled from (#1).
+  task_runner1->PostTask(
+      FROM_HERE,
+      TaskWithSignal(Bind(&TimerSequenceTest::DeleteTimer, Unretained(this))));
+  Wait();
+}
+
 }  // namespace base