Implement exponential back-off mechanism and enforce it at the URLRequestHttpJob level.

net/url_request/url_request_http_job.cc

 // Copyright (c) 2010 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/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/file_util.h"
@@ skipping 11 matching lines @@
 #include "net/base/net_util.h"
 #include "net/base/sdch_manager.h"
 #include "net/base/ssl_cert_request_info.h"
 #include "net/http/http_request_headers.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_response_info.h"
 #include "net/http/http_transaction.h"
 #include "net/http/http_transaction_factory.h"
 #include "net/http/http_util.h"
 #include "net/url_request/https_prober.h"
+#include "net/url_request/request_throttler_header_adapter.h"
+#include "net/url_request/request_throttler_manager.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_error_job.h"
 #include "net/url_request/url_request_redirect_job.h"
 
 static const char kAvailDictionaryHeader[] = "Avail-Dictionary";
 
 // TODO(darin): make sure the port blocking code is not lost
 // static
 URLRequestJob* URLRequestHttpJob::Factory(URLRequest* request,
@@ skipping 43 matching lines @@
       ALLOW_THIS_IN_INITIALIZER_LIST(can_get_cookies_callback_(
           this, &URLRequestHttpJob::OnCanGetCookiesCompleted)),
       ALLOW_THIS_IN_INITIALIZER_LIST(can_set_cookie_callback_(
           this, &URLRequestHttpJob::OnCanSetCookieCompleted)),
       ALLOW_THIS_IN_INITIALIZER_LIST(start_callback_(
           this, &URLRequestHttpJob::OnStartCompleted)),
       ALLOW_THIS_IN_INITIALIZER_LIST(read_callback_(
           this, &URLRequestHttpJob::OnReadCompleted)),
       read_in_progress_(false),
       transaction_(NULL),
+      throttling_entry_(RequestThrottlerManager::GetInstance()->
+          RegisterRequestUrl(request->url())),
       sdch_dictionary_advertised_(false),
       sdch_test_activated_(false),
       sdch_test_control_(false),
       is_cached_content_(false) {
 }
 
 URLRequestHttpJob::~URLRequestHttpJob() {
   DCHECK(!sdch_test_control_ || !sdch_test_activated_);
   if (!IsCachedContent()) {
     if (sdch_test_control_)
@@ skipping 458 matching lines @@
 
 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_) {
+    RequestThrottlerHeaderAdapter response_adapter(response_info_->headers);
+    throttling_entry_->UpdateWithResponse(&response_adapter);
+  }
+
   ProcessStrictTransportSecurityHeader();
 
   if (SdchManager::Global() &&
       SdchManager::Global()->IsInSupportedDomain(request_->url())) {
     static const std::string name = "Get-Dictionary";
     std::string url_text;
     void* iter = NULL;
     // TODO(jar): We need to not fetch dictionaries the first time they are
     // seen, but rather wait until we can justify their usefulness.
     // For now, we will only fetch the first dictionary, which will at least
@@ skipping 27 matching lines @@
   transaction_.reset();
   response_info_ = NULL;
 }
 
 void URLRequestHttpJob::StartTransaction() {
   // NOTE: This method assumes that request_info_ is already setup properly.
 
   // If we already have a transaction, then we should restart the transaction
   // with auth provided by username_ and password_.
 
-  int rv;
+  int return_value;

[willchan no longer on Chromium, 2010/11/24 10:14:50]

rv is sufficiently common in the network stack that unless we wanted to change
the rest of the network stack, it's better to simply be consistent and continue
using rv here to mean return_value.  i understand why you changed it, but it's
inconsistent with network stack code.

[yzshen, 2010/11/24 19:09:30]

Done.

+
   if (transaction_.get()) {
-    rv = transaction_->RestartWithAuth(username_, password_, &start_callback_);
+    return_value = transaction_->RestartWithAuth(username_,
+        password_, &start_callback_);
     username_.clear();
     password_.clear();
   } else {
     DCHECK(request_->context());
     DCHECK(request_->context()->http_transaction_factory());
 
-    rv = request_->context()->http_transaction_factory()->CreateTransaction(
-        &transaction_);
-    if (rv == net::OK) {
-      rv = transaction_->Start(
-          &request_info_, &start_callback_, request_->net_log());
+    return_value = request_->context()->http_transaction_factory()->
+        CreateTransaction(&transaction_);
+    if (return_value == net::OK) {
+      if (!throttling_entry_->IsDuringExponentialBackoff()) {
+        return_value = transaction_->Start(
+            &request_info_, &start_callback_, request_->net_log());
+      } else {
+        // Special error code for the exponential back-off module.
+        return_value = net::ERR_TEMPORARILY_THROTTLED_BY_DDOS;
+      }
     }
   }
 
-  if (rv == net::ERR_IO_PENDING)
+  if (return_value == net::ERR_IO_PENDING)
     return;
 
   // The transaction started synchronously, but we need to notify the
   // URLRequest delegate via the message loop.
   MessageLoop::current()->PostTask(FROM_HERE, NewRunnableMethod(
-      this, &URLRequestHttpJob::OnStartCompleted, rv));
+      this, &URLRequestHttpJob::OnStartCompleted, return_value));
 }
 
 void URLRequestHttpJob::AddExtraHeaders() {
   // TODO(jar): Consider optimizing away SDCH advertising bytes when the URL is
   // probably an img or such (and SDCH encoding is not likely).
   bool advertise_sdch = SdchManager::Global() &&
       SdchManager::Global()->IsInSupportedDomain(request_->url());
   std::string avail_dictionaries;
   if (advertise_sdch) {
     SdchManager::Global()->GetAvailDictionaryList(request_->url(),
@@ skipping 259 matching lines @@
     HTTPSProberDelegate* delegate =
         new HTTPSProberDelegate(request_info_.url.host(), max_age,
                                 include_subdomains,
                                 ctx->transport_security_state());
     if (!prober->ProbeHost(request_info_.url.host(), request()->context(),
                            delegate)) {
       delete delegate;
     }
   }
 }