BackoffEntry: Add the option to always use a delay.

net/url_request/url_request_throttler_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/url_request/url_request_throttler_entry.h"
 
 #include <cmath>
 
 #include "base/logging.h"
 #include "base/metrics/field_trial.h"
@@ skipping 21 matching lines @@
 // Another way to put it is that the maximum additional perceived downtime
 // with these numbers is a couple of seconds shy of 15 minutes, and such
 // a delay would not occur until the remote server has been actually
 // unavailable at the end of each back-off period for a total of about
 // 48 minutes.
 //
 // Ignoring the first couple of errors is just a conservative measure to
 // avoid false positives.  It should help avoid back-off from kicking in e.g.
 // on flaky connections.
 const int URLRequestThrottlerEntry::kDefaultNumErrorsToIgnore = 2;
-const int URLRequestThrottlerEntry::kDefaultInitialBackoffMs = 700;
+const int URLRequestThrottlerEntry::kDefaultInitialDelayMs = 700;
 const double URLRequestThrottlerEntry::kDefaultMultiplyFactor = 1.4;
 const double URLRequestThrottlerEntry::kDefaultJitterFactor = 0.4;
 const int URLRequestThrottlerEntry::kDefaultMaximumBackoffMs = 15 * 60 * 1000;
 const int URLRequestThrottlerEntry::kDefaultEntryLifetimeMs = 2 * 60 * 1000;
 const char URLRequestThrottlerEntry::kExponentialThrottlingHeader[] =
     "X-Chrome-Exponential-Throttling";
 const char URLRequestThrottlerEntry::kExponentialThrottlingDisableValue[] =
     "disable";
 
 // NetLog parameters when a request is rejected by throttling.
@@ skipping 56 matching lines @@
   DCHECK_GT(sliding_window_period_ms, 0);
   DCHECK_GT(max_send_threshold_, 0);
   DCHECK_GE(initial_backoff_ms, 0);
   DCHECK_GT(multiply_factor, 0);
   DCHECK_GE(jitter_factor, 0.0);
   DCHECK_LT(jitter_factor, 1.0);
   DCHECK_GE(maximum_backoff_ms, 0);
   DCHECK(manager_);
 
   Initialize();
-  backoff_policy_.initial_backoff_ms = initial_backoff_ms;
+  backoff_policy_.initial_delay_ms = initial_backoff_ms;
   backoff_policy_.multiply_factor = multiply_factor;
   backoff_policy_.jitter_factor = jitter_factor;
   backoff_policy_.maximum_backoff_ms = maximum_backoff_ms;
   backoff_policy_.entry_lifetime_ms = -1;
   backoff_policy_.num_errors_to_ignore = 0;
+  backoff_policy_.always_use_initial_delay = false;
 }
 
 bool URLRequestThrottlerEntry::IsEntryOutdated() const {
   // This function is called by the URLRequestThrottlerManager to determine
   // whether entries should be discarded from its url_entries_ map.  We
   // want to ensure that it does not remove entries from the map while there
   // are clients (objects other than the manager) holding references to
   // the entry, otherwise separate clients could end up holding separate
   // entries for a request to the same URL, which is undesirable.  Therefore,
   // if an entry has more than one reference (the map will always hold one),
@@ skipping 21 matching lines @@
 void URLRequestThrottlerEntry::DetachManager() {
   manager_ = NULL;
 }
 
 bool URLRequestThrottlerEntry::ShouldRejectRequest(int load_flags) const {
   bool reject_request = false;
   if (!is_backoff_disabled_ && !ExplicitUserRequest(load_flags) &&
       GetBackoffEntry()->ShouldRejectRequest()) {
     int num_failures = GetBackoffEntry()->failure_count();
     int release_after_ms =
-        (GetBackoffEntry()->GetReleaseTime() - base::TimeTicks::Now())
-            .InMilliseconds();
+        GetBackoffEntry()->GetTimeUntilRelease().InMilliseconds();
 
     net_log_.AddEvent(
         NetLog::TYPE_THROTTLING_REJECTED_REQUEST,
         make_scoped_refptr(
             new RejectedRequestParameters(url_id_,
                                           num_failures,
                                           release_after_ms)));
 
     reject_request = true;
   }
@@ skipping 86 matching lines @@
     GetBackoffEntry()->InformOfRequest(false);
   }
 }
 
 URLRequestThrottlerEntry::~URLRequestThrottlerEntry() {
 }
 
 void URLRequestThrottlerEntry::Initialize() {
   sliding_window_release_time_ = base::TimeTicks::Now();
   backoff_policy_.num_errors_to_ignore = kDefaultNumErrorsToIgnore;
-  backoff_policy_.initial_backoff_ms = kDefaultInitialBackoffMs;
+  backoff_policy_.initial_delay_ms = kDefaultInitialDelayMs;
   backoff_policy_.multiply_factor = kDefaultMultiplyFactor;
   backoff_policy_.jitter_factor = kDefaultJitterFactor;
   backoff_policy_.maximum_backoff_ms = kDefaultMaximumBackoffMs;
   backoff_policy_.entry_lifetime_ms = kDefaultEntryLifetimeMs;
+  backoff_policy_.always_use_initial_delay = false;
 
   // We pretend we just had a successful response so that we have a
   // starting point to our tracking. This is called from the
   // constructor so we do not use the virtual ImplGetTimeNow().
   last_successful_response_time_ = base::TimeTicks::Now();
   last_response_was_success_ = true;
 }
 
 bool URLRequestThrottlerEntry::IsConsideredError(int response_code) {
   // We throttle only for the status codes most likely to indicate the server
@@ skipping 67 matching lines @@
 BackoffEntry* URLRequestThrottlerEntry::GetBackoffEntry() {
   return &backoff_entry_;
 }
 
 // static
 bool URLRequestThrottlerEntry::ExplicitUserRequest(const int load_flags) {
   return (load_flags & LOAD_MAYBE_USER_GESTURE) != 0;
 }
 
 }  // namespace net