Template methods on Timer classes instead of the classes themselves.

chrome/browser/chromeos/system/automatic_reboot_manager.cc

 // Copyright (c) 2013 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 "chrome/browser/chromeos/system/automatic_reboot_manager.h"
 
 #include <fcntl.h>
 #include <sys/stat.h>
 #include <sys/types.h>
 
@@ skipping 160 matching lines @@
   dbus_thread_manager->GetUpdateEngineClient()->AddObserver(this);
 
   // If no user is logged in, a reboot may be performed whenever the user is
   // idle. Start listening for user activity to determine whether the user is
   // idle or not.
   if (!user_manager::UserManager::Get()->IsUserLoggedIn()) {
     if (ui::UserActivityDetector::Get())
       ui::UserActivityDetector::Get()->AddObserver(this);
     notification_registrar_.Add(this, chrome::NOTIFICATION_LOGIN_USER_CHANGED,
         content::NotificationService::AllSources());
-    login_screen_idle_timer_.reset(
-        new base::OneShotTimer<AutomaticRebootManager>);
+    login_screen_idle_timer_.reset(new base::OneShotTimer);
     OnUserActivity(NULL);
   }
 
   // In a regular browser, base::ThreadTaskRunnerHandle::Get() and
   // base::ThreadTaskRunnerHandle::Get() return pointers to the same object.
   // In unit tests, using base::ThreadTaskRunnerHandle::Get() has the advantage
   // that it allows a custom base::SingleThreadTaskRunner to be injected.
   base::SequencedWorkerPool* worker_pool =
       content::BrowserThread::GetBlockingPool();
   worker_pool->PostSequencedWorkerTaskWithShutdownBehavior(
@@ skipping 52 matching lines @@
   Reschedule();
 }
 
 void AutomaticRebootManager::OnUserActivity(const ui::Event* event) {
   if (!login_screen_idle_timer_)
     return;
 
   // Destroying and re-creating the timer ensures that Start() posts a fresh
   // task with a delay of exactly |kLoginManagerIdleTimeoutMs|, ensuring that
   // the timer fires predictably in tests.
-  login_screen_idle_timer_.reset(
-      new base::OneShotTimer<AutomaticRebootManager>);
+  login_screen_idle_timer_.reset(new base::OneShotTimer);
   login_screen_idle_timer_->Start(
       FROM_HERE,
       base::TimeDelta::FromMilliseconds(kLoginManagerIdleTimeoutMs),
       base::Bind(&AutomaticRebootManager::MaybeReboot,
                  base::Unretained(this),
                  false));
 }
 
 void AutomaticRebootManager::Observe(
     int type,
@@ skipping 89 matching lines @@
   // Safeguard against reboot loops: Ensure that the uptime after which a reboot
   // is actually requested and the grace period begins is never less than
   // |kMinRebootUptimeMs|.
   const base::TimeTicks now = clock_->NowTicks();
   const base::TimeTicks grace_start_time = std::max(reboot_request_time,
       boot_time_ + base::TimeDelta::FromMilliseconds(kMinRebootUptimeMs));
 
   // Set up a timer for the start of the grace period. If the grace period
   // started in the past, the timer is still used with its delay set to zero.
   if (!grace_start_timer_)
-    grace_start_timer_.reset(new base::OneShotTimer<AutomaticRebootManager>);
+    grace_start_timer_.reset(new base::OneShotTimer);
   grace_start_timer_->Start(FROM_HERE,
                             std::max(grace_start_time - now, kZeroTimeDelta),
                             base::Bind(&AutomaticRebootManager::RequestReboot,
                                        base::Unretained(this)));
 
   const base::TimeTicks grace_end_time = grace_start_time +
       base::TimeDelta::FromMilliseconds(kGracePeriodMs);
   // Set up a timer for the end of the grace period. If the grace period ended
   // in the past, the timer is still used with its delay set to zero.
   if (!grace_end_timer_)
-    grace_end_timer_.reset(new base::OneShotTimer<AutomaticRebootManager>);
+    grace_end_timer_.reset(new base::OneShotTimer);
   grace_end_timer_->Start(FROM_HERE,
                           std::max(grace_end_time - now, kZeroTimeDelta),
                           base::Bind(&AutomaticRebootManager::Reboot,
                                      base::Unretained(this)));
 }
 
 void AutomaticRebootManager::RequestReboot() {
   reboot_requested_ = true;
   DCHECK_NE(AutomaticRebootManagerObserver::REBOOT_REASON_UNKNOWN,
             reboot_reason_);
@@ skipping 25 matching lines @@
   }
 
   login_screen_idle_timer_.reset();
   grace_start_timer_.reset();
   grace_end_timer_.reset();
   DBusThreadManager::Get()->GetPowerManagerClient()->RequestRestart();
 }
 
 }  // namespace system
 }  // namespace chromeos