Remove Task inheritance from base::Timer.

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 32 matching lines @@
 #pragma once
 
 // IMPORTANT: If you change timer code, make sure that all tests (including
 // 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/location.h"
 #include "base/logging.h"
-#include "base/task.h"
 #include "base/time.h"
 
 class MessageLoop;
 
 namespace base {
 
 //-----------------------------------------------------------------------------
 // This class is an implementation detail of OneShotTimer and RepeatingTimer.
 // Please do not use this class directly.
 //
@@ skipping 15 matching lines @@
   // the timer is running!
   TimeDelta GetCurrentDelay() const {
     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 {
+  class TimerTask {
    public:
     TimerTask(const tracked_objects::Location& posted_from,
               TimeDelta delay)
         : posted_from_(posted_from),
           timer_(NULL),
           delay_(delay) {
     }
     virtual ~TimerTask() {}
+    virtual void Run() = 0;
     tracked_objects::Location posted_from_;
     BaseTimer_Helper* timer_;
     TimeDelta delay_;
   };
 
   // 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.
@@ skipping 48 matching lines @@
           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() {

[willchan no longer on Chromium, 2011/12/14 01:38:05]

How about we get rid of this TimerTask class and just move everything into the
base class. Change TimerTask to take a Closure instead of
Receiver+ReceiverMethod.

[dcheng, 2011/12/14 02:07:07]

Won't that require me to include bind.h in timer.h because of the templating? I
thought that was a pattern to be avoided, due to the complexity of bind.h.

[willchan no longer on Chromium, 2011/12/14 19:58:53]

Closure does not require bind.h. The base::Bind() call would be done at the
callsite to pass a Closure into Start(). And Start() itself should be
implemented in the .cc file. There's no need to template BaseTimer if we use a
Closure, unless we want to keep is_repeating as a template parameter.

[dcheng, 2011/12/14 21:15:00]

Ah. I was going to keep kIsRepeating as a template parameter so the branches
could be optimized out. For the moment, maybe it'd be more appropriate to do the
straightforward conversion; any improvements could be made in followup patches
with appropriate benchmarks, etc.

       if (!timer_)  // timer_ is null if we were orphaned.
         return;
       if (kIsRepeating)
         ResetBaseTimer();
       else
         ClearBaseTimer();
-      DispatchToMethod(receiver_, method_, Tuple0());
+      (receiver_->*method_)();
     }
 
     TimerTask* Clone() const {
       return new TimerTask(posted_from_, delay_, receiver_, method_);
     }
 
    private:
     // Inform the Base that the timer is no longer active.
     void ClearBaseTimer() {
       if (timer_) {
@@ skipping 96 matching lines @@
   const ReceiverMethod method_;
   const TimeDelta delay_;
 
   OneShotTimer<DelayTimer<Receiver> > timer_;
   TimeTicks trigger_time_;
 };
 
 }  // namespace base
 
 #endif  // BASE_TIMER_H_