BackoffEntry: Add the option to always use a delay.

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 29 matching lines @@
 
     // The reason why we are not just cutting the release time to
     // ImplGetTimeNow() is on the one hand, it would unset a release
     // time set by SetCustomReleaseTime and on the other we would like
     // to push every request up to our "horizon" when dealing with
     // multiple in-flight requests. Ex: If we send three requests and
     // we receive 2 failures and 1 success. The success that follows
     // those failures will not reset the release time, further
     // requests will then need to wait the delay caused by the 2
     // failures.
+    base::TimeDelta delay;
+    if (policy_->always_use_initial_delay)
+      delay = base::TimeDelta::FromMilliseconds(policy_->initial_delay_ms);
     exponential_backoff_release_time_ = std::max(
-        ImplGetTimeNow(), exponential_backoff_release_time_);
+        ImplGetTimeNow() + delay, exponential_backoff_release_time_);
   }
 }
 
 bool BackoffEntry::ShouldRejectRequest() const {
   return exponential_backoff_release_time_ > ImplGetTimeNow();
 }
 
+base::TimeDelta BackoffEntry::GetTimeUntilRelease() const {
+  base::TimeTicks now = ImplGetTimeNow();
+  if (exponential_backoff_release_time_ <= now)
+    return base::TimeDelta();
+  return exponential_backoff_release_time_ - now;
+}
+
 base::TimeTicks BackoffEntry::GetReleaseTime() const {
   return exponential_backoff_release_time_;
 }
 
 void BackoffEntry::SetCustomReleaseTime(const base::TimeTicks& release_time) {
   exponential_backoff_release_time_ = release_time;
 }
 
 bool BackoffEntry::CanDiscard() const {
   if (policy_->entry_lifetime_ms == -1)
@@ skipping 31 matching lines @@
   exponential_backoff_release_time_ = base::TimeTicks();
 }
 
 base::TimeTicks BackoffEntry::ImplGetTimeNow() const {
   return base::TimeTicks::Now();
 }
 
 base::TimeTicks BackoffEntry::CalculateReleaseTime() const {
   int effective_failure_count =
       std::max(0, failure_count_ - policy_->num_errors_to_ignore);
+
+  // If always_use_initial_delay is true, it's equivalent to
+  // the effective_failure_count always being one greater than when it's false.
+  if (policy_->always_use_initial_delay)
+    ++effective_failure_count;
+
   if (effective_failure_count == 0) {
     // Never reduce previously set release horizon, e.g. due to Retry-After
     // header.
     return std::max(ImplGetTimeNow(), 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]
-  double delay = policy_->initial_backoff_ms;
+  double delay = policy_->initial_delay_ms;
   delay *= pow(policy_->multiply_factor, effective_failure_count - 1);
   delay -= base::RandDouble() * policy_->jitter_factor * delay;
 
   const int64 kMaxInt64 = std::numeric_limits<int64>::max();
   int64 delay_int = (delay > kMaxInt64) ?
       kMaxInt64 : static_cast<int64>(delay + 0.5);
 
   // Ensure that we do not exceed maximum delay.
   if (policy_->maximum_backoff_ms >= 0)
     delay_int = std::min(delay_int, policy_->maximum_backoff_ms);
 
   // Never reduce previously set release horizon, e.g. due to Retry-After
   // header.
   return std::max(
       ImplGetTimeNow() + base::TimeDelta::FromMilliseconds(delay_int),
       exponential_backoff_release_time_);
 }
 
 }  // namespace net