Add a ResourceScheduler to ResourceDispatcherHost.

content/browser/renderer_host/resource_loader_impl.cc

Index: content/browser/renderer_host/resource_loader_impl.cc
diff --git a/content/browser/renderer_host/resource_loader.cc b/content/browser/renderer_host/resource_loader_impl.cc
similarity index 84%
rename from content/browser/renderer_host/resource_loader.cc
rename to content/browser/renderer_host/resource_loader_impl.cc
index be893d7c97440ff2068932fe1b17f50374fdd48b..50a8e16dedaf43ece67d13446d1007fb8071d199 100644
--- a/content/browser/renderer_host/resource_loader.cc
+++ b/content/browser/renderer_host/resource_loader_impl.cc
@@ -2,13 +2,13 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "content/browser/renderer_host/resource_loader.h"
+#include "content/browser/renderer_host/resource_loader_impl.h"
 
 #include "base/message_loop.h"
 #include "base/time.h"
 #include "content/browser/child_process_security_policy_impl.h"
 #include "content/browser/renderer_host/doomed_resource_handler.h"
-#include "content/browser/renderer_host/resource_loader_delegate.h"
+#include "content/browser/renderer_host/resource_loader_impl_delegate.h"
 #include "content/browser/renderer_host/resource_request_info_impl.h"
 #include "content/browser/ssl/ssl_client_auth_handler.h"
 #include "content/browser/ssl/ssl_manager.h"
@@ -50,9 +50,9 @@ void PopulateResourceResponse(net::URLRequest* request,
 
 }  // namespace
 
-ResourceLoader::ResourceLoader(scoped_ptr<net::URLRequest> request,
-                               scoped_ptr<ResourceHandler> handler,
-                               ResourceLoaderDelegate* delegate)
+ResourceLoaderImpl::ResourceLoaderImpl(scoped_ptr<net::URLRequest> request,
+                                       scoped_ptr<ResourceHandler> handler,
+                                       ResourceLoaderImplDelegate* delegate)
     : deferred_stage_(DEFERRED_NONE),
       request_(request.Pass()),
       handler_(handler.Pass()),
@@ -65,7 +65,7 @@ ResourceLoader::ResourceLoader(scoped_ptr<net::URLRequest> request,
   handler_->SetController(this);
 }
 
-ResourceLoader::~ResourceLoader() {
+ResourceLoaderImpl::~ResourceLoaderImpl() {
   if (login_delegate_)
     login_delegate_->OnRequestCancelled();
   if (ssl_client_auth_handler_)
@@ -76,7 +76,7 @@ ResourceLoader::~ResourceLoader() {
   handler_.reset();
 }
 
-void ResourceLoader::StartRequest() {
+void ResourceLoaderImpl::StartRequest() {
   if (delegate_->HandleExternalProtocol(this, request_->url())) {
     CancelAndIgnore();
     return;
@@ -97,21 +97,21 @@ void ResourceLoader::StartRequest() {
   }
 }
 
-void ResourceLoader::CancelRequest(bool from_renderer) {
+void ResourceLoaderImpl::CancelRequest(bool from_renderer) {
   CancelRequestInternal(net::ERR_ABORTED, from_renderer);
 }
 
-void ResourceLoader::CancelAndIgnore() {
+void ResourceLoaderImpl::CancelAndIgnore() {
   ResourceRequestInfoImpl* info = GetRequestInfo();
   info->set_was_ignored_by_handler(true);
   CancelRequest(false);
 }
 
-void ResourceLoader::CancelWithError(int error_code) {
+void ResourceLoaderImpl::CancelWithError(int error_code) {
   CancelRequestInternal(error_code, false);
 }
 
-void ResourceLoader::ReportUploadProgress() {
+void ResourceLoaderImpl::ReportUploadProgress() {
   ResourceRequestInfoImpl* info = GetRequestInfo();
 
   if (waiting_for_upload_progress_ack_)
@@ -146,7 +146,7 @@ void ResourceLoader::ReportUploadProgress() {
   }
 }
 
-void ResourceLoader::MarkAsTransferring() {
+void ResourceLoaderImpl::MarkAsTransferring() {
   is_transferring_ = true;
 
   // When an URLRequest is transferred to a new RenderViewHost, its
@@ -159,11 +159,12 @@ void ResourceLoader::MarkAsTransferring() {
   handler_.reset(new DoomedResourceHandler(handler_.Pass()));
 }
 
-void ResourceLoader::WillCompleteTransfer() {
+void ResourceLoaderImpl::WillCompleteTransfer() {
   handler_.reset();
 }
 
-void ResourceLoader::CompleteTransfer(scoped_ptr<ResourceHandler> new_handler) {
+void ResourceLoaderImpl::CompleteTransfer(
+    scoped_ptr<ResourceHandler> new_handler) {
   DCHECK_EQ(DEFERRED_REDIRECT, deferred_stage_);
   DCHECK(!handler_.get());
 
@@ -174,25 +175,25 @@ void ResourceLoader::CompleteTransfer(scoped_ptr<ResourceHandler> new_handler) {
   Resume();
 }
 
-ResourceRequestInfoImpl* ResourceLoader::GetRequestInfo() {
+ResourceRequestInfoImpl* ResourceLoaderImpl::GetRequestInfo() {
   return ResourceRequestInfoImpl::ForRequest(request_.get());
 }
 
-void ResourceLoader::ClearLoginDelegate() {
+void ResourceLoaderImpl::ClearLoginDelegate() {
   login_delegate_ = NULL;
 }
 
-void ResourceLoader::ClearSSLClientAuthHandler() {
+void ResourceLoaderImpl::ClearSSLClientAuthHandler() {
   ssl_client_auth_handler_ = NULL;
 }
 
-void ResourceLoader::OnUploadProgressACK() {
+void ResourceLoaderImpl::OnUploadProgressACK() {
   waiting_for_upload_progress_ack_ = false;
 }
 
-void ResourceLoader::OnReceivedRedirect(net::URLRequest* unused,
-                                        const GURL& new_url,
-                                        bool* defer) {
+void ResourceLoaderImpl::OnReceivedRedirect(net::URLRequest* unused,
+                                            const GURL& new_url,
+                                            bool* defer) {
   DCHECK_EQ(request_.get(), unused);
 
   VLOG(1) << "OnReceivedRedirect: " << request_->url().spec();
@@ -230,8 +231,8 @@ void ResourceLoader::OnReceivedRedirect(net::URLRequest* unused,
   }
 }
 
-void ResourceLoader::OnAuthRequired(net::URLRequest* unused,
-                                    net::AuthChallengeInfo* auth_info) {
+void ResourceLoaderImpl::OnAuthRequired(net::URLRequest* unused,
+                                        net::AuthChallengeInfo* auth_info) {
   DCHECK_EQ(request_.get(), unused);
 
   if (request_->load_flags() & net::LOAD_DO_NOT_PROMPT_FOR_LOGIN) {
@@ -254,7 +255,7 @@ void ResourceLoader::OnAuthRequired(net::URLRequest* unused,
     request_->CancelAuth();
 }
 
-void ResourceLoader::OnCertificateRequested(
+void ResourceLoaderImpl::OnCertificateRequested(
     net::URLRequest* unused,
     net::SSLCertRequestInfo* cert_info) {
   DCHECK_EQ(request_.get(), unused);
@@ -277,9 +278,9 @@ void ResourceLoader::OnCertificateRequested(
   ssl_client_auth_handler_->SelectCertificate();
 }
 
-void ResourceLoader::OnSSLCertificateError(net::URLRequest* request,
-                                           const net::SSLInfo& ssl_info,
-                                           bool fatal) {
+void ResourceLoaderImpl::OnSSLCertificateError(net::URLRequest* request,
+                                               const net::SSLInfo& ssl_info,
+                                               bool fatal) {
   ResourceRequestInfoImpl* info = GetRequestInfo();
 
   int render_process_id;
@@ -298,7 +299,7 @@ void ResourceLoader::OnSSLCertificateError(net::URLRequest* request,
       fatal);
 }
 
-void ResourceLoader::OnResponseStarted(net::URLRequest* unused) {
+void ResourceLoaderImpl::OnResponseStarted(net::URLRequest* unused) {
   DCHECK_EQ(request_.get(), unused);
 
   VLOG(1) << "OnResponseStarted: " << request_->url().spec();
@@ -326,7 +327,8 @@ void ResourceLoader::OnResponseStarted(net::URLRequest* unused) {
   }
 }
 
-void ResourceLoader::OnReadCompleted(net::URLRequest* unused, int bytes_read) {
+void ResourceLoaderImpl::OnReadCompleted(net::URLRequest* unused,
+                                         int bytes_read) {
   DCHECK_EQ(request_.get(), unused);
   VLOG(1) << "OnReadCompleted: \"" << request_->url().spec() << "\""
           << " bytes_read = " << bytes_read;
@@ -349,9 +351,9 @@ void ResourceLoader::OnReadCompleted(net::URLRequest* unused, int bytes_read) {
   }
 }
 
-void ResourceLoader::CancelSSLRequest(const GlobalRequestID& id,
-                                      int error,
-                                      const net::SSLInfo* ssl_info) {
+void ResourceLoaderImpl::CancelSSLRequest(const GlobalRequestID& id,
+                                          int error,
+                                          const net::SSLInfo* ssl_info) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   // The request can be NULL if it was cancelled by the renderer (as the
@@ -367,7 +369,7 @@ void ResourceLoader::CancelSSLRequest(const GlobalRequestID& id,
   }
 }
 
-void ResourceLoader::ContinueSSLRequest(const GlobalRequestID& id) {
+void ResourceLoaderImpl::ContinueSSLRequest(const GlobalRequestID& id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   DVLOG(1) << "ContinueSSLRequest() url: " << request_->url().spec();
@@ -375,7 +377,7 @@ void ResourceLoader::ContinueSSLRequest(const GlobalRequestID& id) {
   request_->ContinueDespiteLastError();
 }
 
-void ResourceLoader::Resume() {
+void ResourceLoaderImpl::Resume() {
   DCHECK(!is_transferring_);
 
   DeferredStage stage = deferred_stage_;
@@ -393,31 +395,31 @@ void ResourceLoader::Resume() {
     case DEFERRED_READ:
       MessageLoop::current()->PostTask(
           FROM_HERE,
-          base::Bind(&ResourceLoader::ResumeReading,
+          base::Bind(&ResourceLoaderImpl::ResumeReading,
                      weak_ptr_factory_.GetWeakPtr()));
       break;
     case DEFERRED_FINISH:
       // Delay self-destruction since we don't know how we were reached.
       MessageLoop::current()->PostTask(
           FROM_HERE,
-          base::Bind(&ResourceLoader::CallDidFinishLoading,
+          base::Bind(&ResourceLoaderImpl::CallDidFinishLoading,
                      weak_ptr_factory_.GetWeakPtr()));
       break;
   }
 }
 
-void ResourceLoader::Cancel() {
+void ResourceLoaderImpl::Cancel() {
   CancelRequest(false);
 }
 
-void ResourceLoader::StartRequestInternal() {
+void ResourceLoaderImpl::StartRequestInternal() {
   DCHECK(!request_->is_pending());
   request_->Start();
 
   delegate_->DidStartRequest(this);
 }
 
-void ResourceLoader::CancelRequestInternal(int error, bool from_renderer) {
+void ResourceLoaderImpl::CancelRequestInternal(int error, bool from_renderer) {
   VLOG(1) << "CancelRequestInternal: " << request_->url().spec();
 
   ResourceRequestInfoImpl* info = GetRequestInfo();
@@ -448,12 +450,12 @@ void ResourceLoader::CancelRequestInternal(int error, bool from_renderer) {
     // notification from the request, so we have to signal ourselves to finish
     // this request.
     MessageLoop::current()->PostTask(
-        FROM_HERE, base::Bind(&ResourceLoader::ResponseCompleted,
+        FROM_HERE, base::Bind(&ResourceLoaderImpl::ResponseCompleted,
                               weak_ptr_factory_.GetWeakPtr()));
   }
 }
 
-void ResourceLoader::CompleteResponseStarted() {
+void ResourceLoaderImpl::CompleteResponseStarted() {
   ResourceRequestInfoImpl* info = GetRequestInfo();
 
   scoped_refptr<ResourceResponse> response(new ResourceResponse());
@@ -485,7 +487,7 @@ void ResourceLoader::CompleteResponseStarted() {
   }
 }
 
-void ResourceLoader::StartReading(bool is_continuation) {
+void ResourceLoaderImpl::StartReading(bool is_continuation) {
   int bytes_read = 0;
   ReadMore(&bytes_read);
 
@@ -500,13 +502,13 @@ void ResourceLoader::StartReading(bool is_continuation) {
     // thread in case the URLRequest can provide data synchronously.
     MessageLoop::current()->PostTask(
         FROM_HERE,
-        base::Bind(&ResourceLoader::OnReadCompleted,
+        base::Bind(&ResourceLoaderImpl::OnReadCompleted,
                    weak_ptr_factory_.GetWeakPtr(),
                    request_.get(), bytes_read));
   }
 }
 
-void ResourceLoader::ResumeReading() {
+void ResourceLoaderImpl::ResumeReading() {
   DCHECK(!is_deferred());
 
   if (request_->status().is_success()) {
@@ -516,7 +518,7 @@ void ResourceLoader::ResumeReading() {
   }
 }
 
-void ResourceLoader::ReadMore(int* bytes_read) {
+void ResourceLoaderImpl::ReadMore(int* bytes_read) {
   ResourceRequestInfoImpl* info = GetRequestInfo();
   DCHECK(!is_deferred());
 
@@ -536,7 +538,7 @@ void ResourceLoader::ReadMore(int* bytes_read) {
   // inspecting the URLRequest's status.
 }
 
-void ResourceLoader::CompleteRead(int bytes_read) {
+void ResourceLoaderImpl::CompleteRead(int bytes_read) {
   DCHECK(bytes_read >= 0);
   DCHECK(request_->status().is_success());
 
@@ -550,7 +552,7 @@ void ResourceLoader::CompleteRead(int bytes_read) {
   }
 }
 
-void ResourceLoader::ResponseCompleted() {
+void ResourceLoaderImpl::ResponseCompleted() {
   VLOG(1) << "ResponseCompleted: " << request_->url().spec();
   ResourceRequestInfoImpl* info = GetRequestInfo();
 
@@ -575,7 +577,7 @@ void ResourceLoader::ResponseCompleted() {
   }
 }
 
-void ResourceLoader::CallDidFinishLoading() {
+void ResourceLoaderImpl::CallDidFinishLoading() {
   delegate_->DidFinishLoading(this);
 }