Add support to base::Timer for custom task runners.

base/timer/timer.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 "base/logging.h"
 #include "base/memory/ref_counted.h"
-#include "base/single_thread_task_runner.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/threading/platform_thread.h"
 
 namespace base {
 
 // BaseTimerTaskInternal is a simple delegate for scheduling a callback to
 // Timer in the thread's default task runner. It also handles the following
 // edge cases:
 // - deleted by the task runner.
 // - abandoned (orphaned) by Timer.
@@ skipping 64 matching lines @@
 }
 
 bool Timer::IsRunning() const {
   return is_running_;
 }
 
 TimeDelta Timer::GetCurrentDelay() const {
   return delay_;
 }
 
+void Timer::SetTaskRunner(scoped_refptr<SingleThreadTaskRunner> task_runner) {
+  // Do not allow changing the task runner once something has been scheduled.
+  DCHECK_EQ(thread_id_, 0);
+  task_runner_.swap(task_runner);
+}
+
 void Timer::Start(const tracked_objects::Location& posted_from,
                   TimeDelta delay,
                   const base::Closure& user_task) {
   SetTaskInfo(posted_from, delay, user_task);
   Reset();
 }
 
 void Timer::Stop() {
   is_running_ = false;
   if (!retain_user_task_)
@@ skipping 33 matching lines @@
   posted_from_ = posted_from;
   delay_ = delay;
   user_task_ = user_task;
 }
 
 void Timer::PostNewScheduledTask(TimeDelta delay) {
   DCHECK(scheduled_task_ == NULL);
   is_running_ = true;
   scheduled_task_ = new BaseTimerTaskInternal(this);
   if (delay > TimeDelta::FromMicroseconds(0)) {
-    ThreadTaskRunnerHandle::Get()->PostDelayedTask(posted_from_,
+    GetTaskRunner()->PostDelayedTask(posted_from_,
         base::Bind(&BaseTimerTaskInternal::Run, base::Owned(scheduled_task_)),
         delay);
     scheduled_run_time_ = desired_run_time_ = TimeTicks::Now() + delay;
   } else {
-    ThreadTaskRunnerHandle::Get()->PostTask(posted_from_,
+    GetTaskRunner()->PostTask(posted_from_,
         base::Bind(&BaseTimerTaskInternal::Run, base::Owned(scheduled_task_)));
     scheduled_run_time_ = desired_run_time_ = TimeTicks();
   }
   // Remember the thread ID that posts the first task -- this will be verified
   // later when the task is abandoned to detect misuse from multiple threads.
   if (!thread_id_)
     thread_id_ = static_cast<int>(PlatformThread::CurrentId());
 }
 
+scoped_refptr<SingleThreadTaskRunner> Timer::GetTaskRunner() {
+  return task_runner_.get() ? task_runner_ : ThreadTaskRunnerHandle::Get();
+}
+
 void Timer::AbandonScheduledTask() {
   DCHECK(thread_id_ == 0 ||
          thread_id_ == static_cast<int>(PlatformThread::CurrentId()));
   if (scheduled_task_) {
     scheduled_task_->Abandon();
     scheduled_task_ = NULL;
   }
 }
 
 void Timer::RunScheduledTask() {
@@ skipping 23 matching lines @@
     PostNewScheduledTask(delay_);
   else
     Stop();
 
   task.Run();
 
   // No more member accesses here: *this could be deleted at this point.
 }
 
 }  // namespace base