Simplify OneShotTimer and RepeatingTimer. Fix up all consumers.

Major changes:

OneShotTimer and RepeatingTimer become template classes that no longer require
a Task or a Timer object.  They just use PostDelayedTask.  Under the hood that
still uses a Timer object.

The API is much simpler for consumers as they now no longer need to worry about
allocating a Task or managing the lifetime of the object pointer held by the
Task.

I added some new unit tests to timer_unittest.cc to cover the API.

I preserved the old TimerManager / Timer API for now, but I plan to soon kill
it.

R=brettw
BUG=1346553



git-svn-id: svn://svn.chromium.org/chrome/trunk/src@1502 0039d316-1c4b-4281-b951-d872f2087c98

3 files changed, 17 insertions, 31 deletions

diff --git a/net/disk_cache/backend_impl.cc b/net/disk_cache/backend_impl.cc
index 18025a1..7deb343 100644
--- a/net/disk_cache/backend_impl.cc
+++ b/net/disk_cache/backend_impl.cc
@@ -132,23 +132,10 @@ bool DelayedCacheCleanup(const std::wstring& full_path) {
   return true;
 }
 
-// ------------------------------------------------------------------------
-
-class TimerTask : public Task {
- public:
-  explicit TimerTask(disk_cache::BackendImpl* backend) : backend_(backend) {}
-  ~TimerTask() {}
-
-  virtual void Run() {
-    backend_->OnStatsTimer();
-  }
-
- private:
-  disk_cache::BackendImpl* backend_;
-};
-
 }  // namespace
 
+// ------------------------------------------------------------------------
+
 namespace disk_cache {
 
 // If the initialization of the cache fails, and force is true, we will discard
@@ -201,10 +188,8 @@ bool BackendImpl::Init() {
   if (!restarted_) {
     // Create a recurrent timer of 30 secs.
     int timer_delay = unit_test_ ? 1000 : 30000;
-    TimerTask* task = new TimerTask(this);
-    timer_task_ = task;
-    timer_ = MessageLoop::current()->timer_manager()->StartTimer(timer_delay,
-                                                                 task, true);
+    timer_.Start(TimeDelta::FromMilliseconds(timer_delay), this,
+                 &BackendImpl::OnStatsTimer);
   }
 
   init_ = true;
@@ -238,9 +223,7 @@ BackendImpl::~BackendImpl() {
   if (!init_)
     return;
 
-  MessageLoop::current()->timer_manager()->StopTimer(timer_);
-  delete timer_;
-  delete timer_task_;
+  timer_.Stop();
 
   WaitForPendingIO(&num_pending_io_);
   DCHECK(!num_refs_);
diff --git a/net/disk_cache/backend_impl.h b/net/disk_cache/backend_impl.h
index 04a228d..7a39238 100644
--- a/net/disk_cache/backend_impl.h
+++ b/net/disk_cache/backend_impl.h
@@ -7,14 +7,13 @@
 #ifndef NET_DISK_CACHE_BACKEND_IMPL_H__
 #define NET_DISK_CACHE_BACKEND_IMPL_H__
 
+#include "base/timer.h"
 #include "net/disk_cache/block_files.h"
 #include "net/disk_cache/disk_cache.h"
 #include "net/disk_cache/rankings.h"
 #include "net/disk_cache/stats.h"
 #include "net/disk_cache/trace.h"
 
-class Timer;
-
 namespace disk_cache {
 
 // This class implements the Backend interface. An object of this
@@ -176,8 +175,7 @@ class BackendImpl : public Backend {
   bool disabled_;
 
   Stats stats_;  // Usage statistcs.
-  Task* timer_task_;
-  Timer* timer_;  // Usage timer.
+  base::RepeatingTimer<BackendImpl> timer_;  // Usage timer.
   TraceObject trace_object_;  // Inits and destroys internal tracing.
 
   DISALLOW_EVIL_CONSTRUCTORS(BackendImpl);
diff --git a/net/disk_cache/stress_cache.cc b/net/disk_cache/stress_cache.cc
index 10058f0..864309a 100644
--- a/net/disk_cache/stress_cache.cc
+++ b/net/disk_cache/stress_cache.cc
@@ -143,6 +143,9 @@ class CrashTask : public Task {
   ~CrashTask() {}
 
   virtual void Run() {
+    // Keep trying to run.
+    RunSoon(MessageLoop::current());
+
     if (g_crashing)
       return;
 
@@ -151,6 +154,12 @@ class CrashTask : public Task {
       TerminateProcess(GetCurrentProcess(), kExpectedCrash);
     }
   }
+
+  static void RunSoon(MessageLoop* target_loop) {
+    int task_delay = 10000;  // 10 seconds
+    CrashTask* task = new CrashTask();
+    target_loop->PostDelayedTask(FROM_HERE, task, task_delay);
+  }
 };
 
 // We leak everything here :)
@@ -159,11 +168,7 @@ bool StartCrashThread() {
   if (!thread->Start())
     return false;
 
-  // Create a recurrent timer of 10 secs.
-  int timer_delay = 10000;
-  CrashTask* task = new CrashTask();
-  thread->message_loop()->timer_manager()->StartTimer(timer_delay, task, true);
-
+  CrashTask::RunSoon(thread->message_loop());
   return true;
 }