Add a Clock and TickClock interface for mocking out time

sync/notifier/ack_tracker.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 "sync/notifier/ack_tracker.h"
 
 #include <algorithm>
 #include <iterator>
 #include <utility>
 
 #include "base/callback.h"
 #include "base/stl_util.h"
+#include "base/time/tick_clock.h"
 #include "google/cacheinvalidation/include/types.h"
 
 namespace syncer {
 
 namespace {
 
 // All times are in milliseconds.
 const net::BackoffEntry::Policy kDefaultBackoffPolicy = {
   // Number of initial errors (in sequence) to ignore before applying
   // exponential back-off rules.
@@ skipping 43 matching lines @@
 }
 
 AckTracker::Entry::Entry(scoped_ptr<net::BackoffEntry> backoff,
                          const ObjectIdSet& ids)
     : backoff(backoff.Pass()), ids(ids) {
 }
 
 AckTracker::Entry::~Entry() {
 }
 
-AckTracker::AckTracker(Delegate* delegate)
-    : now_callback_(base::Bind(&base::TimeTicks::Now)),
-      create_backoff_entry_callback_(base::Bind(&CreateDefaultBackoffEntry)),
+AckTracker::AckTracker(base::TickClock* tick_clock, Delegate* delegate)
+    : create_backoff_entry_callback_(base::Bind(&CreateDefaultBackoffEntry)),
+      tick_clock_(tick_clock),
       delegate_(delegate) {
+  DCHECK(tick_clock_);
   DCHECK(delegate_);
 }
 
 AckTracker::~AckTracker() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   Clear();
 }
 
 void AckTracker::Clear() {
@@ skipping 42 matching lines @@
   NudgeTimer();
 }
 
 void AckTracker::NudgeTimer() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (queue_.empty()) {
     return;
   }
 
-  const base::TimeTicks now = now_callback_.Run();
+  const base::TimeTicks now = tick_clock_->NowTicks();
   // There are two cases when the timer needs to be started:
   // 1. |desired_run_time_| is in the past. By definition, the timer has already
   //    fired at this point. Since the queue is non-empty, we need to set the
   //    timer to fire again.
   // 2. The timer is already running but we need it to fire sooner if the first
   //    entry's timeout occurs before |desired_run_time_|.
   if (desired_run_time_ <= now || queue_.begin()->first < desired_run_time_) {
     base::TimeDelta delay = queue_.begin()->first - now;
     if (delay < base::TimeDelta()) {
       delay = base::TimeDelta();
     }
     timer_.Start(FROM_HERE, delay, this, &AckTracker::OnTimeout);
     desired_run_time_ = queue_.begin()->first;
   }
 }
 
 void AckTracker::OnTimeout() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
-  OnTimeoutAt(now_callback_.Run());
+  OnTimeoutAt(tick_clock_->NowTicks());
 }
 
 void AckTracker::OnTimeoutAt(base::TimeTicks now) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (queue_.empty())
     return;
 
   ObjectIdSet expired_ids;
   std::multimap<base::TimeTicks, Entry*>::iterator end =
       queue_.upper_bound(now);
   std::vector<Entry*> expired_entries;
   for (std::multimap<base::TimeTicks, Entry*>::iterator it = queue_.begin();
        it != end; ++it) {
     expired_ids.insert(it->second->ids.begin(), it->second->ids.end());
     it->second->backoff->InformOfRequest(false /* succeeded */);
     expired_entries.push_back(it->second);
   }
   queue_.erase(queue_.begin(), end);
   for (std::vector<Entry*>::const_iterator it = expired_entries.begin();
        it != expired_entries.end(); ++it) {
     queue_.insert(std::make_pair((*it)->backoff->GetReleaseTime(), *it));
   }
   delegate_->OnTimeout(expired_ids);
   NudgeTimer();
 }
 
 // Testing helpers.
-void AckTracker::SetNowCallbackForTest(
-    const NowCallback& now_callback) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-
-  now_callback_ = now_callback;
-}
-
 void AckTracker::SetCreateBackoffEntryCallbackForTest(
     const CreateBackoffEntryCallback& create_backoff_entry_callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   create_backoff_entry_callback_ = create_backoff_entry_callback;
 }
 
 bool AckTracker::TriggerTimeoutAtForTest(base::TimeTicks now) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   bool no_timeouts_before_now = (queue_.lower_bound(now) == queue_.begin());
   OnTimeoutAt(now);
   return no_timeouts_before_now;
 }
 
 bool AckTracker::IsQueueEmptyForTest() const {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   return queue_.empty();
 }
 
 const base::Timer& AckTracker::GetTimerForTest() const {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   return timer_;
 }
 
 }  // namespace syncer