Allow BackoffEntry to be serialized and deserialized.

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 124 matching lines @@
   //     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
   // 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> time_until_release_us = delay_ms + 0.5;
+  time_until_release_us *= base::Time::kMicrosecondsPerMillisecond;
+  base::TimeDelta time_until_release = base::TimeDelta::FromMicroseconds(
+      time_until_release_us.ValueOrDefault(kint64max));
+  base::TimeTicks release_time =
+      TimeUntilReleaseToReleaseTime(time_until_release);
+
+  // 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::TimeUntilReleaseToReleaseTime(
+    base::TimeDelta time_until_release) const {
   const int64 kTimeTicksNowUs =
       (GetTimeTicksNow() - base::TimeTicks()).InMicroseconds();
+  // Do overflow checking in microseconds, the internal unit of TimeTicks.
   base::internal::CheckedNumeric<int64> calculated_release_time_us =
-      delay_ms + 0.5;
-  calculated_release_time_us *= base::Time::kMicrosecondsPerMillisecond;
+      time_until_release.InMicroseconds();
   calculated_release_time_us += kTimeTicksNowUs;
 
   base::internal::CheckedNumeric<int64> 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));
 
-  // Never reduce previously set release horizon, e.g. due to Retry-After
-  // header.
-  return std::max(
-      base::TimeTicks() + base::TimeDelta::FromMicroseconds(release_time_us),
-      exponential_backoff_release_time_);
+  return base::TimeTicks() + base::TimeDelta::FromMicroseconds(release_time_us);
 }
 
 base::TimeTicks BackoffEntry::GetTimeTicksNow() const {
   return clock_ ? clock_->NowTicks() : base::TimeTicks::Now();
 }
 
 }  // namespace net