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 55 matching lines @@
       ClearBaseTimer();
     }
 
     virtual void Run() {
       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_