Switch to standard integer types in chrome/browser/, part 4 of 4.

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 "base/macros.h"
 #include "chrome/browser/sync_file_system/logger.h"
 
 namespace sync_file_system {
 
-const int64 SyncProcessRunner::kSyncDelayInMilliseconds =
-    1 * base::Time::kMillisecondsPerSecond; // 1 sec
-const int64 SyncProcessRunner::kSyncDelayWithSyncError =
-    3 * base::Time::kMillisecondsPerSecond; // 3 sec
-const int64 SyncProcessRunner::kSyncDelayFastInMilliseconds = 100;  // 100 ms
+const int64_t SyncProcessRunner::kSyncDelayInMilliseconds =
+    1 * base::Time::kMillisecondsPerSecond;  // 1 sec
+const int64_t SyncProcessRunner::kSyncDelayWithSyncError =
+    3 * base::Time::kMillisecondsPerSecond;                           // 3 sec
+const int64_t SyncProcessRunner::kSyncDelayFastInMilliseconds = 100;  // 100 ms
 const int SyncProcessRunner::kPendingChangeThresholdForFastSync = 10;
-const int64 SyncProcessRunner::kSyncDelaySlowInMilliseconds =
+const int64_t SyncProcessRunner::kSyncDelaySlowInMilliseconds =
     30 * base::Time::kMillisecondsPerSecond;  // 30 sec
-const int64 SyncProcessRunner::kSyncDelayMaxInMilliseconds =
+const int64_t SyncProcessRunner::kSyncDelayMaxInMilliseconds =
     30 * 60 * base::Time::kMillisecondsPerSecond;  // 30 min
 
 namespace {
 
 class BaseTimerHelper : public SyncProcessRunner::TimerHelper {
  public:
   BaseTimerHelper() {}
 
   bool IsRunning() override { return timer_.IsRunning(); }
 
@@ skipping 73 matching lines @@
       if (last_service_state != service_state_)
         ThrottleSync(kSyncDelaySlowInMilliseconds);
       ScheduleInternal(kSyncDelayMaxInMilliseconds);
       return;
   }
 
   NOTREACHED();
   ScheduleInternal(kSyncDelayMaxInMilliseconds);
 }
 
-void SyncProcessRunner::ThrottleSync(int64 base_delay) {
+void SyncProcessRunner::ThrottleSync(int64_t base_delay) {
   base::TimeTicks now = timer_helper_->Now();
   base::TimeDelta elapsed = std::min(now, throttle_until_) - throttle_from_;
   DCHECK(base::TimeDelta() <= elapsed);
 
   throttle_from_ = now;
   // Extend throttling duration by twice the elapsed time.
   // That is, if the backoff repeats in a short period, the throttling period
   // doesn't grow exponentially.  If the backoff happens on the end of
   // throttling period, it causes another throttling period that is twice as
   // long as previous.
@@ skipping 13 matching lines @@
 
 void SyncProcessRunner::ResetThrottling() {
   throttle_from_ = base::TimeTicks();
   throttle_until_ = base::TimeTicks();
 }
 
 SyncServiceState SyncProcessRunner::GetServiceState() {
   return client_->GetSyncServiceState();
 }
 
-void SyncProcessRunner::OnChangesUpdated(
-    int64 pending_changes) {
+void SyncProcessRunner::OnChangesUpdated(int64_t pending_changes) {
   DCHECK_GE(pending_changes, 0);
-  int64 old_pending_changes = pending_changes_;
+  int64_t old_pending_changes = pending_changes_;
   pending_changes_ = pending_changes;
   if (old_pending_changes != pending_changes) {
     CheckIfIdle();
     util::Log(logging::LOG_VERBOSE, FROM_HERE,
               "[%s] pending_changes updated: %" PRId64,
               name_.c_str(), pending_changes);
   }
   Schedule();
 }
 
@@ skipping 34 matching lines @@
 
   util::Log(logging::LOG_VERBOSE, FROM_HERE,
             "[%s] * Started", name_.c_str());
 
   StartSync(base::Bind(&SyncProcessRunner::Finished, factory_.GetWeakPtr(),
                        now));
   if (running_tasks_ < max_parallel_task_)
     Schedule();
 }
 
-void SyncProcessRunner::ScheduleInternal(int64 delay) {
+void SyncProcessRunner::ScheduleInternal(int64_t delay) {
   base::TimeTicks now = timer_helper_->Now();
   base::TimeTicks next_scheduled;
 
   if (timer_helper_->IsRunning()) {
     next_scheduled = last_run_ + base::TimeDelta::FromMilliseconds(delay);
     if (next_scheduled < now) {
       next_scheduled =
           now + base::TimeDelta::FromMilliseconds(kSyncDelayFastInMilliseconds);
     }
   } else {
@@ skipping 16 matching lines @@
       FROM_HERE, next_scheduled - now,
       base::Bind(&SyncProcessRunner::Run, base::Unretained(this)));
 }
 
 void SyncProcessRunner::CheckIfIdle() {
   if (pending_changes_ == 0 && running_tasks_ == 0)
     client_->OnSyncIdle();
 }
 
 }  // namespace sync_file_system