Make URLRequestThrottlerManager a member of URLRequestContext.

content/common/net/url_fetcher_core.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 "content/common/net/url_fetcher_core.h"
 
 #include "base/bind.h"
 #include "base/file_util_proxy.h"
 #include "base/logging.h"
 #include "base/message_loop_proxy.h"
 #include "base/metrics/histogram.h"
 #include "base/stl_util.h"
 #include "base/tracked_objects.h"
 #include "content/public/common/url_fetcher_delegate.h"
 #include "net/base/io_buffer.h"
 #include "net/base/load_flags.h"
 #include "net/base/net_errors.h"
 #include "net/http/http_response_headers.h"
+#include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "net/url_request/url_request_throttler_manager.h"
 
 namespace content {
 
 static const int kBufferSize = 4096;
 static const int kUploadProgressTimerInterval = 100;
 
 URLFetcherCore::Registry::Registry() {}
 URLFetcherCore::Registry::~Registry() {}
@@ skipping 570 matching lines @@
   }
   return write_complete;
 }
 
 void URLFetcherCore::OnReadCompleted(net::URLRequest* request,
                                      int bytes_read) {
   DCHECK(request == request_);
   DCHECK(io_message_loop_proxy_->BelongsToCurrentThread());
 
   url_ = request->url();
-  url_throttler_entry_ =
-      net::URLRequestThrottlerManager::GetInstance()->RegisterRequestUrl(url_);
+  net::URLRequestThrottlerManager* throttler_manager =
+      request->context()->throttler_manager();
+  if (throttler_manager) {
+    url_throttler_entry_ = throttler_manager->RegisterRequestUrl(url_);
+  }
 
   bool waiting_on_write = false;
   do {
     if (!request_->status().is_success() || bytes_read <= 0)
       break;
 
     current_response_bytes_ += bytes_read;
     InformDelegateDownloadProgress();
     InformDelegateDownloadDataIfNecessary(bytes_read);
 
@@ skipping 32 matching lines @@
   DCHECK(io_message_loop_proxy_->BelongsToCurrentThread());
   base::TimeDelta backoff_delay;
 
   // Checks the response from server.
   if (response_code_ >= 500 ||
       status_.error() == net::ERR_TEMPORARILY_THROTTLED) {
     // When encountering a server error, we will send the request again
     // after backoff time.
     ++num_retries_;
 
-    // Note that backoff_delay may be 0 because (a) the URLRequestThrottler
-    // code does not necessarily back off on the first error, and (b) it
-    // only backs off on some of the 5xx status codes.
+    // Note that backoff_delay may be 0 because (a) the
+    // URLRequestThrottler code does not necessarily back off on the

[willchan no longer on Chromium, 2012/05/02 16:40:07]

URLRequestThrottlerManager?

[Jói, 2012/05/02 16:45:28]

Changed to "URLRequestThrottlerManager and related code"

+    // first error, (b) it only backs off on some of the 5xx status
+    // codes, (c) not all URLRequestContexts have a throttler manager.
     base::TimeTicks backoff_release_time = GetBackoffReleaseTime();
     backoff_delay = backoff_release_time - base::TimeTicks::Now();
     if (backoff_delay < base::TimeDelta())
       backoff_delay = base::TimeDelta();
 
     if (automatically_retry_on_5xx_ && num_retries_ <= max_retries_) {
       StartOnIOThread();
       return;
     }
   } else {
@@ skipping 111 matching lines @@
 
   request_->Start();
 }
 
 void URLFetcherCore::StartURLRequestWhenAppropriate() {
   DCHECK(io_message_loop_proxy_->BelongsToCurrentThread());
 
   if (was_cancelled_)
     return;
 
+  DCHECK(request_context_getter_);
+
+  int64 delay = 0LL;
   if (original_url_throttler_entry_ == NULL) {
-    original_url_throttler_entry_ =
-        net::URLRequestThrottlerManager::GetInstance()->RegisterRequestUrl(
-            original_url_);
+    net::URLRequestThrottlerManager* manager =
+        request_context_getter_->GetURLRequestContext()->throttler_manager();
+    if (manager) {
+      original_url_throttler_entry_ =
+          manager->RegisterRequestUrl(original_url_);
+    }
+  }
+  if (original_url_throttler_entry_ != NULL) {
+    delay = original_url_throttler_entry_->ReserveSendingTimeForNextRequest(
+        GetBackoffReleaseTime());
   }
 
-  int64 delay = original_url_throttler_entry_->ReserveSendingTimeForNextRequest(
-      GetBackoffReleaseTime());
   if (delay == 0) {
     StartURLRequest();
   } else {
     MessageLoop::current()->PostDelayedTask(
         FROM_HERE, base::Bind(&URLFetcherCore::StartURLRequest, this),
         base::TimeDelta::FromMilliseconds(delay));
   }
 }
 
 void URLFetcherCore::CancelURLRequest() {
@@ skipping 110 matching lines @@
 }
 
 void URLFetcherCore::ReleaseRequest() {
   upload_progress_checker_timer_.reset();
   request_.reset();
   g_registry.Get().RemoveURLFetcherCore(this);
 }
 
 base::TimeTicks URLFetcherCore::GetBackoffReleaseTime() {
   DCHECK(io_message_loop_proxy_->BelongsToCurrentThread());
-  DCHECK(original_url_throttler_entry_ != NULL);
 
-  base::TimeTicks original_url_backoff =
-      original_url_throttler_entry_->GetExponentialBackoffReleaseTime();
-  base::TimeTicks destination_url_backoff;
-  if (url_throttler_entry_ != NULL &&
-      original_url_throttler_entry_ != url_throttler_entry_) {
-    destination_url_backoff =
-        url_throttler_entry_->GetExponentialBackoffReleaseTime();
+  if (original_url_throttler_entry_) {
+    base::TimeTicks original_url_backoff =
+        original_url_throttler_entry_->GetExponentialBackoffReleaseTime();
+    base::TimeTicks destination_url_backoff;
+    if (url_throttler_entry_ != NULL &&
+        original_url_throttler_entry_ != url_throttler_entry_) {
+      destination_url_backoff =
+          url_throttler_entry_->GetExponentialBackoffReleaseTime();
+    }
+
+    return original_url_backoff > destination_url_backoff ?
+        original_url_backoff : destination_url_backoff;
+  } else {
+    return base::TimeTicks();
   }
-
-  return original_url_backoff > destination_url_backoff ?
-      original_url_backoff : destination_url_backoff;
 }
 
 }  // namespace content