Allow BackoffEntry to be serialized and deserialized.

net/base/backoff_entry.h

 // 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.
 
 #ifndef NET_BASE_BACKOFF_ENTRY_H_
 #define NET_BASE_BACKOFF_ENTRY_H_
 
 #include "base/threading/non_thread_safe.h"
 #include "base/time/time.h"
 #include "net/base/net_export.h"
 
 namespace base {
 class TickClock;
 }
 
 namespace net {
 
 // Provides the core logic needed for randomized exponential back-off
 // on requests to a given resource, given a back-off policy.
 //
 // This utility class knows nothing about network specifics; it is
 // intended for reuse in various networking scenarios.
 class NET_EXPORT BackoffEntry : NON_EXPORTED_BASE(public base::NonThreadSafe) {
  public:
-  // The set of parameters that define a back-off policy.
+  // The set of parameters that define a back-off policy. If you change this,
+  // increment SERIALIZATION_VERSION_NUMBER in backoff_entry_serializer.cc.
   struct Policy {
     // Number of initial errors (in sequence) to ignore before applying
     // exponential back-off rules.
     int num_errors_to_ignore;
 
     // Initial delay.  The interpretation of this value depends on
     // always_use_initial_delay.  It's either how long we wait between
     // requests before backoff starts, or how much we delay the first request
     // after backoff starts.
     int initial_delay_ms;
@@ skipping 56 matching lines @@
   // had for Policy::entry_lifetime_ms.
   bool CanDiscard() const;
 
   // Resets this entry to a fresh (as if just constructed) state.
   void Reset();
 
   // Returns the failure count for this entry.
   int failure_count() const { return failure_count_; }
 
  private:
+  friend class BackoffEntrySerializer;
+
   // Calculates when requests should again be allowed through.
   base::TimeTicks CalculateReleaseTime() const;
 
+  // Converts time_until_release to a release time, obeying maximum_backoff_ms.
+  base::TimeTicks TimeUntilReleaseToReleaseTime(
+      base::TimeDelta time_until_release) const;

[mmenke, 2015/05/05 15:47:51]

nit:  Maybe time_until_release -> backoff (or backoff_[delta|time])?  It seems
weird to use "maximum_backoff" to limit "time_until_release".

[johnme, 2015/05/06 12:46:46]

Ok, renamed time_until_release to backoff_duration everywhere.

+
   // Equivalent to TimeTicks::Now(), using clock_ if provided.
   base::TimeTicks GetTimeTicksNow() const;
 
   // Timestamp calculated by the exponential back-off algorithm at which we are
   // allowed to start sending requests again.
   base::TimeTicks exponential_backoff_release_time_;
 
   // Counts request errors; decremented on success.
   int failure_count_;
 
   const Policy* const policy_;  // Not owned.
 
   base::TickClock* const clock_;  // Not owned.
 
   DISALLOW_COPY_AND_ASSIGN(BackoffEntry);
 };
 
 }  // namespace net
 
 #endif  // NET_BASE_BACKOFF_ENTRY_H_