Remove X-Retry-After support.

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 26 matching lines @@
 //
 // 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 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::kRetryHeaderName[] = "X-Retry-After";
 const char URLRequestThrottlerEntry::kExponentialThrottlingHeader[] =
     "X-Chrome-Exponential-Throttling";
 const char URLRequestThrottlerEntry::kExponentialThrottlingDisableValue[] =
     "disable";
 
 // NetLog parameters when a request is rejected by throttling.
 class RejectedRequestParameters : public NetLog::EventParameters {
  public:
   RejectedRequestParameters(const std::string& url_id,
                             int num_failures,
@@ skipping 10 matching lines @@
     dict->SetInteger("release_after_ms", release_after_ms_);
     return dict;
   }
 
  private:
   std::string url_id_;
   int num_failures_;
   int release_after_ms_;
 };
 
-// NetLog parameters when a response contains an X-Retry-After header.
-class RetryAfterParameters : public NetLog::EventParameters {
- public:
-  RetryAfterParameters(const std::string& url_id,
-                       int retry_after_ms)
-      : url_id_(url_id),
-        retry_after_ms_(retry_after_ms) {
-  }
-
-  virtual Value* ToValue() const {
-    DictionaryValue* dict = new DictionaryValue();
-    dict->SetString("url", url_id_);
-    dict->SetInteger("retry_after_ms", retry_after_ms_);
-    return dict;
-  }
-
- private:
-  std::string url_id_;
-  int retry_after_ms_;
-};
-
 URLRequestThrottlerEntry::URLRequestThrottlerEntry(
     URLRequestThrottlerManager* manager,
     const std::string& url_id)
     : sliding_window_period_(
           base::TimeDelta::FromMilliseconds(kDefaultSlidingWindowPeriodMs)),
       max_send_threshold_(kDefaultMaxSendThreshold),
       is_backoff_disabled_(false),
       backoff_entry_(&backoff_policy_),
       manager_(manager),
       url_id_(url_id),
@@ skipping 148 matching lines @@
     const std::string& host,
     const URLRequestThrottlerHeaderInterface* response) {
   int response_code = response->GetResponseCode();
   HandleMetricsTracking(response_code);
 
   if (IsConsideredError(response_code)) {
     GetBackoffEntry()->InformOfRequest(false);
   } else {
     GetBackoffEntry()->InformOfRequest(true);
 
-    std::string retry_header = response->GetNormalizedValue(kRetryHeaderName);
-    if (!retry_header.empty())
-      HandleCustomRetryAfter(retry_header);
-
     std::string throttling_header = response->GetNormalizedValue(
         kExponentialThrottlingHeader);
     if (!throttling_header.empty())
       HandleThrottlingHeader(throttling_header, host);
   }
 }
 
 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
@@ skipping 49 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::HandleCustomRetryAfter(
-    const std::string& header_value) {
-  // Input parameter is the number of seconds to wait in a floating point value.
-  double time_in_sec = 0;
-  bool conversion_is_ok = base::StringToDouble(header_value, &time_in_sec);
-
-  // Conversion of custom retry-after header value failed.
-  if (!conversion_is_ok)
-    return;
-
-  // We must use an int value later so we transform this in milliseconds.
-  int64 value_ms = static_cast<int64>(0.5 + time_in_sec * 1000);
-
-  // We do not check for an upper bound; the server can set any Retry-After it
-  // desires. Recovery from error would involve restarting the browser.
-  if (value_ms < 0)
-    return;
-
-  net_log_.AddEvent(
-      NetLog::TYPE_THROTTLING_GOT_CUSTOM_RETRY_AFTER,
-      make_scoped_refptr(new RetryAfterParameters(url_id_, value_ms)));
-
-  base::TimeDelta value = base::TimeDelta::FromMilliseconds(value_ms);
-  GetBackoffEntry()->SetCustomReleaseTime(ImplGetTimeNow() + value);
-
-  UMA_HISTOGRAM_CUSTOM_TIMES(
-      "Throttling.CustomRetryAfterMs", value,
-      base::TimeDelta::FromSeconds(1), base::TimeDelta::FromHours(12), 50);
-}
-
 void URLRequestThrottlerEntry::HandleThrottlingHeader(
     const std::string& header_value,
     const std::string& host) {
   if (header_value == kExponentialThrottlingDisableValue) {
     DisableBackoffThrottling();
     if (manager_)
       manager_->AddToOptOutList(host);
   } else {
     // TODO(joi): Log this.
   }
@@ skipping 32 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