Template methods on Timer classes instead of the classes themselves.

base/timer/timer_unittest.cc

 // Copyright (c) 2012 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.
 
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/test/test_simple_task_runner.h"
 #include "base/timer/timer.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ skipping 33 matching lines @@
 
  private:
   void Run() {
     *did_run_ = true;
     if (quit_message_loop_) {
       base::MessageLoop::current()->QuitWhenIdle();
     }
   }
 
   bool* did_run_;
-  base::OneShotTimer<OneShotTimerTester> timer_;
+  base::OneShotTimer timer_;
   const unsigned delay_ms_;
   bool quit_message_loop_;
 };
 
 class OneShotSelfDeletingTimerTester {
  public:
-  explicit OneShotSelfDeletingTimerTester(bool* did_run) :
-      did_run_(did_run),
-      timer_(new base::OneShotTimer<OneShotSelfDeletingTimerTester>()) {
-  }
+  explicit OneShotSelfDeletingTimerTester(bool* did_run)
+      : did_run_(did_run), timer_(new base::OneShotTimer()) {}
 
   void Start() {
     timer_->Start(FROM_HERE, TimeDelta::FromMilliseconds(10), this,
                   &OneShotSelfDeletingTimerTester::Run);
   }
 
  private:
   void Run() {
     *did_run_ = true;
     timer_.reset();
     base::MessageLoop::current()->QuitWhenIdle();
   }
 
   bool* did_run_;
-  scoped_ptr<base::OneShotTimer<OneShotSelfDeletingTimerTester> > timer_;
+  scoped_ptr<base::OneShotTimer> timer_;
 };
 
 class RepeatingTimerTester {
  public:
   explicit RepeatingTimerTester(bool* did_run, const TimeDelta& delay)
       : did_run_(did_run), counter_(10), delay_(delay) {
   }
 
   void Start() {
     timer_.Start(FROM_HERE, delay_, this, &RepeatingTimerTester::Run);
   }
 
  private:
   void Run() {
     if (--counter_ == 0) {
       *did_run_ = true;
       timer_.Stop();
       base::MessageLoop::current()->QuitWhenIdle();
     }
   }
 
   bool* did_run_;
   int counter_;
   TimeDelta delay_;
-  base::RepeatingTimer<RepeatingTimerTester> timer_;
+  base::RepeatingTimer timer_;
 };
 
 void RunTest_OneShotTimer(base::MessageLoop::Type message_loop_type) {
   base::MessageLoop loop(message_loop_type);
 
   bool did_run = false;
   OneShotTimerTester f(&did_run);
   f.Start();
 
   base::MessageLoop::current()->Run();
@@ skipping 83 matching lines @@
 
  private:
   bool signaled_ = false;
 };
 
 void RunTest_DelayTimer_NoCall(base::MessageLoop::Type message_loop_type) {
   base::MessageLoop loop(message_loop_type);
 
   // If Delay is never called, the timer shouldn't go off.
   DelayTimerTarget target;
-  base::DelayTimer<DelayTimerTarget> timer(FROM_HERE,
-      TimeDelta::FromMilliseconds(1), &target, &DelayTimerTarget::Signal);
+  base::DelayTimer timer(FROM_HERE, TimeDelta::FromMilliseconds(1), &target,
+                         &DelayTimerTarget::Signal);
 
   bool did_run = false;
   OneShotTimerTester tester(&did_run);
   tester.Start();
   base::MessageLoop::current()->Run();
 
   ASSERT_FALSE(target.signaled());
 }
 
 void RunTest_DelayTimer_OneCall(base::MessageLoop::Type message_loop_type) {
   base::MessageLoop loop(message_loop_type);
 
   DelayTimerTarget target;
-  base::DelayTimer<DelayTimerTarget> timer(FROM_HERE,
-      TimeDelta::FromMilliseconds(1), &target, &DelayTimerTarget::Signal);
+  base::DelayTimer timer(FROM_HERE, TimeDelta::FromMilliseconds(1), &target,
+                         &DelayTimerTarget::Signal);
   timer.Reset();
 
   bool did_run = false;
   OneShotTimerTester tester(&did_run, 100 /* milliseconds */);
   tester.Start();
   base::MessageLoop::current()->Run();
 
   ASSERT_TRUE(target.signaled());
 }
 
 struct ResetHelper {
-  ResetHelper(base::DelayTimer<DelayTimerTarget>* timer,
-              DelayTimerTarget* target)
-      : timer_(timer),
-        target_(target) {
-  }
+  ResetHelper(base::DelayTimer* timer, DelayTimerTarget* target)
+      : timer_(timer), target_(target) {}
 
   void Reset() {
     ASSERT_FALSE(target_->signaled());
     timer_->Reset();
   }
 
  private:
-  base::DelayTimer<DelayTimerTarget> *const timer_;
-  DelayTimerTarget *const target_;
+  base::DelayTimer* const timer_;
+  DelayTimerTarget* const target_;
 };
 
 void RunTest_DelayTimer_Reset(base::MessageLoop::Type message_loop_type) {
   base::MessageLoop loop(message_loop_type);
 
   // If Delay is never called, the timer shouldn't go off.
   DelayTimerTarget target;
-  base::DelayTimer<DelayTimerTarget> timer(FROM_HERE,
-      TimeDelta::FromMilliseconds(50), &target, &DelayTimerTarget::Signal);
+  base::DelayTimer timer(FROM_HERE, TimeDelta::FromMilliseconds(50), &target,
+                         &DelayTimerTarget::Signal);
   timer.Reset();
 
   ResetHelper reset_helper(&timer, &target);
 
-  base::OneShotTimer<ResetHelper> timers[20];
+  base::OneShotTimer timers[20];
   for (size_t i = 0; i < arraysize(timers); ++i) {
     timers[i].Start(FROM_HERE, TimeDelta::FromMilliseconds(i * 10),
                     &reset_helper, &ResetHelper::Reset);
   }
 
   bool did_run = false;
   OneShotTimerTester tester(&did_run, 300);
   tester.Start();
   base::MessageLoop::current()->Run();
 
   ASSERT_TRUE(target.signaled());
 }
 
 class DelayTimerFatalTarget {
  public:
   void Signal() {
     ASSERT_TRUE(false);
   }
 };
 
 
 void RunTest_DelayTimer_Deleted(base::MessageLoop::Type message_loop_type) {
   base::MessageLoop loop(message_loop_type);
 
   DelayTimerFatalTarget target;
 
   {
-    base::DelayTimer<DelayTimerFatalTarget> timer(
-        FROM_HERE, TimeDelta::FromMilliseconds(50), &target,
-        &DelayTimerFatalTarget::Signal);
+    base::DelayTimer timer(FROM_HERE, TimeDelta::FromMilliseconds(50), &target,
+                           &DelayTimerFatalTarget::Signal);
     timer.Reset();
   }
 
   // When the timer is deleted, the DelayTimerFatalTarget should never be
   // called.
   base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(100));
 }
 
 }  // namespace
 
@@ skipping 224 matching lines @@
                 base::Bind(&SetCallbackHappened1));
     timer.Reset();
     // Since Reset happened before task ran, the user_task must not be cleared:
     ASSERT_FALSE(timer.user_task().is_null());
     base::MessageLoop::current()->Run();
     EXPECT_TRUE(g_callback_happened1);
   }
 }
 
 }  // namespace