Use the exact-width integer types defined in <stdint.h> rather than

net/base/backoff_entry.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 "net/base/backoff_entry.h"
 
 #include <algorithm>
 #include <cmath>
 #include <limits>
 
@@ skipping 69 matching lines @@
 void BackoffEntry::SetCustomReleaseTime(const base::TimeTicks& release_time) {
   exponential_backoff_release_time_ = release_time;
 }
 
 bool BackoffEntry::CanDiscard() const {
   if (policy_->entry_lifetime_ms == -1)
     return false;
 
   base::TimeTicks now = GetTimeTicksNow();
 
-  int64 unused_since_ms =
+  int64_t unused_since_ms =
       (now - exponential_backoff_release_time_).InMilliseconds();
 
   // Release time is further than now, we are managing it.
   if (unused_since_ms < 0)
     return false;
 
   if (failure_count_ > 0) {
     // Need to keep track of failures until maximum back-off period
     // has passed (since further failures can add to back-off).
     return unused_since_ms >= std::max(policy_->maximum_backoff_ms,
@@ skipping 27 matching lines @@
     // Never reduce previously set release horizon, e.g. due to Retry-After
     // header.
     return std::max(GetTimeTicksNow(), exponential_backoff_release_time_);
   }
 
   // The delay is calculated with this formula:
   // delay = initial_backoff * multiply_factor^(
   //     effective_failure_count - 1) * Uniform(1 - jitter_factor, 1]
   // Note: if the failure count is too high, |delay_ms| will become infinity
   // after the exponential calculation, and then NaN after the jitter is
-  // accounted for. Both cases are handled by using CheckedNumeric<int64> to
+  // accounted for. Both cases are handled by using CheckedNumeric<int64_t> to
   // perform the conversion to integers.
   double delay_ms = policy_->initial_delay_ms;
   delay_ms *= pow(policy_->multiply_factor, effective_failure_count - 1);
   delay_ms -= base::RandDouble() * policy_->jitter_factor * delay_ms;
 
   // Do overflow checking in microseconds, the internal unit of TimeTicks.
-  base::internal::CheckedNumeric<int64> backoff_duration_us = delay_ms + 0.5;
+  base::internal::CheckedNumeric<int64_t> backoff_duration_us = delay_ms + 0.5;
   backoff_duration_us *= base::Time::kMicrosecondsPerMillisecond;
   base::TimeDelta backoff_duration = base::TimeDelta::FromMicroseconds(
       backoff_duration_us.ValueOrDefault(kint64max));
   base::TimeTicks release_time = BackoffDurationToReleaseTime(backoff_duration);
 
   // Never reduce previously set release horizon, e.g. due to Retry-After
   // header.
   return std::max(release_time, exponential_backoff_release_time_);
 }
 
 base::TimeTicks BackoffEntry::BackoffDurationToReleaseTime(
     base::TimeDelta backoff_duration) const {
-  const int64 kTimeTicksNowUs =
+  const int64_t kTimeTicksNowUs =
       (GetTimeTicksNow() - base::TimeTicks()).InMicroseconds();
   // Do overflow checking in microseconds, the internal unit of TimeTicks.
-  base::internal::CheckedNumeric<int64> calculated_release_time_us =
+  base::internal::CheckedNumeric<int64_t> calculated_release_time_us =
       backoff_duration.InMicroseconds();
   calculated_release_time_us += kTimeTicksNowUs;
 
-  base::internal::CheckedNumeric<int64> maximum_release_time_us = kint64max;
+  base::internal::CheckedNumeric<int64_t> maximum_release_time_us = kint64max;
   if (policy_->maximum_backoff_ms >= 0) {
     maximum_release_time_us = policy_->maximum_backoff_ms;
     maximum_release_time_us *= base::Time::kMicrosecondsPerMillisecond;
     maximum_release_time_us += kTimeTicksNowUs;
   }
 
   // Decide between maximum release time and calculated release time, accounting
   // for overflow with both.
-  int64 release_time_us = std::min(
-      calculated_release_time_us.ValueOrDefault(kint64max),
-      maximum_release_time_us.ValueOrDefault(kint64max));
+  int64_t release_time_us =
+      std::min(calculated_release_time_us.ValueOrDefault(kint64max),
+               maximum_release_time_us.ValueOrDefault(kint64max));
 
   return base::TimeTicks() + base::TimeDelta::FromMicroseconds(release_time_us);
 }
 
 base::TimeTicks BackoffEntry::GetTimeTicksNow() const {
   return clock_ ? clock_->NowTicks() : base::TimeTicks::Now();
 }
 
 }  // namespace net