Implement URLRequestBackoffManager for managing Backoff headers

net/url_request/url_request_http_job.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_http_job.h"
 
 #include "base/base_switches.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
@@ skipping 26 matching lines @@
 #include "net/http/http_status_code.h"
 #include "net/http/http_transaction.h"
 #include "net/http/http_transaction_factory.h"
 #include "net/http/http_util.h"
 #include "net/proxy/proxy_info.h"
 #include "net/ssl/ssl_cert_request_info.h"
 #include "net/ssl/ssl_config_service.h"
 #include "net/url_request/fraudulent_certificate_reporter.h"
 #include "net/url_request/http_user_agent_settings.h"
 #include "net/url_request/url_request.h"
+#include "net/url_request/url_request_backoff_manager.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_error_job.h"
 #include "net/url_request/url_request_job_factory.h"
 #include "net/url_request/url_request_redirect_job.h"
 #include "net/url_request/url_request_throttler_manager.h"
 #include "net/websockets/websocket_handshake_stream_base.h"
 
 static const char kAvailDictionaryHeader[] = "Avail-Dictionary";
 
 namespace net {
@@ skipping 131 matching lines @@
       done_(false),
       bytes_observed_in_packets_(0),
       request_time_snapshot_(),
       final_packet_time_(),
       filter_context_(new HttpFilterContext(this)),
       on_headers_received_callback_(
           base::Bind(&URLRequestHttpJob::OnHeadersReceivedCallback,
                      base::Unretained(this))),
       awaiting_callback_(false),
       http_user_agent_settings_(http_user_agent_settings),
+      backoff_manager_(request->context()->backoff_manager()),
       weak_factory_(this) {
   URLRequestThrottlerManager* manager = request->context()->throttler_manager();
   if (manager)
     throttling_entry_ = manager->RegisterRequestUrl(request->url());
 
   ResetTimer();
 }
 
 URLRequestHttpJob::~URLRequestHttpJob() {
   CHECK(!awaiting_callback_);
@@ skipping 86 matching lines @@
   DCHECK(request_headers);
   DCHECK_NE(URLRequestStatus::CANCELED, GetStatus().status());
   if (network_delegate()) {
     network_delegate()->NotifyBeforeSendProxyHeaders(
         request_,
         proxy_info,
         request_headers);
   }
 }
 
+void URLRequestHttpJob::NotifyBeforeNetworkStart(bool* defer) {
+  if (!request_)
+    return;
+  if (backoff_manager_) {
+    if (backoff_manager_->ShouldRejectRequest(request()->url(),
+                                              request()->request_time())) {
+      *defer = true;
+      base::MessageLoop::current()->PostTask(
+          FROM_HERE,
+          base::Bind(&URLRequestHttpJob::OnStartCompleted,
+                     weak_factory_.GetWeakPtr(), ERR_TEMPORARY_BACKOFF));
+      return;
+    }
+  }
+  URLRequestJob::NotifyBeforeNetworkStart(defer);
+}
+
 void URLRequestHttpJob::NotifyHeadersComplete() {
   DCHECK(!response_info_);
 
   response_info_ = transaction_->GetResponseInfo();
 
   // Save boolean, as we'll need this info at destruction time, and filters may
   // also need this info.
   is_cached_content_ = response_info_->was_cached;
 
   if (!is_cached_content_ && throttling_entry_.get())
     throttling_entry_->UpdateWithResponse(GetResponseCode());
 
+  if (!is_cached_content_)
+    ProcessBackoffHeader();
+
   // The ordering of these calls is not important.
   ProcessStrictTransportSecurityHeader();
   ProcessPublicKeyPinsHeader();
 
   // Handle the server notification of a new SDCH dictionary.
   SdchManager* sdch_manager(request()->context()->sdch_manager());
   if (sdch_manager) {
     SdchProblemCode rv = sdch_manager->IsInSupportedDomain(request()->url());
     if (rv != SDCH_OK) {
       // If SDCH is just disabled, it is not a real error.
@@ skipping 463 matching lines @@
   std::string value;
 
   void* iter = NULL;
   HttpResponseHeaders* headers = GetResponseHeaders();
   while (headers->EnumerateHeader(&iter, name, &value)) {
     if (!value.empty())
       cookies->push_back(value);
   }
 }
 
+void URLRequestHttpJob::ProcessBackoffHeader() {
+  DCHECK(response_info_);
+
+  if (!backoff_manager_)
+    return;
+
+  TransportSecurityState* security_state =
+      request_->context()->transport_security_state();
+  const SSLInfo& ssl_info = response_info_->ssl_info;
+
+  // Only accept Backoff headers on HTTPS connections that have no
+  // certificate errors.
+  if (!ssl_info.is_valid() || IsCertStatusError(ssl_info.cert_status) ||
+      !security_state)
+    return;
+
+  backoff_manager_->UpdateWithResponse(request()->url(), GetResponseHeaders(),
+                                       base::Time::Now());
+}
+
 // NOTE: |ProcessStrictTransportSecurityHeader| and
 // |ProcessPublicKeyPinsHeader| have very similar structures, by design.
 void URLRequestHttpJob::ProcessStrictTransportSecurityHeader() {
   DCHECK(response_info_);
   TransportSecurityState* security_state =
       request_->context()->transport_security_state();
   const SSLInfo& ssl_info = response_info_->ssl_info;
 
   // Only accept HSTS headers on HTTPS connections that have no
   // certificate errors.
@@ skipping 701 matching lines @@
   return override_response_headers_.get() ?
              override_response_headers_.get() :
              transaction_->GetResponseInfo()->headers.get();
 }
 
 void URLRequestHttpJob::NotifyURLRequestDestroyed() {
   awaiting_callback_ = false;
 }
 
 }  // namespace net