Add a ResourceScheduler to ResourceDispatcherHost.

content/browser/renderer_host/resource_dispatcher_host_impl.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.
 
 // See http://dev.chromium.org/developers/design-documents/multi-process-resource-loading
 
 #include "content/browser/renderer_host/resource_dispatcher_host_impl.h"
 
 #include <set>
 #include <vector>
@@ skipping 20 matching lines @@
 #include "content/browser/fileapi/chrome_blob_storage_context.h"
 #include "content/browser/plugin_service_impl.h"
 #include "content/browser/renderer_host/async_resource_handler.h"
 #include "content/browser/renderer_host/buffered_resource_handler.h"
 #include "content/browser/renderer_host/cross_site_resource_handler.h"
 #include "content/browser/renderer_host/redirect_to_file_resource_handler.h"
 #include "content/browser/renderer_host/render_view_host_delegate.h"
 #include "content/browser/renderer_host/render_view_host_impl.h"
 #include "content/browser/renderer_host/resource_message_filter.h"
 #include "content/browser/renderer_host/resource_request_info_impl.h"
+#include "content/browser/renderer_host/resource_scheduler.h"
 #include "content/browser/renderer_host/sync_resource_handler.h"
 #include "content/browser/renderer_host/throttling_resource_handler.h"
 #include "content/browser/renderer_host/transfer_navigation_resource_throttle.h"
 #include "content/browser/resource_context_impl.h"
 #include "content/browser/worker_host/worker_service_impl.h"
 #include "content/common/resource_messages.h"
 #include "content/common/ssl_status_serialization.h"
 #include "content/common/view_messages.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/content_browser_client.h"
@@ skipping 300 matching lines @@
 }
 
 ResourceDispatcherHostImpl::ResourceDispatcherHostImpl()
     : save_file_manager_(new SaveFileManager()),
       request_id_(-1),
       is_shutdown_(false),
       max_outstanding_requests_cost_per_process_(
           kMaxOutstandingRequestsCostPerProcess),
       filter_(NULL),
       delegate_(NULL),
-      allow_cross_origin_auth_prompt_(false) {
+      allow_cross_origin_auth_prompt_(false),
+      resource_scheduler_(new ResourceScheduler()) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!g_resource_dispatcher_host);
   g_resource_dispatcher_host = this;
 
   GetContentClient()->browser()->ResourceDispatcherHostCreated();
 
   ANNOTATE_BENIGN_RACE(
       &last_user_gesture_time_,
       "We don't care about the precise value, see http://crbug.com/92889");
 
@@ skipping 38 matching lines @@
     ResourceContext* context) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK(context);
 
   CHECK(ContainsKey(active_resource_contexts_, context));
 
   // Note that request cancellation has side effects. Therefore, we gather all
   // the requests to cancel first, and then we start cancelling. We assert at
   // the end that there are no more to cancel since the context is about to go
   // away.
-  typedef std::vector<linked_ptr<ResourceLoader> > LoaderList;
+  typedef std::vector<linked_ptr<ResourceLoaderImpl> > LoaderList;
   LoaderList loaders_to_cancel;
 
   for (LoaderMap::iterator i = pending_loaders_.begin();
        i != pending_loaders_.end();) {
     if (i->second->GetRequestInfo()->GetContext() == context) {
       loaders_to_cancel.push_back(i->second);
       pending_loaders_.erase(i++);
     } else {
       ++i;
     }
   }
 
   for (BlockedLoadersMap::iterator i = blocked_loaders_map_.begin();
        i != blocked_loaders_map_.end();) {
     BlockedLoadersList* loaders = i->second;
     if (loaders->empty()) {
       // This can happen if BlockRequestsForRoute() has been called for a route,
       // but we haven't blocked any matching requests yet.
       ++i;
       continue;
     }
     ResourceRequestInfoImpl* info = loaders->front()->GetRequestInfo();
     if (info->GetContext() == context) {
       blocked_loaders_map_.erase(i++);
       for (BlockedLoadersList::const_iterator it = loaders->begin();
            it != loaders->end(); ++it) {
-        linked_ptr<ResourceLoader> loader = *it;
+        linked_ptr<ResourceLoaderImpl> loader = *it;
         info = loader->GetRequestInfo();
         // We make the assumption that all requests on the list have the same
         // ResourceContext.
         DCHECK_EQ(context, info->GetContext());
         IncrementOutstandingRequestsMemoryCost(-1 * info->memory_cost(),
                                                info->GetChildID());
         loaders_to_cancel.push_back(loader);
       }
       delete loaders;
     } else {
@@ skipping 97 matching lines @@
 
   BeginRequestInternal(request.Pass(), handler.Pass());
 
   return net::OK;
 }
 
 void ResourceDispatcherHostImpl::ClearLoginDelegateForRequest(
     net::URLRequest* request) {
   ResourceRequestInfoImpl* info = ResourceRequestInfoImpl::ForRequest(request);
   if (info) {
-    ResourceLoader* loader = GetLoader(info->GetGlobalRequestID());
+    ResourceLoaderImpl* loader = GetLoader(info->GetGlobalRequestID());
     if (loader)
       loader->ClearLoginDelegate();
   }
 }
 
 void ResourceDispatcherHostImpl::Shutdown() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   BrowserThread::PostTask(BrowserThread::IO,
                           FROM_HERE,
                           base::Bind(&ResourceDispatcherHostImpl::OnShutdown,
@@ skipping 24 matching lines @@
               request_info->GetRequestID(), throttles.Pass()));
     }
   }
   return handler.Pass();
 }
 
 void ResourceDispatcherHostImpl::ClearSSLClientAuthHandlerForRequest(
     net::URLRequest* request) {
   ResourceRequestInfoImpl* info = ResourceRequestInfoImpl::ForRequest(request);
   if (info) {
-    ResourceLoader* loader = GetLoader(info->GetGlobalRequestID());
+    ResourceLoaderImpl* loader = GetLoader(info->GetGlobalRequestID());
     if (loader)
       loader->ClearSSLClientAuthHandler();
   }
 }
 
 ResourceDispatcherHostLoginDelegate*
 ResourceDispatcherHostImpl::CreateLoginDelegate(
-    ResourceLoader* loader,
+    ResourceLoaderImpl* loader,
     net::AuthChallengeInfo* auth_info) {
   if (!delegate_)
     return NULL;
 
   return delegate_->CreateLoginDelegate(auth_info, loader->request());
 }
 
 bool ResourceDispatcherHostImpl::AcceptAuthRequest(
-    ResourceLoader* loader,
+    ResourceLoaderImpl* loader,
     net::AuthChallengeInfo* auth_info) {
   if (delegate_ && !delegate_->AcceptAuthRequest(loader->request(), auth_info))
     return false;
 
   // Prevent third-party content from prompting for login, unless it is
   // a proxy that is trying to authenticate.  This is often the foundation
   // of a scam to extract credentials for another domain from the user.
   if (!auth_info->is_proxy) {
     HttpAuthResourceType resource_type =
         HttpAuthResourceTypeOf(loader->request());
     UMA_HISTOGRAM_ENUMERATION("Net.HttpAuthResource",
                               resource_type,
                               HTTP_AUTH_RESOURCE_LAST);
 
     if (resource_type == HTTP_AUTH_RESOURCE_BLOCKED_CROSS)
       return false;
   }
 
   return true;
 }
 
 bool ResourceDispatcherHostImpl::AcceptSSLClientCertificateRequest(
-    ResourceLoader* loader,
+    ResourceLoaderImpl* loader,
     net::SSLCertRequestInfo* cert_info) {
   if (delegate_ && !delegate_->AcceptSSLClientCertificateRequest(
           loader->request(), cert_info)) {
     return false;
   }
 
   return true;
 }
 
-bool ResourceDispatcherHostImpl::HandleExternalProtocol(ResourceLoader* loader,
-                                                        const GURL& url) {
+bool ResourceDispatcherHostImpl::HandleExternalProtocol(
+    ResourceLoaderImpl* loader,
+    const GURL& url) {
   if (!delegate_)
     return false;
 
   ResourceRequestInfoImpl* info = loader->GetRequestInfo();
 
   if (!ResourceType::IsFrame(info->GetResourceType()))
     return false;
 
   const net::URLRequestJobFactory* job_factory =
       info->GetContext()->GetRequestContext()->job_factory();
   if (job_factory->IsHandledURL(url))
     return false;
 
   delegate_->HandleExternalProtocol(url, info->GetChildID(),
                                     info->GetRouteID());
   return true;
 }
 
-void ResourceDispatcherHostImpl::DidStartRequest(ResourceLoader* loader) {
+void ResourceDispatcherHostImpl::DidStartRequest(ResourceLoaderImpl* loader) {
   // Make sure we have the load state monitor running
   if (!update_load_states_timer_->IsRunning()) {
     update_load_states_timer_->Start(FROM_HERE,
         TimeDelta::FromMilliseconds(kUpdateLoadStatesIntervalMsec),
         this, &ResourceDispatcherHostImpl::UpdateLoadStates);
   }
 }
 
-void ResourceDispatcherHostImpl::DidReceiveRedirect(ResourceLoader* loader,
+void ResourceDispatcherHostImpl::DidReceiveRedirect(ResourceLoaderImpl* loader,
                                                     const GURL& new_url) {
   ResourceRequestInfoImpl* info = loader->GetRequestInfo();
 
   int render_process_id, render_view_id;
   if (!info->GetAssociatedRenderView(&render_process_id, &render_view_id))
     return;
 
   // Notify the observers on the UI thread.
   scoped_ptr<ResourceRedirectDetails> detail(new ResourceRedirectDetails(
       loader->request(),
       GetCertID(loader->request(), info->GetChildID()),
       new_url));
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(
           &NotifyOnUI<ResourceRedirectDetails>,
           static_cast<int>(NOTIFICATION_RESOURCE_RECEIVED_REDIRECT),
           render_process_id, render_view_id, base::Passed(&detail)));
 }
 
-void ResourceDispatcherHostImpl::DidReceiveResponse(ResourceLoader* loader) {
+void ResourceDispatcherHostImpl::DidReceiveResponse(
+    ResourceLoaderImpl* loader) {
   ResourceRequestInfoImpl* info = loader->GetRequestInfo();
 
   int render_process_id, render_view_id;
   if (!info->GetAssociatedRenderView(&render_process_id, &render_view_id))
     return;
 
   // Notify the observers on the UI thread.
   scoped_ptr<ResourceRequestDetails> detail(new ResourceRequestDetails(
       loader->request(),
       GetCertID(loader->request(), info->GetChildID())));
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(
           &NotifyOnUI<ResourceRequestDetails>,
           static_cast<int>(NOTIFICATION_RESOURCE_RESPONSE_STARTED),
           render_process_id, render_view_id, base::Passed(&detail)));
 }
 
-void ResourceDispatcherHostImpl::DidFinishLoading(ResourceLoader* loader) {
+void ResourceDispatcherHostImpl::DidFinishLoading(ResourceLoaderImpl* loader) {
   ResourceRequestInfo* info = loader->GetRequestInfo();
 
   // Record final result of all resource loads.
   if (info->GetResourceType() == ResourceType::MAIN_FRAME) {
     // This enumeration has "3" appended to its name to distinguish it from
     // older versions.
     UMA_HISTOGRAM_CUSTOM_ENUMERATION(
         "Net.ErrorCodesForMainFrame3",
         -loader->request()->status().error(),
         base::CustomHistogram::ArrayToCustomRanges(
@@ skipping 129 matching lines @@
   int child_id = filter_->child_id();
 
   // If we crash here, figure out what URL the renderer was requesting.
   // http://crbug.com/91398
   char url_buf[128];
   base::strlcpy(url_buf, request_data.url.spec().c_str(), arraysize(url_buf));
   base::debug::Alias(url_buf);
 
   // If the request that's coming in is being transferred from another process,
   // we want to reuse and resume the old loader rather than start a new one.
-  linked_ptr<ResourceLoader> deferred_loader;
+  linked_ptr<ResourceLoaderImpl> deferred_loader;
   {
     LoaderMap::iterator it = pending_loaders_.find(
         GlobalRequestID(request_data.transferred_request_child_id,
                         request_data.transferred_request_request_id));
     if (it != pending_loaders_.end()) {
       if (it->second->is_transferring()) {
         deferred_loader = it->second;
         pending_loaders_.erase(it);
       } else {
         RecordAction(UserMetricsAction("BadMessageTerminate_RDH"));
@@ skipping 174 matching lines @@
   } else {
     BeginRequestInternal(new_request.Pass(), handler.Pass());
   }
 }
 
 void ResourceDispatcherHostImpl::OnReleaseDownloadedFile(int request_id) {
   UnregisterDownloadedTempFile(filter_->child_id(), request_id);
 }
 
 void ResourceDispatcherHostImpl::OnDataReceivedACK(int request_id) {
-  ResourceLoader* loader = GetLoader(filter_->child_id(), request_id);
+  ResourceLoaderImpl* loader = GetLoader(filter_->child_id(), request_id);
   if (!loader)
     return;
 
   ResourceRequestInfoImpl* info = loader->GetRequestInfo();
   if (info->async_handler())
     info->async_handler()->OnDataReceivedACK();
 }
 
 void ResourceDispatcherHostImpl::OnDataDownloadedACK(int request_id) {
   // TODO(michaeln): maybe throttle DataDownloaded messages
@@ skipping 30 matching lines @@
   // Note that we don't remove the security bits here. This will be done
   // when all file refs are deleted (see RegisterDownloadedTempFile).
 }
 
 bool ResourceDispatcherHostImpl::Send(IPC::Message* message) {
   delete message;
   return false;
 }
 
 void ResourceDispatcherHostImpl::OnUploadProgressACK(int request_id) {
-  ResourceLoader* loader = GetLoader(filter_->child_id(), request_id);
+  ResourceLoaderImpl* loader = GetLoader(filter_->child_id(), request_id);
   if (loader)
     loader->OnUploadProgressACK();
 }
 
 void ResourceDispatcherHostImpl::OnCancelRequest(int request_id) {
   CancelRequest(filter_->child_id(), request_id, true);
 }
 
 void ResourceDispatcherHostImpl::OnFollowRedirect(
     int request_id,
     bool has_new_first_party_for_cookies,
     const GURL& new_first_party_for_cookies) {
-  ResourceLoader* loader = GetLoader(filter_->child_id(), request_id);
+  ResourceLoaderImpl* loader = GetLoader(filter_->child_id(), request_id);
   if (!loader) {
     DVLOG(1) << "OnFollowRedirect for invalid request";
     return;
   }
 
   ResourceRequestInfoImpl* info = loader->GetRequestInfo();
   if (info->async_handler()) {
     info->async_handler()->OnFollowRedirect(
         has_new_first_party_for_cookies,
         new_first_party_for_cookies);
@@ skipping 33 matching lines @@
 void ResourceDispatcherHostImpl::OnSimulateSwapOutACK(
     const ViewMsg_SwapOut_Params& params) {
   // Call the real implementation with true, which means that we timed out.
   HandleSwapOutACK(params, true);
 }
 
 void ResourceDispatcherHostImpl::HandleSwapOutACK(
     const ViewMsg_SwapOut_Params& params, bool timed_out) {
   // Closes for cross-site transitions are handled such that the cross-site
   // transition continues.
-  ResourceLoader* loader = GetLoader(params.new_render_process_host_id,
-                                     params.new_request_id);
+  ResourceLoaderImpl* loader = GetLoader(params.new_render_process_host_id,
+                                         params.new_request_id);
   if (loader) {
     // The response we were meant to resume could have already been canceled.
     ResourceRequestInfoImpl* info = loader->GetRequestInfo();
     if (info->cross_site_handler())
       info->cross_site_handler()->ResumeResponse();
   }
 
   // Update the RenderViewHost's internal state after the ACK.
   BrowserThread::PostTask(
       BrowserThread::UI,
@@ skipping 171 matching lines @@
 
 void ResourceDispatcherHostImpl::RemovePendingLoader(
     const LoaderMap::iterator& iter) {
   ResourceRequestInfoImpl* info = iter->second->GetRequestInfo();
 
   // Remove the memory credit that we added when pushing the request onto
   // the pending list.
   IncrementOutstandingRequestsMemoryCost(-1 * info->memory_cost(),
                                          info->GetChildID());
 
+  resource_scheduler_->RemoveLoad(
+      info->GetChildID(), info->GetRouteID(), info->GetRequestID());
   pending_loaders_.erase(iter);
 
   // If we have no more pending requests, then stop the load state monitor
   if (pending_loaders_.empty() && update_load_states_timer_.get())
     update_load_states_timer_->Stop();
 }
 
 void ResourceDispatcherHostImpl::CancelRequest(int child_id,
                                                int request_id,
                                                bool from_renderer) {
   if (from_renderer) {
     // When the old renderer dies, it sends a message to us to cancel its
     // requests.
     if (IsTransferredNavigation(GlobalRequestID(child_id, request_id)))
       return;
   }
 
-  ResourceLoader* loader = GetLoader(child_id, request_id);
+  ResourceLoaderImpl* loader = GetLoader(child_id, request_id);
   if (!loader) {
     // We probably want to remove this warning eventually, but I wanted to be
     // able to notice when this happens during initial development since it
     // should be rare and may indicate a bug.
     DVLOG(1) << "Canceling a request that wasn't found";
     return;
   }
 
   loader->CancelRequest(from_renderer);
 }
@@ skipping 67 matching lines @@
     }
 
     IncrementOutstandingRequestsMemoryCost(-1 * info->memory_cost(),
                                            info->GetChildID());
 
     // A ResourceHandler must not outlive its associated URLRequest.
     handler.reset();
     return;
   }
 
-  linked_ptr<ResourceLoader> loader(
-      new ResourceLoader(request.Pass(), handler.Pass(), this));
+  linked_ptr<ResourceLoaderImpl> loader(
+      new ResourceLoaderImpl(request.Pass(), handler.Pass(), this));
 
   ProcessRouteIDs pair_id(info->GetChildID(), info->GetRouteID());
   BlockedLoadersMap::const_iterator iter = blocked_loaders_map_.find(pair_id);
   if (iter != blocked_loaders_map_.end()) {
     // The request should be blocked.
     iter->second->push_back(loader);
     return;
   }
 
   StartLoading(info, loader);
 }
 
 void ResourceDispatcherHostImpl::StartLoading(
     ResourceRequestInfoImpl* info,
-    const linked_ptr<ResourceLoader>& loader) {
+    const linked_ptr<ResourceLoaderImpl>& loader) {
   pending_loaders_[info->GetGlobalRequestID()] = loader;
-
-  loader->StartRequest();
+  resource_scheduler_->ScheduleLoad(info->GetChildID(), info->GetRouteID(),
+                                    info->GetRequestID(), loader.get());
 }
 
 void ResourceDispatcherHostImpl::OnUserGesture(WebContentsImpl* contents) {
   last_user_gesture_time_ = TimeTicks::Now();
 }
 
 net::URLRequest* ResourceDispatcherHostImpl::GetURLRequest(
     const GlobalRequestID& id) {
-  ResourceLoader* loader = GetLoader(id);
+  ResourceLoaderImpl* loader = GetLoader(id);
   if (!loader)
     return NULL;
 
   return loader->request();
 }
 
 namespace {
 
 // This function attempts to return the "more interesting" load state of |a|
 // and |b|.  We don't have temporal information about these load states
@@ skipping 136 matching lines @@
     return;
   }
 
   BlockedLoadersList* loaders = iter->second;
 
   // Removing the vector from the map unblocks any subsequent requests.
   blocked_loaders_map_.erase(iter);
 
   for (BlockedLoadersList::iterator loaders_iter = loaders->begin();
        loaders_iter != loaders->end(); ++loaders_iter) {
-    linked_ptr<ResourceLoader> loader = *loaders_iter;
+    linked_ptr<ResourceLoaderImpl> loader = *loaders_iter;
     ResourceRequestInfoImpl* info = loader->GetRequestInfo();
     if (cancel_requests) {
       IncrementOutstandingRequestsMemoryCost(-1 * info->memory_cost(),
                                              info->GetChildID());
     } else {
       StartLoading(info, loader);
     }
   }
 
   delete loaders;
@@ skipping 15 matching lines @@
 
   return HTTP_AUTH_RESOURCE_BLOCKED_CROSS;
 }
 
 bool ResourceDispatcherHostImpl::allow_cross_origin_auth_prompt() {
   return allow_cross_origin_auth_prompt_;
 }
 
 bool ResourceDispatcherHostImpl::IsTransferredNavigation(
     const GlobalRequestID& id) const {
-  ResourceLoader* loader = GetLoader(id);
+  ResourceLoaderImpl* loader = GetLoader(id);
   return loader ? loader->is_transferring() : false;
 }
 
-ResourceLoader* ResourceDispatcherHostImpl::GetLoader(
+ResourceLoaderImpl* ResourceDispatcherHostImpl::GetLoader(
     const GlobalRequestID& id) const {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   LoaderMap::const_iterator i = pending_loaders_.find(id);
   if (i == pending_loaders_.end())
     return NULL;
 
   return i->second.get();
 }
 
-ResourceLoader* ResourceDispatcherHostImpl::GetLoader(int child_id,
-                                                      int request_id) const {
+ResourceLoaderImpl* ResourceDispatcherHostImpl::GetLoader(
+    int child_id, int request_id) const {
   return GetLoader(GlobalRequestID(child_id, request_id));
 }
 
 }  // namespace content