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

chrome/common/net/url_fetcher.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 "chrome/common/net/url_fetcher.h"
 
 #include <set>
 
 #include "base/compiler_specific.h"
 #include "base/lazy_instance.h"
 #include "base/lock.h"
 #include "base/message_loop_proxy.h"
 #include "base/scoped_ptr.h"
 #include "base/stl_util-inl.h"
 #include "base/string_util.h"
 #include "base/thread.h"
-#include "chrome/common/net/url_fetcher_protect.h"
 #include "chrome/common/net/url_request_context_getter.h"
 #include "googleurl/src/gurl.h"
 #include "net/base/load_flags.h"
 #include "net/base/io_buffer.h"
+#include "net/base/net_errors.h"
 #include "net/http/http_request_headers.h"
 #include "net/http/http_response_headers.h"
+#include "net/url_request/request_throttler_manager.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_context.h"
 
 static const int kBufferSize = 4096;
 
 bool URLFetcher::g_interception_enabled = false;
 
 class URLFetcher::Core
     : public base::RefCountedThreadSafe<URLFetcher::Core>,
       public URLRequest::Delegate {
@@ skipping 75 matching lines @@
                                      // Read buffer
   scoped_refptr<URLRequestContextGetter> request_context_getter_;
                                      // Cookie/cache info for the request
   ResponseCookies cookies_;          // Response cookies
   net::HttpRequestHeaders extra_request_headers_;
   scoped_refptr<net::HttpResponseHeaders> response_headers_;
 
   std::string upload_content_;       // HTTP POST payload
   std::string upload_content_type_;  // MIME type of POST payload
 
-  // The overload protection entry for this URL.  This is used to
-  // incrementally back off how rapidly we'll send requests to a particular
-  // URL, to avoid placing too much demand on the remote resource.  We update
-  // this with the status of all requests as they return, and in turn use it
-  // to determine how long to wait before making another request.
-  URLFetcherProtectEntry* protect_entry_;
   // |num_retries_| indicates how many times we've failed to successfully
   // fetch this URL.  Once this value exceeds the maximum number of retries
-  // specified by the protection manager, we'll give up.
+  // specified by the owner URLFetcher instance, we'll give up.
   int num_retries_;
 
+  // Caches the pointer to the singleton object of RequestThrottlerManager.
+  // This is used to determine how long to wait before making a request or doing
+  // a retry.
+  RequestThrottlerManager* request_throttler_manager_;
+
   // True if the URLFetcher has been cancelled.
   bool was_cancelled_;
 
   static base::LazyInstance<Registry> g_registry;
 
   friend class URLFetcher;
   DISALLOW_COPY_AND_ASSIGN(Core);
 };
 
 URLFetcher::Core::Registry::Registry() {}
@@ skipping 23 matching lines @@
     URLFetcher::Core::g_registry(base::LINKER_INITIALIZED);
 
 // static
 URLFetcher::Factory* URLFetcher::factory_ = NULL;
 
 URLFetcher::URLFetcher(const GURL& url,
                        RequestType request_type,
                        Delegate* d)
     : ALLOW_THIS_IN_INITIALIZER_LIST(
       core_(new Core(this, url, request_type, d))),
-      automatically_retry_on_5xx_(true) {
+      automatically_retry_on_5xx_(true),
+      max_retries_(0) {
 }
 
 URLFetcher::~URLFetcher() {
   core_->Stop();
 }
 
 // static
 URLFetcher* URLFetcher::Create(int id, const GURL& url,
                                RequestType request_type, Delegate* d) {
   return factory_ ? factory_->CreateURLFetcher(id, url, request_type, d) :
                     new URLFetcher(url, request_type, d);
 }
 
 URLFetcher::Core::Core(URLFetcher* fetcher,
                        const GURL& original_url,
                        RequestType request_type,
                        URLFetcher::Delegate* d)
     : fetcher_(fetcher),
       original_url_(original_url),
       request_type_(request_type),
       delegate_(d),
       delegate_loop_(MessageLoop::current()),
       request_(NULL),
       load_flags_(net::LOAD_NORMAL),
       response_code_(-1),
       buffer_(new net::IOBuffer(kBufferSize)),
-      protect_entry_(URLFetcherProtectManager::GetInstance()->Register(
-          original_url_.host())),
       num_retries_(0),
+      request_throttler_manager_(Singleton<RequestThrottlerManager>::get()),
       was_cancelled_(false) {
 }
 
 URLFetcher::Core::~Core() {
   // |request_| should be NULL.  If not, it's unsafe to delete it here since we
   // may not be on the IO thread.
   DCHECK(!request_.get());
 }
 
 void URLFetcher::Core::Start() {
   DCHECK(delegate_loop_);
   CHECK(request_context_getter_) << "We need an URLRequestContext!";
   io_message_loop_proxy_ = request_context_getter_->GetIOMessageLoopProxy();
   CHECK(io_message_loop_proxy_.get()) << "We need an IO message loop proxy";
+
+  scoped_refptr<RequestThrottlerEntryInterface> entry =
+      request_throttler_manager_->RegisterRequestUrl(original_url_);
   io_message_loop_proxy_->PostDelayedTask(
       FROM_HERE,
       NewRunnableMethod(this, &Core::StartURLRequest),
-          protect_entry_->UpdateBackoff(URLFetcherProtectEntry::SEND));
+      entry->GetRecommendedDelayForNextRequest());
 }
 
 void URLFetcher::Core::Stop() {
   DCHECK_EQ(MessageLoop::current(), delegate_loop_);
   delegate_ = NULL;
   fetcher_ = NULL;
   if (io_message_loop_proxy_.get()) {
     io_message_loop_proxy_->PostTask(
         FROM_HERE, NewRunnableMethod(this, &Core::CancelURLRequest));
   }
@@ skipping 106 matching lines @@
   // delete the object, but we cannot delay the destruction of the request
   // context.
   request_context_getter_ = NULL;
   was_cancelled_ = true;
 }
 
 void URLFetcher::Core::OnCompletedURLRequest(const URLRequestStatus& status) {
   DCHECK(MessageLoop::current() == delegate_loop_);
 
   // Checks the response from server.
-  if (response_code_ >= 500) {
+  if (response_code_ >= 500 ||
+      status.os_error() == net::ERR_TEMPORARILY_THROTTLED_BY_DDOS) {
     // When encountering a server error, we will send the request again
     // after backoff time.
-    int64 back_off_time =
-        protect_entry_->UpdateBackoff(URLFetcherProtectEntry::FAILURE);
+    scoped_refptr<RequestThrottlerEntryInterface> entry =
+        request_throttler_manager_->RegisterRequestUrl(url_);
+    int64 back_off_time = entry->GetRecommendedDelayForNextRequest();

[Jói, 2010/11/17 16:39:18]

Doesn't this call to GetRecommendedDelayForNextRequest add a sent item to the
sliding window? Is that what you intend?

[yzshen, 2010/11/19 23:51:36]

Since every retry is a new request, I think we need to spread them over time
properly, by reserving them in the sliding window.

However, the code does have some problems, because sometimes it reserves a send
item in the sliding window while not using it. I have fixed it.

     if (delegate_) {
       fetcher_->backoff_delay_ =
           base::TimeDelta::FromMilliseconds(back_off_time);
     }
     ++num_retries_;
     // Restarts the request if we still need to notify the delegate.
     if (delegate_) {
       if (fetcher_->automatically_retry_on_5xx_ &&
-          num_retries_ <= protect_entry_->max_retries()) {
+          num_retries_ <= fetcher_->max_retries()) {
         io_message_loop_proxy_->PostDelayedTask(
             FROM_HERE,
             NewRunnableMethod(this, &Core::StartURLRequest), back_off_time);
       } else {
         delegate_->OnURLFetchComplete(fetcher_, url_, status, response_code_,
                                       cookies_, data_);
       }
     }
   } else {
-    protect_entry_->UpdateBackoff(URLFetcherProtectEntry::SUCCESS);
     if (delegate_) {
       fetcher_->backoff_delay_ = base::TimeDelta();
       delegate_->OnURLFetchComplete(fetcher_, url_, status, response_code_,
                                     cookies_, data_);
     }
   }
 }
 
 void URLFetcher::Core::ReleaseRequest() {
   request_.reset();
   g_registry.Get().RemoveURLFetcherCore(this);
 }
 
 void URLFetcher::set_upload_data(const std::string& upload_content_type,
-                     const std::string& upload_content) {
+                                 const std::string& upload_content) {
   core_->upload_content_type_ = upload_content_type;
   core_->upload_content_ = upload_content;
 }
 
 const std::string& URLFetcher::upload_data() const {
   return core_->upload_content_;
 }
 
 void URLFetcher::set_load_flags(int load_flags) {
   core_->load_flags_ = load_flags;
@@ skipping 31 matching lines @@
 }
 
 // static
 void URLFetcher::CancelAll() {
   Core::CancelAll();
 }
 
 URLFetcher::Delegate* URLFetcher::delegate() const {
   return core_->delegate();
 }