Convert SessionLengthLimiter to OneShotTimer

chrome/browser/chromeos/power/session_length_limiter.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 "chrome/browser/chromeos/power/session_length_limiter.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/prefs/pref_registry_simple.h"
 #include "base/prefs/pref_service.h"
 #include "base/prefs/public/pref_service_base.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/lifetime/application_lifetime.h"
 #include "chrome/common/pref_names.h"
 
 namespace chromeos {
 
 namespace {
 
 // The minimum session time limit that can be set.
 const int kSessionLengthLimitMinMs = 30 * 1000; // 30 seconds.
 
 // The maximum session time limit that can be set.
 const int kSessionLengthLimitMaxMs = 24 * 60 * 60 * 1000; // 24 hours.
 
-// The interval at which to fire periodic callbacks and check whether the
-// session time limit has been reached.
-const int kSessionLengthLimitTimerIntervalMs = 1000;
-
 // A default delegate implementation that returns the current time and does end
 // the current user's session when requested. This can be replaced with a mock
 // in tests.
 class SessionLengthLimiterDelegateImpl : public SessionLengthLimiter::Delegate {
  public:
   SessionLengthLimiterDelegateImpl();
   virtual ~SessionLengthLimiterDelegateImpl();
 
   virtual const base::Time GetCurrentTime() const OVERRIDE;
   virtual void StopSession() OVERRIDE;
@@ skipping 47 matching lines @@
     session_start_time = now;
   }
   session_start_time_ = base::Time::FromInternalValue(session_start_time);
 
   // Listen for changes to the session length limit.
   pref_change_registrar_.Init(local_state);
   pref_change_registrar_.Add(
       prefs::kSessionLengthLimit,
       base::Bind(&SessionLengthLimiter::OnSessionLengthLimitChanged,
                  base::Unretained(this)));
+
+  // Handle the current session length limit, if any.
   OnSessionLengthLimitChanged();
 }
 
 SessionLengthLimiter::~SessionLengthLimiter() {
 }
 
 void SessionLengthLimiter::OnSessionLengthLimitChanged() {
   DCHECK(thread_checker_.CalledOnValidThread());
+
+  // Stop any currently running timer.
+  if (timer_)
+    timer_->Stop();
+
   int limit;
   const PrefServiceBase::Preference* session_length_limit_pref =
       pref_change_registrar_.prefs()->
           FindPreference(prefs::kSessionLengthLimit);
-  // If no session length limit is set, stop the timer.
   if (session_length_limit_pref->IsDefaultValue() ||
       !session_length_limit_pref->GetValue()->GetAsInteger(&limit)) {
-    session_length_limit_ = base::TimeDelta();
-    StopTimer();
+    // If no session length limit is set, destroy the timer.
+    timer_.reset();

[Daniel Erat, 2013/02/12 20:40:43]

what's the reason to destroy the timer here?

[bartfab (slow), 2013/02/13 10:32:59]

This simply frees up the memory that the timer was occupying. The whole
indirection via a scoped_ptr exists as reviewers felt strongly that no timer
object should be occupying memory if the policy is disabled.

If the policy is disabled to begin with, no timer gets created. If the policy is
enabled and then later disabled, it seems only prudent to clean up and destry
the timer.

     return;
   }
 
-  // If a session length limit is set, clamp it to the valid range and start
-  // the timer.
-  session_length_limit_ = base::TimeDelta::FromMilliseconds(
-      std::min(std::max(limit, kSessionLengthLimitMinMs),
-               kSessionLengthLimitMaxMs));
-  StartTimer();
-}
+  // Clamp the session length limit to the valid range.
+  const base::TimeDelta session_length_limit =
+      base::TimeDelta::FromMilliseconds(std::min(std::max(
+          limit, kSessionLengthLimitMinMs), kSessionLengthLimitMaxMs));
 
-void SessionLengthLimiter::StartTimer() {
-  if (repeating_timer_ && repeating_timer_->IsRunning())
+  // Calculate the remaining session time.
+  const base::TimeDelta remaining = session_length_limit -
+      (delegate_->GetCurrentTime() - session_start_time_);
+
+  // Log out the user immediately if the session length limit has been reached
+  // or exceeded.
+  if (remaining <= base::TimeDelta()) {
+    delegate_->StopSession();
     return;
-  if (!repeating_timer_)
-    repeating_timer_.reset(new base::RepeatingTimer<SessionLengthLimiter>);
-  repeating_timer_->Start(
-      FROM_HERE,
-      base::TimeDelta::FromMilliseconds(kSessionLengthLimitTimerIntervalMs),
-      this,
-      &SessionLengthLimiter::UpdateRemainingTime);
-}
+  }
 
-void SessionLengthLimiter::StopTimer() {
-  if (!repeating_timer_)
-    return;
-  repeating_timer_.reset();
-  UpdateRemainingTime();
-}
-
-void SessionLengthLimiter::UpdateRemainingTime() {
-  const base::TimeDelta kZeroTimeDelta = base::TimeDelta();
-  // If no session length limit is set, return.
-  if (session_length_limit_ == kZeroTimeDelta)
-    return;
-
-  // Calculate the remaining session time, clamping so that it never falls below
-  // zero.
-  base::TimeDelta remaining = session_length_limit_ -
-      (delegate_->GetCurrentTime() - session_start_time_);
-  if (remaining < kZeroTimeDelta)
-    remaining = kZeroTimeDelta;
-
-  // End the session if the remaining time reaches zero.
-  if (remaining == base::TimeDelta())
-    delegate_->StopSession();
+  // Set a timer to log out the user when the session length limit is reached.
+  if (!timer_)
+    timer_.reset(new base::OneShotTimer<SessionLengthLimiter::Delegate>);
+  timer_->Start(FROM_HERE, remaining, delegate_.get(),
+                &SessionLengthLimiter::Delegate::StopSession);
 }
 
 }  // namespace chromeos