Remove X-Chrome-Exponential-Throttling header

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"
 #include "base/metrics/histogram.h"
 #include "base/rand_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/values.h"
 #include "net/base/load_flags.h"
 #include "net/log/net_log.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_context.h"
-#include "net/url_request/url_request_throttler_header_interface.h"
 #include "net/url_request/url_request_throttler_manager.h"
 
 namespace net {
 
 const int URLRequestThrottlerEntry::kDefaultSlidingWindowPeriodMs = 2000;
 const int URLRequestThrottlerEntry::kDefaultMaxSendThreshold = 20;
 
 // This set of back-off parameters will (at maximum values, i.e. without
 // the reduction caused by jitter) add 0-41% (distributed uniformly
 // in that range) to the "perceived downtime" of the remote server, once
 // exponential back-off kicks in and is throttling requests for more than
 // about a second at a time.  Once the maximum back-off is reached, the added
 // perceived downtime decreases rapidly, percentage-wise.
 //
 // 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::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";
 
 // Returns NetLog parameters when a request is rejected by throttling.
 base::Value* NetLogRejectedRequestCallback(
     const std::string* url_id,
     int num_failures,
     const base::TimeDelta& release_after,
     NetLogCaptureMode /* capture_mode */) {
   scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
   dict->SetString("url", *url_id);
   dict->SetInteger("num_failures", num_failures);
@@ skipping 152 matching lines @@
   // the back-off mechanism when it shouldn't be triggered, in which case
   // returning the calculated back-off release time would probably be the
   // wrong thing to do (i.e. it would likely be too long).  Therefore, we
   // return "now" so that retries are not delayed.
   if (is_backoff_disabled_)
     return ImplGetTimeNow();
 
   return GetBackoffEntry()->GetReleaseTime();
 }
 
-void URLRequestThrottlerEntry::UpdateWithResponse(
-    const std::string& host,
-    const URLRequestThrottlerHeaderInterface* response) {
-  if (IsConsideredError(response->GetResponseCode())) {
-    GetBackoffEntry()->InformOfRequest(false);
-  } else {
-    GetBackoffEntry()->InformOfRequest(true);
-
-    std::string throttling_header = response->GetNormalizedValue(
-        kExponentialThrottlingHeader);
-    if (!throttling_header.empty())
-      HandleThrottlingHeader(throttling_header, host);
-  }
+void URLRequestThrottlerEntry::UpdateWithResponse(int status_code) {
+  GetBackoffEntry()->InformOfRequest(IsConsideredSuccess(status_code));
 }
 
 void URLRequestThrottlerEntry::ReceivedContentWasMalformed(int response_code) {
   // A malformed body can only occur when the request to fetch a resource
   // was successful.  Therefore, in such a situation, we will receive one
   // call to ReceivedContentWasMalformed() and one call to
   // UpdateWithResponse() with a response categorized as "good".  To end
   // up counting one failure, we need to count two failures here against
   // the one success in UpdateWithResponse().
   //
   // We do nothing for a response that is already being considered an error
   // based on its status code (otherwise we would count 3 errors instead of 1).
-  if (!IsConsideredError(response_code)) {
+  if (IsConsideredSuccess(response_code)) {
     GetBackoffEntry()->InformOfRequest(false);
     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_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;
 }
 
-bool URLRequestThrottlerEntry::IsConsideredError(int response_code) {
+bool URLRequestThrottlerEntry::IsConsideredSuccess(int response_code) {
   // We throttle only for the status codes most likely to indicate the server
   // is failing because it is too busy or otherwise are likely to be
   // because of DDoS.
   //
   // 500 is the generic error when no better message is suitable, and
   //     as such does not necessarily indicate a temporary state, but
   //     other status codes cover most of the permanent error states.
   // 503 is explicitly documented as a temporary state where the server
   //     is either overloaded or down for maintenance.
   // 509 is the (non-standard but widely implemented) Bandwidth Limit Exceeded
   //     status code, which might indicate DDoS.
   //
   // We do not back off on 502 or 504, which are reported by gateways
   // (proxies) on timeouts or failures, because in many cases these requests
   // have not made it to the destination server and so we do not actually
   // know that it is down or busy.  One degenerate case could be a proxy on
   // localhost, where you are not actually connected to the network.
-  return (response_code == 500 ||
-          response_code == 503 ||
-          response_code == 509);
+  return !(response_code == 500 || response_code == 503 ||
+           response_code == 509);
 }
 
 base::TimeTicks URLRequestThrottlerEntry::ImplGetTimeNow() const {
   return base::TimeTicks::Now();
 }
 
-void URLRequestThrottlerEntry::HandleThrottlingHeader(
-    const std::string& header_value,
-    const std::string& host) {
-  if (header_value == kExponentialThrottlingDisableValue) {
-    DisableBackoffThrottling();
-    if (manager_)
-      manager_->AddToOptOutList(host);
-  }
-}
-
 const BackoffEntry* URLRequestThrottlerEntry::GetBackoffEntry() const {
   return &backoff_entry_;
 }
 
 BackoffEntry* URLRequestThrottlerEntry::GetBackoffEntry() {
   return &backoff_entry_;
 }
 
 // static
 bool URLRequestThrottlerEntry::ExplicitUserRequest(const int load_flags) {
   return (load_flags & LOAD_MAYBE_USER_GESTURE) != 0;
 }
 
 }  // namespace net