[SyncFS] Make base::TimeTicks::Now() dependency in SyncProcessRunner injectable.

chrome/browser/sync_file_system/sync_process_runner.cc

 // Copyright 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/sync_file_system/sync_process_runner.h"
 
 #include "base/format_macros.h"
 #include "chrome/browser/sync_file_system/logger.h"
 
 namespace sync_file_system {
@@ skipping 26 matching lines @@
   virtual bool IsRunning() OVERRIDE {
     return timer_.IsRunning();
   }
 
   virtual void Start(const tracked_objects::Location& from_here,
                      const base::TimeDelta& delay,
                      const base::Closure& closure) OVERRIDE {
     timer_.Start(from_here, delay, closure);
   }
 
+  virtual base::TimeTicks Now() const OVERRIDE {
+    return base::TimeTicks::Now();
+  }
+
   virtual ~BaseTimerHelper() {}
 
  private:
   base::OneShotTimer<SyncProcessRunner> timer_;
 
   DISALLOW_COPY_AND_ASSIGN(BaseTimerHelper);
 };
 
 bool WasSuccessfulSync(SyncStatusCode status) {
   return status == SYNC_STATUS_OK ||
@@ skipping 89 matching lines @@
 }
 
 void SyncProcessRunner::Finished(const base::TimeTicks& start_time,
                                  SyncStatusCode status) {
   DCHECK_LT(0, running_tasks_);
   DCHECK_LE(running_tasks_, max_parallel_task_);
   --running_tasks_;
   util::Log(logging::LOG_VERBOSE, FROM_HERE,
             "[%s] * Finished (elapsed: %" PRId64 " sec)",
             name_.c_str(),
-            (base::TimeTicks::Now() - start_time).InSeconds());
+            (timer_helper_->Now() - start_time).InSeconds());
   if (status == SYNC_STATUS_NO_CHANGE_TO_SYNC ||
       status == SYNC_STATUS_FILE_BUSY)
     ScheduleInternal(kSyncDelayMaxInMilliseconds);
   else if (!WasSuccessfulSync(status) &&
            GetServiceState() == SYNC_SERVICE_RUNNING)
     ScheduleInternal(kSyncDelayWithSyncError);
   else
     Schedule();
 }
 
 void SyncProcessRunner::Run() {
   if (running_tasks_ >= max_parallel_task_)
     return;
   ++running_tasks_;
-  last_scheduled_ = base::TimeTicks::Now();
+  last_scheduled_ = timer_helper_->Now();
   last_delay_ = current_delay_;
 
   util::Log(logging::LOG_VERBOSE, FROM_HERE,
             "[%s] * Started", name_.c_str());
 
   StartSync(base::Bind(&SyncProcessRunner::Finished, factory_.GetWeakPtr(),
                        last_scheduled_));
 }
 
 void SyncProcessRunner::ScheduleInternal(int64 delay) {
   base::TimeDelta time_to_next = base::TimeDelta::FromMilliseconds(delay);
 
   if (timer_helper_->IsRunning()) {
     if (current_delay_ == delay)
       return;
 
-    base::TimeDelta elapsed = base::TimeTicks::Now() - last_scheduled_;
+    base::TimeDelta elapsed = timer_helper_->Now() - last_scheduled_;
     if (elapsed < time_to_next) {
       time_to_next = time_to_next - elapsed;
     } else {
       time_to_next = base::TimeDelta::FromMilliseconds(
           kSyncDelayFastInMilliseconds);
     }
   }
 
   if (current_delay_ != delay) {
     util::Log(logging::LOG_VERBOSE, FROM_HERE,
               "[%s] Scheduling task in %" PRId64 " secs",
               name_.c_str(), time_to_next.InSeconds());
   }
   current_delay_ = delay;
 
   timer_helper_->Start(
       FROM_HERE, time_to_next,
       base::Bind(&SyncProcessRunner::Run, base::Unretained(this)));
 }
 
 }  // namespace sync_file_system