Update base/timer.h code to pass through Location from call sites.

base/timer.h

 // Copyright (c) 2011 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 69 matching lines @@
     DCHECK(IsRunning());
     return delayed_task_->delay_;
   }
 
  protected:
   BaseTimer_Helper() : delayed_task_(NULL) {}
 
   // We have access to the timer_ member so we can orphan this task.
   class TimerTask : public Task {
    public:
-    explicit TimerTask(TimeDelta delay) : timer_(NULL), delay_(delay) {
+    explicit TimerTask(TimeDelta delay,
+                       const tracked_objects::Location& posted_from)
+        : timer_(NULL),
+          delay_(delay),
+          posted_from_(posted_from) {
     }
     virtual ~TimerTask() {}
     BaseTimer_Helper* timer_;
     TimeDelta delay_;
+    tracked_objects::Location posted_from_;
   };
 
   // Used to orphan delayed_task_ so that when it runs it does nothing.
   void OrphanDelayedTask();
 
   // Used to initiated a new delayed task.  This has the side-effect of
   // orphaning delayed_task_ if it is non-null.
   void InitiateDelayedTask(TimerTask* timer_task);
 
   TimerTask* delayed_task_;
 
   DISALLOW_COPY_AND_ASSIGN(BaseTimer_Helper);
 };
 
 //-----------------------------------------------------------------------------
 // This class is an implementation detail of OneShotTimer and RepeatingTimer.
 // Please do not use this class directly.
 template <class Receiver, bool kIsRepeating>
 class BaseTimer : public BaseTimer_Helper {
  public:
   typedef void (Receiver::*ReceiverMethod)();
 
   // Call this method to start the timer.  It is an error to call this method
   // while the timer is already running.
-  void Start(TimeDelta delay, Receiver* receiver, ReceiverMethod method) {
+  void Start(TimeDelta delay,

[darin (slow to review), 2011/08/31 21:27:38]

consistency nit:  it'd be nice to place the Location parameter first, like it is
for PostTask.  that way whenever we have a parameter like this, people can just
remember that they should always type FROM_HERE first, and then list the other
parameters.

[jbates, 2011/08/31 23:01:59]

Done.

+             Receiver* receiver,
+             ReceiverMethod method,
+             const tracked_objects::Location& posted_from) {
     DCHECK(!IsRunning());
-    InitiateDelayedTask(new TimerTask(delay, receiver, method));
+    InitiateDelayedTask(new TimerTask(delay, receiver, method, posted_from));
   }
 
   // Call this method to stop the timer.  It is a no-op if the timer is not
   // running.
   void Stop() {
     OrphanDelayedTask();
   }
 
   // Call this method to reset the timer delay of an already running timer.
   void Reset() {
     DCHECK(IsRunning());
     InitiateDelayedTask(static_cast<TimerTask*>(delayed_task_)->Clone());
   }
 
  private:
   typedef BaseTimer<Receiver, kIsRepeating> SelfType;
 
   class TimerTask : public BaseTimer_Helper::TimerTask {
    public:
-    TimerTask(TimeDelta delay, Receiver* receiver, ReceiverMethod method)
-        : BaseTimer_Helper::TimerTask(delay),
+    TimerTask(TimeDelta delay,
+              Receiver* receiver,
+              ReceiverMethod method,
+              const tracked_objects::Location& posted_from)
+        : BaseTimer_Helper::TimerTask(delay, posted_from),
           receiver_(receiver),
           method_(method) {
     }
 
     virtual ~TimerTask() {
       // This task may be getting cleared because the MessageLoop has been
       // destructed.  If so, don't leave the Timer with a dangling pointer
       // to this now-defunct task.
       ClearBaseTimer();
     }
 
     virtual void Run() {
       if (!timer_)  // timer_ is null if we were orphaned.
         return;
       if (kIsRepeating)
         ResetBaseTimer();
       else
         ClearBaseTimer();
       DispatchToMethod(receiver_, method_, Tuple0());
     }
 
     TimerTask* Clone() const {
-      return new TimerTask(delay_, receiver_, method_);
+      return new TimerTask(delay_, receiver_, method_, posted_from_);
     }
 
    private:
     // Inform the Base that the timer is no longer active.
     void ClearBaseTimer() {
       if (timer_) {
         SelfType* self = static_cast<SelfType*>(timer_);
         // It is possible that the Timer has already been reset, and that this
         // Task is old.  So, if the Timer points to a different task, assume
         // that the Timer has already taken care of properly setting the task.
@@ skipping 38 matching lines @@
 // passed since the last call to Reset, the callback is made. Once the callback
 // has been made, it's inactive until Reset is called again.
 //
 // If destroyed, the timeout is canceled and will not occur even if already
 // inflight.
 template <class Receiver>
 class DelayTimer {
  public:
   typedef void (Receiver::*ReceiverMethod)();
 
-  DelayTimer(TimeDelta delay, Receiver* receiver, ReceiverMethod method)
+  DelayTimer(TimeDelta delay,
+             Receiver* receiver,
+             ReceiverMethod method,
+             const tracked_objects::Location& posted_from)
       : receiver_(receiver),
         method_(method),
-        delay_(delay) {
+        delay_(delay),
+        posted_from_(posted_from) {
   }
 
   void Reset() {
     DelayFor(delay_);
   }
 
  private:
   void DelayFor(TimeDelta delay) {
     trigger_time_ = TimeTicks::Now() + delay;
 
     // If we already have a timer that will expire at or before the given delay,
     // then we have nothing more to do now.
     if (timer_.IsRunning() && timer_.GetCurrentDelay() <= delay)
       return;
 
     // The timer isn't running, or will expire too late, so restart it.
     timer_.Stop();
-    timer_.Start(delay, this, &DelayTimer<Receiver>::Check);
+    timer_.Start(delay, this, &DelayTimer<Receiver>::Check, posted_from_);
   }
 
   void Check() {
     if (trigger_time_.is_null())
       return;
 
     // If we have not waited long enough, then wait some more.
     const TimeTicks now = TimeTicks::Now();
     if (now < trigger_time_) {
       DelayFor(trigger_time_ - now);
       return;
     }
 
     (receiver_->*method_)();
   }
 
   Receiver *const receiver_;
   const ReceiverMethod method_;
   const TimeDelta delay_;
+  tracked_objects::Location posted_from_;
 
   OneShotTimer<DelayTimer<Receiver> > timer_;
   TimeTicks trigger_time_;
 };
 
 }  // namespace base
 
 #endif  // BASE_TIMER_H_