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())) {
+void URLRequestThrottlerEntry::UpdateWithResponse(const std::string& host,

[mmenke, 2015/05/19 19:18:37]

This method no longer needs the "host" argument.

[xunjieli, 2015/05/19 20:06:44]

Done. thanks!

+                                                  int status_code) {
+  if (IsConsideredError(status_code)) {
     GetBackoffEntry()->InformOfRequest(false);
   } else {
     GetBackoffEntry()->InformOfRequest(true);
-
-    std::string throttling_header = response->GetNormalizedValue(
-        kExponentialThrottlingHeader);
-    if (!throttling_header.empty())
-      HandleThrottlingHeader(throttling_header, host);
   }

[mmenke, 2015/05/19 19:18:37]

nit:  Can just collapse this block to:

GetBackoffEntry()->InformOfRequest(!IsConsideredError(status_code));

Optionally could rename/modify !IsConsideredError -> IsConsideredSuccess.  Not
an error is a weird way of saying something is a success.

[xunjieli, 2015/05/19 20:06:44]

Done.

 }
 
 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().
   //
@@ skipping 39 matching lines @@
   // localhost, where you are not actually connected to the network.
   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