Eliminate the TimerManager by pulling its priority queue into MessageLoop....

base/task.h

 // Copyright (c) 2006-2008 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.
 
 #ifndef BASE_TASK_H__
 #define BASE_TASK_H__
 
 #include <set>
 
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "base/non_thread_safe.h"
 #include "base/revocable_store.h"
 #include "base/time.h"
 #include "base/tracked.h"
 #include "base/tuple.h"
 
-namespace base {
-class TimerManager;
-}
-
-//------------------------------------------------------------------------------
-// Base class of Task, where we store info to help MessageLoop handle PostTask()
-// elements of Task processing.
-
-class Task;
-
-// TODO(darin): Eliminate TaskBase.  This data is ML specific and is not
-// applicable to other uses of Task.
-class TaskBase : public tracked_objects::Tracked {
- public:
-  TaskBase() { Reset(); }
-  virtual ~TaskBase() {}
-
-  // Use this method to adjust the priority given to a task by MessageLoop.
-  void set_priority(int priority) { priority_ = priority; }
-  int priority() const { return priority_; }
-
-  // Change whether this task will run in nested message loops.
-  void set_nestable(bool nestable) { nestable_ = nestable; }
-  bool nestable() { return nestable_; }
-
-  // Used to manage a linked-list of tasks.
-  Task* next_task() const { return next_task_; }
-  void set_next_task(Task* next) { next_task_ = next; }
-
- protected:
-  // If a derived class wishes to re-use this instance, then it should override
-  // this method.  This method is called by MessageLoop after processing a task
-  // that was submitted to PostTask() or PostDelayedTask().  As seen, by default
-  // it deletes the task, but the derived class can change this behaviour and
-  // recycle (re-use) it.  Be sure to call Reset() if you recycle it!
-  virtual void RecycleOrDelete() { delete this; }
-
-  // Call this method if you are trying to recycle a Task.  Note that only
-  // derived classes should attempt this feat, as a replacement for creating a
-  // new instance.
-  void Reset() {
-    priority_ = 0;
-    delayed_run_time_ = Time();
-    next_task_ = NULL;
-    nestable_ = true;
-    owned_by_message_loop_ = false;
-  }
-
- private:
-  friend class base::TimerManager;  // To check is_owned_by_message_loop().
-  friend class MessageLoop;         // To maintain posted_task_delay().
-
-  // Priority for execution by MessageLoop. 0 is default. Higher means run
-  // sooner, and lower (including negative) means run less soon.
-  int priority_;
-
-  // The time when a delayed task should be run.
-  Time delayed_run_time_;
-
-  // When tasks are collected into a queue by MessageLoop, this member is used
-  // to form a null terminated list.
-  Task* next_task_;
-
-  // A nestable task will run in nested message loops, otherwise it will run
-  // only in the top level message loop.
-  bool nestable_;
-
-  // True if this Task is owned by the message loop.
-  bool owned_by_message_loop_;
-
-  DISALLOW_COPY_AND_ASSIGN(TaskBase);
-};
-
-
 // Task ------------------------------------------------------------------------
 //
 // A task is a generic runnable thingy, usually used for running code on a
 // different thread or for scheduling future tasks off of the message loop.
 
-class Task : public TaskBase {
+class Task : public tracked_objects::Tracked {
  public:
   Task() {}
   virtual ~Task() {}
 
   // Tasks are automatically deleted after Run is called.
   virtual void Run() = 0;
 };
 
 class CancelableTask : public Task {
  public:
@@ skipping 181 matching lines @@
   DISALLOW_EVIL_CONSTRUCTORS(ScopedRunnableMethodFactory);
 };
 
 // General task implementations ------------------------------------------------
 
 // Task to delete an object
 template<class T>
 class DeleteTask : public CancelableTask {
  public:
   explicit DeleteTask(T* obj) : obj_(obj) {
-    set_nestable(false);
   }
   virtual void Run() {
     delete obj_;
   }
   virtual void Cancel() {
     obj_ = NULL;
   }
  private:
   T* obj_;
 };
 
 // Task to Release() an object
 template<class T>
 class ReleaseTask : public CancelableTask {
  public:
   explicit ReleaseTask(T* obj) : obj_(obj) {
-    set_nestable(false);
   }
   virtual void Run() {
     if (obj_)
       obj_->Release();
   }
   virtual void Cancel() {
     obj_ = NULL;
   }
  private:
   T* obj_;
@@ skipping 369 matching lines @@
           typename Arg3, typename Arg4, typename Arg5>
 typename Callback5<Arg1, Arg2, Arg3, Arg4, Arg5>::Type* NewCallback(
     T* object,
     void (T::*method)(Arg1, Arg2, Arg3, Arg4, Arg5)) {
   return new CallbackImpl<T, void (T::*)(Arg1, Arg2, Arg3, Arg4, Arg5),
       Tuple5<Arg1, Arg2, Arg3, Arg4, Arg5> >(object, method);
 }
 
 #endif  // BASE_TASK_H__