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

base/timer/timer.h

 // 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.
 
 // OneShotTimer and RepeatingTimer provide a simple timer API.  As the names
 // suggest, OneShotTimer calls you back once after a time delay expires.
 // RepeatingTimer on the other hand calls you back periodically with the
 // prescribed time interval.
 //
 // OneShotTimer and RepeatingTimer both cancel the timer when they go out of
@@ skipping 37 matching lines @@
 // disabled ones) from timer_unittests.cc pass locally. Some are disabled
 // because they're flaky on the buildbot, but when you run them locally you
 // should be able to tell the difference.
 
 #include "base/base_export.h"
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/location.h"
+#include "base/single_thread_task_runner.h"

[danakj, 2014/10/22 15:07:43]

can this be forward declared in this header?

[petrcermak, 2014/10/23 10:59:37]

Done.

 #include "base/time/time.h"
 
 namespace base {
 
 class BaseTimerTaskInternal;
 
 //-----------------------------------------------------------------------------
 // This class wraps MessageLoop::PostDelayedTask to manage delayed and repeating
 // tasks. It must be destructed on the same thread that starts tasks. There are
 // DCHECKs in place to verify this.
@@ skipping 12 matching lines @@
         bool is_repeating);
 
   virtual ~Timer();
 
   // Returns true if the timer is running (i.e., not stopped).
   virtual bool IsRunning() const;
 
   // Returns the current delay for this timer.
   virtual TimeDelta GetCurrentDelay() const;
 
+  // Set the task runner on which the task should be scheduled. This method can
+  // only be called before any tasks have been scheduled.
+  virtual void SetTaskRunner(scoped_refptr<SingleThreadTaskRunner> task_runner);
+
   // Start the timer to run at the given |delay| from now. If the timer is
   // already running, it will be replaced to call the given |user_task|.
   virtual void Start(const tracked_objects::Location& posted_from,
                      TimeDelta delay,
                      const base::Closure& user_task);
 
   // Call this method to stop and cancel the timer.  It is a no-op if the timer
   // is not running.
   virtual void Stop();
 
@@ skipping 15 matching lines @@
   bool is_repeating() const { return is_repeating_; }
 
  private:
   friend class BaseTimerTaskInternal;
 
   // Allocates a new scheduled_task_ and posts it on the current MessageLoop
   // with the given |delay|. scheduled_task_ must be NULL. scheduled_run_time_
   // and desired_run_time_ are reset to Now() + delay.
   void PostNewScheduledTask(TimeDelta delay);
 
+  // Returns the task runner on which the task should be scheduled. If the
+  // corresponding task_runner_ field is null, the task runner for the current
+  // thread is returned.
+  scoped_refptr<SingleThreadTaskRunner> GetTaskRunner();
+
   // Disable scheduled_task_ and abandon it so that it no longer refers back to
   // this object.
   void AbandonScheduledTask();
 
   // Called by BaseTimerTaskInternal when the MessageLoop runs it.
   void RunScheduledTask();
 
   // Stop running task (if any) and abandon scheduled task (if any).
   void StopAndAbandon() {
     Stop();
     AbandonScheduledTask();
   }
 
   // When non-NULL, the scheduled_task_ is waiting in the MessageLoop to call
   // RunScheduledTask() at scheduled_run_time_.
   BaseTimerTaskInternal* scheduled_task_;
 
+  // The task runner on which the task should be scheduled. If it is null, the
+  // task runner for the current thread should be used.
+  scoped_refptr<SingleThreadTaskRunner> task_runner_;
+
   // Location in user code.
   tracked_objects::Location posted_from_;
   // Delay requested by user.
   TimeDelta delay_;
   // user_task_ is what the user wants to be run at desired_run_time_.
   base::Closure user_task_;
 
   // The estimated time that the MessageLoop will run the scheduled_task_ that
   // will call RunScheduledTask(). This time can be a "zero" TimeTicks if the
   // task must be run immediately.
@@ skipping 86 matching lines @@
       : Timer(posted_from, delay,
               base::Bind(method, base::Unretained(receiver)),
               false) {}
 
   void Reset() { Timer::Reset(); }
 };
 
 }  // namespace base
 
 #endif  // BASE_TIMER_TIMER_H_